1/*
2 *  Licensed to the Apache Software Foundation (ASF) under one or more
3 *  contributor license agreements.  See the NOTICE file distributed with
4 *  this work for additional information regarding copyright ownership.
5 *  The ASF licenses this file to You under the Apache License, Version 2.0
6 *  (the "License"); you may not use this file except in compliance with
7 *  the License.  You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 *  Unless required by applicable law or agreed to in writing, software
12 *  distributed under the License is distributed on an "AS IS" BASIS,
13 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 *  See the License for the specific language governing permissions and
15 *  limitations under the License.
16 */
17
18package org.apache.harmony.luni.tests.java.util;
19
20import java.io.Serializable;
21import java.util.ArrayDeque;
22import java.util.ArrayList;
23import java.util.ConcurrentModificationException;
24import java.util.Iterator;
25import java.util.NoSuchElementException;
26
27import junit.framework.TestCase;
28
29import org.apache.harmony.testframework.serialization.SerializationTest;
30import org.apache.harmony.testframework.serialization.SerializationTest.SerializableAssert;
31
32public class ArrayDequeTest extends TestCase {
33
34    private Object testObjOne;
35
36    private Object testObjTwo;
37
38    private Object testObjThree;
39
40    private Object testObjFour;
41
42    private Object testObjLast;
43
44    private ArrayDeque<Object> testQue;
45
46    @Override
47    protected void setUp() throws Exception {
48        super.setUp();
49        testObjOne = new Object();
50        testObjTwo = new Object();
51        testObjThree = new Object();
52        testObjFour = new Object();
53        testObjLast = new Object();
54        testQue = new ArrayDeque<Object>();
55    }
56
57    /**
58     * @tests {@link java.util.ArrayDeque#ArrayDeque()}
59     */
60    public void test_Constructor() throws Exception {
61        assertEquals(0, new ArrayDeque<Object>().size());
62    }
63
64    /**
65     * @tests {@link java.util.ArrayDeque#ArrayDeque(java.util.Collection)}
66     */
67    public void test_Constructor_LCollection() throws Exception {
68        assertEquals(0, new ArrayDeque<Object>(new ArrayList<Object>()).size());
69        try {
70            new ArrayDeque<Object>(null);
71            fail("should throw NPE");
72        } catch (NullPointerException e) {
73            // expected
74        }
75    }
76
77    /**
78     * @tests {@link java.util.ArrayDeque#ArrayDeque(int)}
79     */
80    public void test_Constructor_Int() throws Exception {
81        assertEquals(0, new ArrayDeque<Object>(8).size());
82        ArrayDeque<Object> zeroCapQue = new ArrayDeque<Object>(0);
83        assertEquals(0, zeroCapQue.size());
84        zeroCapQue.add(testObjOne);
85        assertEquals(1, zeroCapQue.size());
86        assertEquals(0, new ArrayDeque<Object>(0).size());
87        ArrayDeque<Object> negCapQue = new ArrayDeque<Object>(-1);
88        assertEquals(0, negCapQue.size());
89        negCapQue.add(testObjOne);
90        assertEquals(1, negCapQue.size());
91        ArrayDeque<Object> oneCapQue = new ArrayDeque<Object>(1);
92        assertEquals(0, oneCapQue.size());
93        oneCapQue.add(testObjOne);
94        assertEquals(1, oneCapQue.size());
95        oneCapQue.add(testObjOne);
96        assertEquals(2, oneCapQue.size());
97    }
98
99    /**
100     * @tests {@link java.util.ArrayDeque#addFirst(Object)}
101     */
102    public void test_addFirst() throws Exception {
103        testQue.addFirst(testObjOne);
104        assertEquals(1, testQue.size());
105        assertEquals(testObjOne, testQue.peek());
106        testQue.addFirst(testObjOne);
107        assertEquals(2, testQue.size());
108        assertEquals(testObjOne, testQue.peek());
109        testQue.addFirst(testObjTwo);
110        assertEquals(3, testQue.size());
111        assertEquals(testObjTwo, testQue.peek());
112        assertEquals(testObjOne, testQue.getLast());
113        try {
114            testQue.addFirst(null);
115            fail("should throw NullPointerException");
116        } catch (NullPointerException e) {
117            // expected
118        }
119    }
120
121    /**
122     * @tests {@link java.util.ArrayDeque#addLast(Object)}
123     */
124    public void test_addLast() throws Exception {
125        testQue.addLast(testObjOne);
126        assertEquals(1, testQue.size());
127        assertEquals(testObjOne, testQue.peek());
128        testQue.addLast(testObjOne);
129        assertEquals(2, testQue.size());
130        assertEquals(testObjOne, testQue.peek());
131        testQue.addLast(testObjTwo);
132        assertEquals(3, testQue.size());
133        assertEquals(testObjOne, testQue.peek());
134        assertEquals(testObjTwo, testQue.getLast());
135        try {
136            testQue.addLast(null);
137            fail("should throw NullPointerException");
138        } catch (NullPointerException e) {
139            // expected
140        }
141    }
142
143    /**
144     * @tests {@link java.util.ArrayDeque#offerFirst(Object)}
145     */
146    public void test_offerFirst() throws Exception {
147        assertTrue(testQue.offerFirst(testObjOne));
148        assertEquals(1, testQue.size());
149        assertEquals(testObjOne, testQue.peek());
150        assertTrue(testQue.offerFirst(testObjOne));
151        assertEquals(2, testQue.size());
152        assertEquals(testObjOne, testQue.peek());
153        assertTrue(testQue.offerFirst(testObjTwo));
154        assertEquals(3, testQue.size());
155        assertEquals(testObjTwo, testQue.peek());
156        assertEquals(testObjOne, testQue.getLast());
157        try {
158            testQue.offerFirst(null);
159            fail("should throw NullPointerException");
160        } catch (NullPointerException e) {
161            // expected
162        }
163    }
164
165    /**
166     * @tests {@link java.util.ArrayDeque#offerLast(Object)}
167     */
168    public void test_offerLast() throws Exception {
169        assertTrue(testQue.offerLast(testObjOne));
170        assertEquals(1, testQue.size());
171        assertEquals(testObjOne, testQue.peek());
172        assertTrue(testQue.offerLast(testObjOne));
173        assertEquals(2, testQue.size());
174        assertEquals(testObjOne, testQue.peek());
175        assertTrue(testQue.offerLast(testObjTwo));
176        assertEquals(3, testQue.size());
177        assertEquals(testObjOne, testQue.peek());
178        assertEquals(testObjTwo, testQue.getLast());
179        try {
180            testQue.offerLast(null);
181            fail("should throw NullPointerException");
182        } catch (NullPointerException e) {
183            // expected
184        }
185    }
186
187    /**
188     * @tests {@link java.util.ArrayDeque#removeFirst()}
189     */
190    public void test_removeFirst() throws Exception {
191        assertTrue(testQue.offerLast(testObjOne));
192        assertTrue(testQue.offerLast(testObjTwo));
193        assertTrue(testQue.offerLast(testObjThree));
194        assertEquals(3, testQue.size());
195        assertEquals(testObjOne, testQue.removeFirst());
196        assertEquals(2, testQue.size());
197        assertEquals(testObjTwo, testQue.removeFirst());
198        assertEquals(testObjThree, testQue.removeFirst());
199        assertEquals(0, testQue.size());
200        try {
201            testQue.removeFirst();
202            fail("should throw NoSuchElementException ");
203        } catch (NoSuchElementException e) {
204            // expected
205        }
206    }
207
208    /**
209     * @tests {@link java.util.ArrayDeque#removeLast()}
210     */
211    public void test_removeLast() throws Exception {
212        assertTrue(testQue.offerLast(testObjOne));
213        assertTrue(testQue.offerLast(testObjTwo));
214        assertTrue(testQue.offerLast(testObjThree));
215        assertEquals(3, testQue.size());
216        assertEquals(testObjThree, testQue.removeLast());
217        assertEquals(2, testQue.size());
218        assertEquals(testObjTwo, testQue.removeLast());
219        assertEquals(testObjOne, testQue.removeLast());
220        assertEquals(0, testQue.size());
221        try {
222            testQue.removeLast();
223            fail("should throw NoSuchElementException ");
224        } catch (NoSuchElementException e) {
225            // expected
226        }
227    }
228
229    /**
230     * @tests {@link java.util.ArrayDeque#pollFirst()}
231     */
232    public void test_pollFirst() throws Exception {
233        assertTrue(testQue.offerLast(testObjOne));
234        assertTrue(testQue.offerLast(testObjTwo));
235        assertTrue(testQue.offerLast(testObjThree));
236        assertEquals(3, testQue.size());
237        assertEquals(testObjOne, testQue.pollFirst());
238        assertEquals(2, testQue.size());
239        assertEquals(testObjTwo, testQue.pollFirst());
240        assertEquals(testObjThree, testQue.pollFirst());
241        assertEquals(0, testQue.size());
242        assertNull(testQue.pollFirst());
243    }
244
245    /**
246     * @tests {@link java.util.ArrayDeque#peekLast()}
247     */
248    public void test_pollLast() throws Exception {
249        assertTrue(testQue.offerLast(testObjOne));
250        assertTrue(testQue.offerLast(testObjTwo));
251        assertTrue(testQue.offerLast(testObjThree));
252        assertEquals(3, testQue.size());
253        assertEquals(testObjThree, testQue.pollLast());
254        assertEquals(2, testQue.size());
255        assertEquals(testObjTwo, testQue.pollLast());
256        assertEquals(testObjOne, testQue.pollLast());
257        assertEquals(0, testQue.size());
258        assertNull(testQue.pollFirst());
259    }
260
261    /**
262     * @tests {@link java.util.ArrayDeque#getFirst()}
263     */
264    public void test_getFirst() throws Exception {
265        assertTrue(testQue.offerLast(testObjOne));
266        assertTrue(testQue.offerLast(testObjTwo));
267        assertTrue(testQue.offerLast(testObjThree));
268        assertEquals(3, testQue.size());
269        assertEquals(testObjOne, testQue.getFirst());
270        assertEquals(3, testQue.size());
271        assertEquals(testObjOne, testQue.pollFirst());
272        assertEquals(testObjTwo, testQue.getFirst());
273        assertEquals(testObjTwo, testQue.pollFirst());
274        assertEquals(testObjThree, testQue.pollFirst());
275        assertEquals(0, testQue.size());
276        try {
277            testQue.getFirst();
278            fail("should throw NoSuchElementException ");
279        } catch (NoSuchElementException e) {
280            // expected
281        }
282    }
283
284    /**
285     * @tests {@link java.util.ArrayDeque#getLast()}
286     */
287    public void test_getLast() throws Exception {
288        assertTrue(testQue.offerLast(testObjOne));
289        assertTrue(testQue.offerLast(testObjTwo));
290        assertTrue(testQue.offerLast(testObjThree));
291        assertEquals(3, testQue.size());
292        assertEquals(testObjThree, testQue.getLast());
293        assertEquals(3, testQue.size());
294        assertEquals(testObjThree, testQue.pollLast());
295        assertEquals(testObjTwo, testQue.getLast());
296        assertEquals(testObjTwo, testQue.pollLast());
297        assertEquals(testObjOne, testQue.pollLast());
298        assertEquals(0, testQue.size());
299        try {
300            testQue.getLast();
301            fail("should throw NoSuchElementException ");
302        } catch (NoSuchElementException e) {
303            // expected
304        }
305    }
306
307    /**
308     * @tests {@link java.util.ArrayDeque#peekFirst()}
309     */
310    public void test_peekFirst() throws Exception {
311        assertTrue(testQue.offerLast(testObjOne));
312        assertTrue(testQue.offerLast(testObjTwo));
313        assertTrue(testQue.offerLast(testObjThree));
314        assertEquals(3, testQue.size());
315        assertEquals(testObjOne, testQue.peekFirst());
316        assertEquals(3, testQue.size());
317        assertEquals(testObjOne, testQue.pollFirst());
318        assertEquals(testObjTwo, testQue.peekFirst());
319        assertEquals(testObjTwo, testQue.pollFirst());
320        assertEquals(testObjThree, testQue.pollFirst());
321        assertEquals(0, testQue.size());
322        assertEquals(null, testQue.peekFirst());
323    }
324
325    /**
326     * @tests {@link java.util.ArrayDeque#peekLast()}
327     */
328    public void test_peekLast() throws Exception {
329        assertTrue(testQue.offerLast(testObjOne));
330        assertTrue(testQue.offerLast(testObjTwo));
331        assertTrue(testQue.offerLast(testObjThree));
332        assertEquals(3, testQue.size());
333        assertEquals(testObjThree, testQue.peekLast());
334        assertEquals(3, testQue.size());
335        assertEquals(testObjThree, testQue.pollLast());
336        assertEquals(testObjTwo, testQue.peekLast());
337        assertEquals(testObjTwo, testQue.pollLast());
338        assertEquals(testObjOne, testQue.pollLast());
339        assertEquals(0, testQue.size());
340        assertNull(testQue.peekLast());
341    }
342
343    /**
344     * @tests {@link java.util.ArrayDeque#removeFirstOccurrence(Object)}
345     */
346    public void test_removeFirstOccurrence() throws Exception {
347        assertTrue(testQue.offerLast(testObjOne));
348        assertTrue(testQue.offerLast(testObjTwo));
349        assertTrue(testQue.offerLast(testObjOne));
350        assertTrue(testQue.offerLast(testObjThree));
351        assertTrue(testQue.offerLast(testObjOne));
352        assertEquals(5, testQue.size());
353        assertTrue(testQue.removeFirstOccurrence(testObjOne));
354        assertFalse(testQue.removeFirstOccurrence(testObjFour));
355        assertEquals(testObjTwo, testQue.peekFirst());
356        assertEquals(testObjOne, testQue.peekLast());
357        assertEquals(4, testQue.size());
358        assertTrue(testQue.removeFirstOccurrence(testObjOne));
359        assertEquals(3, testQue.size());
360        assertEquals(testObjOne, testQue.peekLast());
361        assertTrue(testQue.removeFirstOccurrence(testObjOne));
362        assertEquals(2, testQue.size());
363        assertEquals(testObjThree, testQue.peekLast());
364        assertFalse(testQue.removeFirstOccurrence(testObjOne));
365    }
366
367    /**
368     * @tests {@link java.util.ArrayDeque#removeLastOccurrence(Object)}
369     */
370    public void test_removeLastOccurrence() throws Exception {
371        assertTrue(testQue.offerLast(testObjOne));
372        assertTrue(testQue.offerLast(testObjTwo));
373        assertTrue(testQue.offerLast(testObjOne));
374        assertTrue(testQue.offerLast(testObjThree));
375        assertTrue(testQue.offerLast(testObjOne));
376        assertEquals(5, testQue.size());
377        assertTrue(testQue.removeLastOccurrence(testObjOne));
378        assertFalse(testQue.removeLastOccurrence(testObjFour));
379        assertEquals(testObjOne, testQue.peekFirst());
380        assertEquals(testObjThree, testQue.peekLast());
381        assertEquals(4, testQue.size());
382        assertTrue(testQue.removeLastOccurrence(testObjOne));
383        assertEquals(3, testQue.size());
384        assertEquals(testObjOne, testQue.peekFirst());
385        assertEquals(testObjThree, testQue.peekLast());
386        assertTrue(testQue.removeLastOccurrence(testObjOne));
387        assertEquals(2, testQue.size());
388        assertEquals(testObjThree, testQue.peekLast());
389        assertFalse(testQue.removeLastOccurrence(testObjOne));
390    }
391
392    /**
393     * @tests {@link java.util.ArrayDeque#add(Object)}
394     */
395    public void test_add() throws Exception {
396        assertTrue(testQue.add(testObjOne));
397        assertTrue(testQue.add(testObjTwo));
398        assertTrue(testQue.add(testObjOne));
399        assertTrue(testQue.add(testObjThree));
400        assertEquals(testObjOne, testQue.peekFirst());
401        assertEquals(testObjThree, testQue.peekLast());
402        try {
403            testQue.add(null);
404            fail("Should throw NullPointerException");
405        } catch (NullPointerException e) {
406            // expected
407        }
408    }
409
410    /**
411     * @tests {@link java.util.ArrayDeque#offer(Object)}
412     */
413    public void test_offer() throws Exception {
414        assertTrue(testQue.offer(testObjOne));
415        assertTrue(testQue.offer(testObjTwo));
416        assertTrue(testQue.offer(testObjOne));
417        assertTrue(testQue.offer(testObjThree));
418        assertEquals(testObjOne, testQue.peekFirst());
419        assertEquals(testObjThree, testQue.peekLast());
420        try {
421            testQue.offer(null);
422            fail("Should throw NullPointerException");
423        } catch (NullPointerException e) {
424            // expected
425        }
426    }
427
428    /**
429     * @tests {@link java.util.ArrayDeque#remove()}
430     */
431    public void test_remove() throws Exception {
432        assertTrue(testQue.offerLast(testObjOne));
433        assertTrue(testQue.offerLast(testObjTwo));
434        assertTrue(testQue.offerLast(testObjThree));
435        assertEquals(3, testQue.size());
436        assertEquals(testObjOne, testQue.remove());
437        assertEquals(2, testQue.size());
438        assertEquals(testObjTwo, testQue.remove());
439        assertEquals(testObjThree, testQue.remove());
440        assertEquals(0, testQue.size());
441        try {
442            testQue.remove();
443            fail("should throw NoSuchElementException ");
444        } catch (NoSuchElementException e) {
445            // expected
446        }
447    }
448
449    /**
450     * @tests {@link java.util.ArrayDeque#poll()}
451     */
452    public void test_poll() throws Exception {
453        assertTrue(testQue.offerLast(testObjOne));
454        assertTrue(testQue.offerLast(testObjTwo));
455        assertTrue(testQue.offerLast(testObjThree));
456        assertEquals(3, testQue.size());
457        assertEquals(testObjOne, testQue.poll());
458        assertEquals(2, testQue.size());
459        assertEquals(testObjTwo, testQue.poll());
460        assertEquals(testObjThree, testQue.poll());
461        assertEquals(0, testQue.size());
462        assertNull(testQue.poll());
463    }
464
465    /**
466     * @tests {@link java.util.ArrayDeque#element()}
467     */
468    public void test_element() throws Exception {
469        assertTrue(testQue.offerLast(testObjOne));
470        assertTrue(testQue.offerLast(testObjTwo));
471        assertTrue(testQue.offerLast(testObjThree));
472        assertEquals(3, testQue.size());
473        assertEquals(testObjOne, testQue.element());
474        assertEquals(3, testQue.size());
475        assertEquals(testObjOne, testQue.pollFirst());
476        assertEquals(testObjTwo, testQue.element());
477        assertEquals(testObjTwo, testQue.pollFirst());
478        assertEquals(testObjThree, testQue.element());
479        assertEquals(testObjThree, testQue.pollFirst());
480        assertEquals(0, testQue.size());
481        try {
482            testQue.element();
483            fail("should throw NoSuchElementException ");
484        } catch (NoSuchElementException e) {
485            // expected
486        }
487    }
488
489    /**
490     * @tests {@link java.util.ArrayDeque#peek()}
491     */
492    public void test_peek() throws Exception {
493        assertTrue(testQue.offerLast(testObjOne));
494        assertTrue(testQue.offerLast(testObjTwo));
495        assertTrue(testQue.offerLast(testObjThree));
496        assertEquals(3, testQue.size());
497        assertEquals(testObjOne, testQue.peek());
498        assertEquals(3, testQue.size());
499        assertEquals(testObjOne, testQue.pollFirst());
500        assertEquals(testObjTwo, testQue.peek());
501        assertEquals(testObjTwo, testQue.pollFirst());
502        assertEquals(testObjThree, testQue.pollFirst());
503        assertEquals(0, testQue.size());
504        assertEquals(null, testQue.peek());
505    }
506
507    /**
508     * @tests {@link java.util.ArrayDeque#push(Object)}
509     */
510    public void test_push() throws Exception {
511        testQue.push(testObjOne);
512        assertEquals(1, testQue.size());
513        assertEquals(testObjOne, testQue.peek());
514        testQue.push(testObjOne);
515        assertEquals(2, testQue.size());
516        assertEquals(testObjOne, testQue.peek());
517        testQue.push(testObjTwo);
518        assertEquals(3, testQue.size());
519        assertEquals(testObjTwo, testQue.peek());
520        assertEquals(testObjOne, testQue.getLast());
521        try {
522            testQue.push(null);
523            fail("should throw NullPointerException");
524        } catch (NullPointerException e) {
525            // expected
526        }
527    }
528
529    /**
530     * @tests {@link java.util.ArrayDeque#pop()}
531     */
532    public void test_pop() throws Exception {
533        assertTrue(testQue.offerLast(testObjOne));
534        assertTrue(testQue.offerLast(testObjTwo));
535        assertTrue(testQue.offerLast(testObjThree));
536        assertEquals(3, testQue.size());
537        assertEquals(testObjOne, testQue.pop());
538        assertEquals(2, testQue.size());
539        assertEquals(testObjTwo, testQue.pop());
540        assertEquals(testObjThree, testQue.pop());
541        assertEquals(0, testQue.size());
542        try {
543            testQue.pop();
544            fail("should throw NoSuchElementException ");
545        } catch (NoSuchElementException e) {
546            // expected
547        }
548    }
549
550    /**
551     * @tests {@link java.util.ArrayDeque#addFirst(Object)}
552     */
553    public void test_size() throws Exception {
554        assertEquals(0, testQue.size());
555        assertTrue(testQue.add(testObjOne));
556        assertTrue(testQue.add(testObjTwo));
557        assertEquals(2, testQue.size());
558        assertTrue(testQue.add(testObjOne));
559        assertTrue(testQue.add(testObjThree));
560        assertEquals(4, testQue.size());
561        testQue.remove();
562        testQue.remove();
563        assertEquals(2, testQue.size());
564        testQue.clear();
565        assertEquals(0, testQue.size());
566    }
567
568    /**
569     * @tests {@link java.util.ArrayDeque#isEmpty()}
570     */
571    public void test_isEmpty() throws Exception {
572        assertTrue(testQue.isEmpty());
573        assertTrue(testQue.add(testObjOne));
574        assertFalse(testQue.isEmpty());
575        assertTrue(testQue.add(testObjTwo));
576        assertFalse(testQue.isEmpty());
577        assertTrue(testQue.add(testObjOne));
578        assertTrue(testQue.add(testObjThree));
579        assertFalse(testQue.isEmpty());
580        testQue.remove();
581        testQue.remove();
582        assertFalse(testQue.isEmpty());
583        testQue.clear();
584        assertTrue(testQue.isEmpty());
585    }
586
587    /**
588     * @tests {@link java.util.ArrayDeque#iterator()}
589     */
590    public void test_iterator() throws Exception {
591        assertFalse(testQue.iterator().hasNext());
592        assertTrue(testQue.add(testObjOne));
593        assertTrue(testQue.add(testObjTwo));
594        assertTrue(testQue.add(testObjOne));
595        assertTrue(testQue.add(testObjThree));
596        assertTrue(testQue.add(testObjLast));
597        Iterator result = testQue.iterator();
598        assertEquals(5, testQue.size());
599        try {
600            result.remove();
601            fail("should throw IllegalStateException");
602        } catch (IllegalStateException e) {
603            // expected
604        }
605        assertTrue(testQue.add(testObjThree));
606        try {
607            result.next();
608            fail("should throw ConcurrentModificationException");
609        } catch (ConcurrentModificationException e) {
610            // expected
611        }
612        result = testQue.iterator();
613        assertEquals(testObjOne, result.next());
614        assertEquals(testObjTwo, result.next());
615        assertEquals(testObjOne, result.next());
616        assertEquals(testObjThree, result.next());
617        assertEquals(testObjLast, result.next());
618        assertTrue(result.hasNext());
619        result.remove();
620        assertEquals(testObjThree, result.next());
621        assertFalse(result.hasNext());
622        try {
623            result.next();
624            fail("should throw NoSuchElementException");
625        } catch (NoSuchElementException e) {
626            // expected
627        }
628        // test a full array
629        ArrayDeque<Object> ad = new ArrayDeque<Object>();
630        // fill the array
631        for (int i = 0; i < 16; ++i) {
632            ad.addLast(new Object());
633        }
634        assertTrue(ad.iterator().hasNext());
635        Iterator<Object> iter = ad.iterator();
636        for (int i = 0; i < 16; ++i) {
637            assertTrue(iter.hasNext());
638            iter.next();
639        }
640        iter.remove();
641        // test un-full array
642        ad = new ArrayDeque<Object>();
643        // fill the array
644        for (int i = 0; i < 5; ++i) {
645                ad.addLast(new Object());
646        }
647        iter = ad.iterator();
648        for (int i = 0; i < 5; ++i) {
649                assertTrue(iter.hasNext());
650                iter.next();
651        }
652        iter.remove();
653
654        ad = new ArrayDeque<Object>();
655        // fill the array
656        for (int i = 0; i < 16; ++i) {
657            ad.addLast(new Object());
658        }
659        iter = ad.iterator();
660        assertTrue(iter.hasNext());
661        for (int i = 0; i < ad.size(); ++i) {
662            iter.next();
663        }
664        assertFalse(iter.hasNext());
665        iter.remove();
666        ad.add(new Object());
667        assertFalse(iter.hasNext());
668    }
669
670    /**
671     * @tests {@link java.util.ArrayDeque#descendingIterator()}
672     */
673    public void test_descendingIterator() throws Exception {
674        assertFalse(testQue.descendingIterator().hasNext());
675        assertTrue(testQue.add(testObjOne));
676        assertTrue(testQue.add(testObjTwo));
677        assertTrue(testQue.add(testObjOne));
678        assertTrue(testQue.add(testObjThree));
679        assertTrue(testQue.add(testObjLast));
680        Iterator result = testQue.descendingIterator();
681        assertEquals(5, testQue.size());
682        try {
683            result.remove();
684            fail("should throw IllegalStateException");
685        } catch (IllegalStateException e) {
686            // expected
687        }
688        assertTrue(testQue.add(testObjFour));
689
690        // a strange behavior here, RI's descendingIterator() and iterator() is
691        // properly different. Notice spec: "The iterators returned by this
692        // class's iterator method are fail-fast". RI shows descendingIterator()
693        // is not an iterator method.
694        assertEquals(testObjLast,result.next());
695
696        result = testQue.descendingIterator();
697        assertEquals(testObjFour, result.next());
698        assertEquals(testObjLast, result.next());
699        assertEquals(testObjThree, result.next());
700        assertEquals(testObjOne, result.next());
701        assertEquals(testObjTwo, result.next());
702        assertTrue(result.hasNext());
703        result.remove();
704        assertEquals(testObjOne, result.next());
705        assertFalse(result.hasNext());
706        try {
707            result.next();
708            fail("should throw NoSuchElementException");
709        } catch (NoSuchElementException e) {
710            // expected
711        }
712        // test a full array
713        ArrayDeque<Object> ad = new ArrayDeque<Object>();
714        // fill the array
715        for (int i = 0; i < 16; ++i) {
716            ad.addLast(new Object());
717        }
718        assertTrue(ad.descendingIterator().hasNext());
719        Iterator<Object> iter = ad.descendingIterator();
720        for (int i = 0; i < 16; ++i) {
721            assertTrue(iter.hasNext());
722            iter.next();
723        }
724        iter.remove();
725        // test un-full array
726        ad = new ArrayDeque<Object>();
727        // fill the array
728        for (int i = 0; i < 5; ++i) {
729                ad.addLast(new Object());
730        }
731        iter = ad.descendingIterator();
732        for (int i = 0; i < 5; ++i) {
733                assertTrue(iter.hasNext());
734                iter.next();
735        }
736        iter.remove();
737
738        ad = new ArrayDeque<Object>();
739        // fill the array
740        for (int i = 0; i < 16; ++i) {
741            ad.addLast(new Object());
742        }
743        iter = ad.descendingIterator();
744        assertTrue(iter.hasNext());
745        for (int i = 0; i < ad.size(); ++i) {
746            iter.next();
747        }
748        assertFalse(iter.hasNext());
749        iter.remove();
750        ad.add(new Object());
751        assertFalse(iter.hasNext());
752    }
753
754    /**
755     * @tests {@link java.util.ArrayDeque#contains(Object)}
756     */
757    public void test_contains() throws Exception {
758        assertFalse(testQue.contains(testObjFour));
759        assertFalse(testQue.contains(null));
760        assertTrue(testQue.add(testObjOne));
761        assertTrue(testQue.add(testObjTwo));
762        assertTrue(testQue.add(testObjOne));
763        assertTrue(testQue.add(testObjThree));
764        assertTrue(testQue.add(testObjLast));
765
766        assertTrue(testQue.contains(testObjOne));
767        assertTrue(testQue.contains(testObjTwo));
768        assertTrue(testQue.contains(testObjThree));
769        assertTrue(testQue.contains(testObjLast));
770        assertFalse(testQue.contains(null));
771        testQue.clear();
772        assertFalse(testQue.contains(testObjOne));
773        assertFalse(testQue.contains(testObjTwo));
774    }
775
776    /**
777     * @tests {@link java.util.ArrayDeque#remove(Object)}
778     */
779    public void test_remove_LObject() throws Exception {
780        assertTrue(testQue.offerLast(testObjOne));
781        assertTrue(testQue.offerLast(testObjTwo));
782        assertTrue(testQue.offerLast(testObjOne));
783        assertTrue(testQue.offerLast(testObjThree));
784        assertTrue(testQue.offerLast(testObjOne));
785        assertEquals(5, testQue.size());
786        assertTrue(testQue.remove(testObjOne));
787        assertFalse(testQue.remove(testObjFour));
788        assertEquals(testObjTwo, testQue.peekFirst());
789        assertEquals(testObjOne, testQue.peekLast());
790        assertEquals(4, testQue.size());
791        assertTrue(testQue.remove(testObjOne));
792        assertEquals(3, testQue.size());
793        assertEquals(testObjOne, testQue.peekLast());
794        assertTrue(testQue.remove(testObjOne));
795        assertEquals(2, testQue.size());
796        assertEquals(testObjThree, testQue.peekLast());
797        assertFalse(testQue.remove(testObjOne));
798    }
799
800    /**
801     * @tests {@link java.util.ArrayDeque#clear()}
802     */
803    public void test_clear() throws Exception {
804        assertTrue(testQue.isEmpty());
805        testQue.clear();
806        assertTrue(testQue.isEmpty());
807        assertTrue(testQue.add(testObjOne));
808        assertTrue(testQue.add(testObjTwo));
809        assertTrue(testQue.add(testObjOne));
810        assertTrue(testQue.add(testObjThree));
811        testQue.clear();
812        assertTrue(testQue.isEmpty());
813    }
814
815    /**
816     * @tests {@link java.util.ArrayDeque#toArray()}
817     */
818    public void test_toArray() throws Exception {
819        assertEquals(0, testQue.toArray().length);
820        assertTrue(testQue.add(testObjOne));
821        assertTrue(testQue.add(testObjTwo));
822        assertTrue(testQue.add(testObjOne));
823        assertTrue(testQue.add(testObjThree));
824        assertTrue(testQue.add(testObjLast));
825        Object[] result = testQue.toArray();
826        assertEquals(5, testQue.size());
827        assertEquals(testObjOne, result[0]);
828        assertEquals(testObjTwo, result[1]);
829        assertEquals(testObjOne, result[2]);
830        assertEquals(testObjThree, result[3]);
831        assertEquals(testObjLast, result[4]);
832        // change in array do not affect ArrayDeque
833        result[0] = null;
834        assertEquals(5, testQue.size());
835        assertEquals(testObjOne, testQue.peek());
836    }
837
838    /**
839     * @tests {@link java.util.ArrayDeque#toArray(Object[])}
840     */
841    public void test_toArray_$LObject() throws Exception {
842        Object[] array = new Object[0];
843        Object[] result = testQue.toArray(array);
844        assertEquals(0, result.length);
845        assertEquals(array, result);
846        assertTrue(testQue.add(testObjOne));
847        assertTrue(testQue.add(testObjTwo));
848        assertTrue(testQue.add(testObjOne));
849        assertTrue(testQue.add(testObjThree));
850        assertTrue(testQue.add(testObjLast));
851        result = testQue.toArray(array);
852        assertEquals(5, testQue.size());
853        assertEquals(5, result.length);
854        assertEquals(0, array.length);
855        assertFalse(array == result);
856        assertEquals(testObjOne, result[0]);
857        assertEquals(testObjTwo, result[1]);
858        assertEquals(testObjOne, result[2]);
859        assertEquals(testObjThree, result[3]);
860        assertEquals(testObjLast, result[4]);
861        // change in array do not affect ArrayDeque
862        result[0] = null;
863        assertEquals(5, testQue.size());
864        assertEquals(testObjOne, testQue.peek());
865        try {
866            testQue.toArray(null);
867            fail("should throw NullPointerException");
868        } catch (NullPointerException e) {
869            // expected
870        }
871
872    }
873
874    /**
875     * @tests {@link java.util.ArrayDeque#clone()}
876     */
877    public void test_clone() throws Exception {
878        ArrayDeque<Object> cloned = testQue.clone();
879        assertEquals(0, cloned.size());
880        assertFalse(cloned == testQue);
881        assertTrue(testQue.add(testObjOne));
882        assertTrue(testQue.add(testObjTwo));
883        assertTrue(testQue.add(testObjOne));
884        assertTrue(testQue.add(testObjThree));
885        assertTrue(testQue.add(testObjLast));
886        assertTrue(testQue.add(testQue));
887        cloned = testQue.clone();
888        assertEquals(6, cloned.size());
889        while (0 != testQue.size()) {
890            assertEquals(testQue.remove(), cloned.remove());
891        }
892    }
893
894    /**
895     * @tests java.util.ArrayDeque#Serialization()
896     */
897    public void test_serialization() throws Exception {
898        assertTrue(testQue.add(new Integer(1)));
899        assertTrue(testQue.add(new Integer(2)));
900        assertTrue(testQue.add(new Integer(3)));
901        assertTrue(testQue.add(new Integer(4)));
902        assertTrue(testQue.add(new Integer(5)));
903        SerializationTest.verifySelf(testQue, new SerializableAssert() {
904            public void assertDeserialized(Serializable initial,
905                    Serializable deserialized) {
906                ArrayDeque<Object> formerQue = (ArrayDeque)initial;
907                ArrayDeque<Object> deserializedQue = (ArrayDeque)deserialized;
908                assertEquals(formerQue.remove(),deserializedQue.remove());
909            }
910        });
911    }
912
913    /**
914     * @tests serialization/deserialization compatibility with RI.
915     */
916    @SuppressWarnings( { "unchecked", "boxing" })
917    public void testSerializationCompatibility() throws Exception {
918        assertTrue(testQue.add(new Integer(1)));
919        assertTrue(testQue.add(new Integer(2)));
920        assertTrue(testQue.add(new Integer(3)));
921        assertTrue(testQue.add(new Integer(4)));
922        assertTrue(testQue.add(new Integer(5)));
923        SerializationTest.verifyGolden(this,testQue, new SerializableAssert() {
924            public void assertDeserialized(Serializable initial,
925                    Serializable deserialized) {
926                ArrayDeque<Object> formerQue = (ArrayDeque)initial;
927                ArrayDeque<Object> deserializedQue = (ArrayDeque)deserialized;
928                assertEquals(formerQue.remove(),deserializedQue.remove());
929            }
930        });
931    }
932}
933