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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.33 - (view) (download)

1 : dl 1.1 /*
2 :     * Written by Doug Lea with assistance from members of JCP JSR-166
3 :     * Expert Group and released to the public domain, as explained at
4 : jsr166 1.22 * http://creativecommons.org/publicdomain/zero/1.0/
5 : dl 1.1 */
6 :    
7 : jsr166 1.30 import java.util.ArrayDeque;
8 : jsr166 1.24 import java.util.Arrays;
9 :     import java.util.Collection;
10 :     import java.util.Deque;
11 :     import java.util.Iterator;
12 :     import java.util.NoSuchElementException;
13 :     import java.util.Queue;
14 :     import java.util.Random;
15 : dl 1.1
16 : jsr166 1.30 import junit.framework.Test;
17 :     import junit.framework.TestSuite;
18 :    
19 : dl 1.1 public class ArrayDequeTest extends JSR166TestCase {
20 :     public static void main(String[] args) {
21 : jsr166 1.16 junit.textui.TestRunner.run(suite());
22 : dl 1.1 }
23 :    
24 :     public static Test suite() {
25 : jsr166 1.8 return new TestSuite(ArrayDequeTest.class);
26 : dl 1.1 }
27 :    
28 :     /**
29 : jsr166 1.26 * Returns a new deque of given size containing consecutive
30 : dl 1.1 * Integers 0 ... n.
31 :     */
32 : jsr166 1.20 private ArrayDeque<Integer> populatedDeque(int n) {
33 :     ArrayDeque<Integer> q = new ArrayDeque<Integer>();
34 : dl 1.1 assertTrue(q.isEmpty());
35 : jsr166 1.8 for (int i = 0; i < n; ++i)
36 :     assertTrue(q.offerLast(new Integer(i)));
37 : dl 1.1 assertFalse(q.isEmpty());
38 : jsr166 1.8 assertEquals(n, q.size());
39 : dl 1.1 return q;
40 :     }
41 : jsr166 1.5
42 : dl 1.1 /**
43 : jsr166 1.16 * new deque is empty
44 : dl 1.1 */
45 :     public void testConstructor1() {
46 :     assertEquals(0, new ArrayDeque().size());
47 :     }
48 :    
49 :     /**
50 :     * Initializing from null Collection throws NPE
51 :     */
52 :     public void testConstructor3() {
53 :     try {
54 : jsr166 1.33 new ArrayDeque((Collection)null);
55 : dl 1.1 shouldThrow();
56 : jsr166 1.9 } catch (NullPointerException success) {}
57 : dl 1.1 }
58 :    
59 :     /**
60 : jsr166 1.16 * Initializing from Collection of null elements throws NPE
61 :     */
62 :     public void testConstructor4() {
63 :     try {
64 :     Integer[] ints = new Integer[SIZE];
65 : jsr166 1.33 new ArrayDeque(Arrays.asList(ints));
66 : jsr166 1.16 shouldThrow();
67 :     } catch (NullPointerException success) {}
68 :     }
69 : dl 1.1
70 : jsr166 1.16 /**
71 :     * Initializing from Collection with some null elements throws NPE
72 :     */
73 :     public void testConstructor5() {
74 :     try {
75 :     Integer[] ints = new Integer[SIZE];
76 :     for (int i = 0; i < SIZE-1; ++i)
77 :     ints[i] = new Integer(i);
78 : jsr166 1.33 new ArrayDeque(Arrays.asList(ints));
79 : jsr166 1.16 shouldThrow();
80 :     } catch (NullPointerException success) {}
81 :     }
82 :    
83 :     /**
84 :     * Deque contains all elements of collection used to initialize
85 : dl 1.1 */
86 :     public void testConstructor6() {
87 : jsr166 1.9 Integer[] ints = new Integer[SIZE];
88 :     for (int i = 0; i < SIZE; ++i)
89 :     ints[i] = new Integer(i);
90 :     ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
91 :     for (int i = 0; i < SIZE; ++i)
92 :     assertEquals(ints[i], q.pollFirst());
93 : dl 1.1 }
94 :    
95 :     /**
96 :     * isEmpty is true before add, false after
97 :     */
98 :     public void testEmpty() {
99 :     ArrayDeque q = new ArrayDeque();
100 :     assertTrue(q.isEmpty());
101 :     q.add(new Integer(1));
102 :     assertFalse(q.isEmpty());
103 :     q.add(new Integer(2));
104 :     q.removeFirst();
105 :     q.removeFirst();
106 :     assertTrue(q.isEmpty());
107 :     }
108 :    
109 :     /**
110 :     * size changes when elements added and removed
111 :     */
112 :     public void testSize() {
113 :     ArrayDeque q = populatedDeque(SIZE);
114 :     for (int i = 0; i < SIZE; ++i) {
115 :     assertEquals(SIZE-i, q.size());
116 :     q.removeFirst();
117 :     }
118 :     for (int i = 0; i < SIZE; ++i) {
119 :     assertEquals(i, q.size());
120 :     q.add(new Integer(i));
121 :     }
122 :     }
123 :    
124 :     /**
125 :     * push(null) throws NPE
126 :     */
127 :     public void testPushNull() {
128 : jsr166 1.8 try {
129 : dl 1.1 ArrayDeque q = new ArrayDeque(1);
130 :     q.push(null);
131 :     shouldThrow();
132 : jsr166 1.9 } catch (NullPointerException success) {}
133 : dl 1.1 }
134 :    
135 :     /**
136 : jsr166 1.16 * peekFirst() returns element inserted with push
137 : dl 1.1 */
138 :     public void testPush() {
139 :     ArrayDeque q = populatedDeque(3);
140 :     q.pollLast();
141 : jsr166 1.8 q.push(four);
142 : jsr166 1.12 assertSame(four, q.peekFirst());
143 : jsr166 1.5 }
144 : dl 1.1
145 :     /**
146 : jsr166 1.16 * pop() removes next element, or throws NSEE if empty
147 : dl 1.1 */
148 :     public void testPop() {
149 :     ArrayDeque q = populatedDeque(SIZE);
150 :     for (int i = 0; i < SIZE; ++i) {
151 : jsr166 1.12 assertEquals(i, q.pop());
152 : dl 1.1 }
153 :     try {
154 :     q.pop();
155 :     shouldThrow();
156 : jsr166 1.9 } catch (NoSuchElementException success) {}
157 : dl 1.1 }
158 :    
159 :     /**
160 :     * offer(null) throws NPE
161 :     */
162 : jsr166 1.16 public void testOfferNull() {
163 :     try {
164 :     ArrayDeque q = new ArrayDeque();
165 :     q.offer(null);
166 :     shouldThrow();
167 :     } catch (NullPointerException success) {}
168 :     }
169 :    
170 :     /**
171 :     * offerFirst(null) throws NPE
172 :     */
173 : dl 1.1 public void testOfferFirstNull() {
174 : jsr166 1.8 try {
175 : dl 1.1 ArrayDeque q = new ArrayDeque();
176 :     q.offerFirst(null);
177 :     shouldThrow();
178 : jsr166 1.9 } catch (NullPointerException success) {}
179 : dl 1.1 }
180 :    
181 :     /**
182 : jsr166 1.16 * offerLast(null) throws NPE
183 :     */
184 :     public void testOfferLastNull() {
185 :     try {
186 :     ArrayDeque q = new ArrayDeque();
187 :     q.offerLast(null);
188 :     shouldThrow();
189 :     } catch (NullPointerException success) {}
190 :     }
191 :    
192 :     /**
193 :     * offer(x) succeeds
194 :     */
195 :     public void testOffer() {
196 :     ArrayDeque q = new ArrayDeque();
197 :     assertTrue(q.offer(zero));
198 :     assertTrue(q.offer(one));
199 :     assertSame(zero, q.peekFirst());
200 :     assertSame(one, q.peekLast());
201 :     }
202 :    
203 :     /**
204 :     * offerFirst(x) succeeds
205 : dl 1.1 */
206 :     public void testOfferFirst() {
207 :     ArrayDeque q = new ArrayDeque();
208 : jsr166 1.16 assertTrue(q.offerFirst(zero));
209 :     assertTrue(q.offerFirst(one));
210 :     assertSame(one, q.peekFirst());
211 :     assertSame(zero, q.peekLast());
212 : dl 1.1 }
213 :    
214 :     /**
215 : jsr166 1.16 * offerLast(x) succeeds
216 : dl 1.1 */
217 :     public void testOfferLast() {
218 :     ArrayDeque q = new ArrayDeque();
219 : jsr166 1.16 assertTrue(q.offerLast(zero));
220 :     assertTrue(q.offerLast(one));
221 :     assertSame(zero, q.peekFirst());
222 :     assertSame(one, q.peekLast());
223 : dl 1.1 }
224 :    
225 :     /**
226 : jsr166 1.16 * add(null) throws NPE
227 :     */
228 :     public void testAddNull() {
229 :     try {
230 :     ArrayDeque q = new ArrayDeque();
231 :     q.add(null);
232 :     shouldThrow();
233 :     } catch (NullPointerException success) {}
234 :     }
235 :    
236 :     /**
237 :     * addFirst(null) throws NPE
238 :     */
239 :     public void testAddFirstNull() {
240 :     try {
241 :     ArrayDeque q = new ArrayDeque();
242 :     q.addFirst(null);
243 :     shouldThrow();
244 :     } catch (NullPointerException success) {}
245 :     }
246 :    
247 :     /**
248 :     * addLast(null) throws NPE
249 :     */
250 :     public void testAddLastNull() {
251 :     try {
252 :     ArrayDeque q = new ArrayDeque();
253 :     q.addLast(null);
254 :     shouldThrow();
255 :     } catch (NullPointerException success) {}
256 :     }
257 :    
258 :     /**
259 :     * add(x) succeeds
260 : dl 1.1 */
261 :     public void testAdd() {
262 :     ArrayDeque q = new ArrayDeque();
263 : jsr166 1.16 assertTrue(q.add(zero));
264 :     assertTrue(q.add(one));
265 :     assertSame(zero, q.peekFirst());
266 :     assertSame(one, q.peekLast());
267 :     }
268 :    
269 :     /**
270 :     * addFirst(x) succeeds
271 :     */
272 :     public void testAddFirst() {
273 :     ArrayDeque q = new ArrayDeque();
274 :     q.addFirst(zero);
275 :     q.addFirst(one);
276 :     assertSame(one, q.peekFirst());
277 :     assertSame(zero, q.peekLast());
278 :     }
279 :    
280 :     /**
281 :     * addLast(x) succeeds
282 :     */
283 :     public void testAddLast() {
284 :     ArrayDeque q = new ArrayDeque();
285 :     q.addLast(zero);
286 :     q.addLast(one);
287 :     assertSame(zero, q.peekFirst());
288 :     assertSame(one, q.peekLast());
289 : dl 1.1 }
290 :    
291 :     /**
292 :     * addAll(null) throws NPE
293 :     */
294 :     public void testAddAll1() {
295 :     try {
296 :     ArrayDeque q = new ArrayDeque();
297 :     q.addAll(null);
298 :     shouldThrow();
299 : jsr166 1.9 } catch (NullPointerException success) {}
300 : dl 1.1 }
301 :    
302 :     /**
303 : jsr166 1.16 * addAll of a collection with null elements throws NPE
304 :     */
305 :     public void testAddAll2() {
306 :     try {
307 :     ArrayDeque q = new ArrayDeque();
308 :     Integer[] ints = new Integer[SIZE];
309 :     q.addAll(Arrays.asList(ints));
310 :     shouldThrow();
311 :     } catch (NullPointerException success) {}
312 :     }
313 :    
314 :     /**
315 :     * addAll of a collection with any null elements throws NPE after
316 :     * possibly adding some elements
317 :     */
318 :     public void testAddAll3() {
319 :     try {
320 :     ArrayDeque q = new ArrayDeque();
321 :     Integer[] ints = new Integer[SIZE];
322 :     for (int i = 0; i < SIZE-1; ++i)
323 :     ints[i] = new Integer(i);
324 :     q.addAll(Arrays.asList(ints));
325 :     shouldThrow();
326 :     } catch (NullPointerException success) {}
327 :     }
328 :    
329 :     /**
330 :     * Deque contains all elements, in traversal order, of successful addAll
331 : dl 1.1 */
332 :     public void testAddAll5() {
333 : jsr166 1.10 Integer[] empty = new Integer[0];
334 :     Integer[] ints = new Integer[SIZE];
335 :     for (int i = 0; i < SIZE; ++i)
336 :     ints[i] = new Integer(i);
337 :     ArrayDeque q = new ArrayDeque();
338 :     assertFalse(q.addAll(Arrays.asList(empty)));
339 :     assertTrue(q.addAll(Arrays.asList(ints)));
340 :     for (int i = 0; i < SIZE; ++i)
341 :     assertEquals(ints[i], q.pollFirst());
342 : dl 1.1 }
343 :    
344 :     /**
345 : jsr166 1.16 * pollFirst() succeeds unless empty
346 : dl 1.1 */
347 :     public void testPollFirst() {
348 :     ArrayDeque q = populatedDeque(SIZE);
349 :     for (int i = 0; i < SIZE; ++i) {
350 : jsr166 1.12 assertEquals(i, q.pollFirst());
351 : dl 1.1 }
352 : jsr166 1.8 assertNull(q.pollFirst());
353 : dl 1.1 }
354 :    
355 :     /**
356 : jsr166 1.16 * pollLast() succeeds unless empty
357 : dl 1.1 */
358 :     public void testPollLast() {
359 :     ArrayDeque q = populatedDeque(SIZE);
360 :     for (int i = SIZE-1; i >= 0; --i) {
361 : jsr166 1.12 assertEquals(i, q.pollLast());
362 : dl 1.1 }
363 : jsr166 1.8 assertNull(q.pollLast());
364 : dl 1.1 }
365 :    
366 :     /**
367 : jsr166 1.16 * poll() succeeds unless empty
368 : dl 1.1 */
369 :     public void testPoll() {
370 :     ArrayDeque q = populatedDeque(SIZE);
371 :     for (int i = 0; i < SIZE; ++i) {
372 : jsr166 1.12 assertEquals(i, q.poll());
373 : dl 1.1 }
374 : jsr166 1.8 assertNull(q.poll());
375 : dl 1.1 }
376 :    
377 :     /**
378 : jsr166 1.16 * remove() removes next element, or throws NSEE if empty
379 : dl 1.1 */
380 :     public void testRemove() {
381 :     ArrayDeque q = populatedDeque(SIZE);
382 :     for (int i = 0; i < SIZE; ++i) {
383 : jsr166 1.12 assertEquals(i, q.remove());
384 : dl 1.1 }
385 :     try {
386 :     q.remove();
387 :     shouldThrow();
388 : jsr166 1.9 } catch (NoSuchElementException success) {}
389 : dl 1.1 }
390 :    
391 :     /**
392 : jsr166 1.16 * remove(x) removes x and returns true if present
393 :     */
394 :     public void testRemoveElement() {
395 :     ArrayDeque q = populatedDeque(SIZE);
396 : jsr166 1.31 for (int i = 1; i < SIZE; i += 2) {
397 : jsr166 1.21 assertTrue(q.contains(i));
398 :     assertTrue(q.remove(i));
399 :     assertFalse(q.contains(i));
400 :     assertTrue(q.contains(i-1));
401 : jsr166 1.16 }
402 : jsr166 1.31 for (int i = 0; i < SIZE; i += 2) {
403 : jsr166 1.21 assertTrue(q.contains(i));
404 :     assertTrue(q.remove(i));
405 :     assertFalse(q.contains(i));
406 :     assertFalse(q.remove(i+1));
407 :     assertFalse(q.contains(i+1));
408 : jsr166 1.16 }
409 :     assertTrue(q.isEmpty());
410 :     }
411 :    
412 :     /**
413 :     * peekFirst() returns next element, or null if empty
414 : dl 1.1 */
415 :     public void testPeekFirst() {
416 :     ArrayDeque q = populatedDeque(SIZE);
417 :     for (int i = 0; i < SIZE; ++i) {
418 : jsr166 1.12 assertEquals(i, q.peekFirst());
419 :     assertEquals(i, q.pollFirst());
420 : dl 1.1 assertTrue(q.peekFirst() == null ||
421 : jsr166 1.12 !q.peekFirst().equals(i));
422 : dl 1.1 }
423 : jsr166 1.8 assertNull(q.peekFirst());
424 : dl 1.1 }
425 :    
426 :     /**
427 : jsr166 1.16 * peek() returns next element, or null if empty
428 : dl 1.1 */
429 :     public void testPeek() {
430 :     ArrayDeque q = populatedDeque(SIZE);
431 :     for (int i = 0; i < SIZE; ++i) {
432 : jsr166 1.12 assertEquals(i, q.peek());
433 :     assertEquals(i, q.poll());
434 : dl 1.1 assertTrue(q.peek() == null ||
435 : jsr166 1.12 !q.peek().equals(i));
436 : dl 1.1 }
437 : jsr166 1.8 assertNull(q.peek());
438 : dl 1.1 }
439 :    
440 :     /**
441 : jsr166 1.16 * peekLast() returns next element, or null if empty
442 : dl 1.1 */
443 :     public void testPeekLast() {
444 :     ArrayDeque q = populatedDeque(SIZE);
445 :     for (int i = SIZE-1; i >= 0; --i) {
446 : jsr166 1.12 assertEquals(i, q.peekLast());
447 :     assertEquals(i, q.pollLast());
448 : dl 1.1 assertTrue(q.peekLast() == null ||
449 : jsr166 1.12 !q.peekLast().equals(i));
450 : dl 1.1 }
451 : jsr166 1.8 assertNull(q.peekLast());
452 : dl 1.1 }
453 :    
454 :     /**
455 : jsr166 1.16 * element() returns first element, or throws NSEE if empty
456 :     */
457 :     public void testElement() {
458 :     ArrayDeque q = populatedDeque(SIZE);
459 :     for (int i = 0; i < SIZE; ++i) {
460 :     assertEquals(i, q.element());
461 :     assertEquals(i, q.poll());
462 :     }
463 :     try {
464 :     q.element();
465 :     shouldThrow();
466 :     } catch (NoSuchElementException success) {}
467 :     }
468 :    
469 :     /**
470 :     * getFirst() returns first element, or throws NSEE if empty
471 : dl 1.1 */
472 :     public void testFirstElement() {
473 :     ArrayDeque q = populatedDeque(SIZE);
474 :     for (int i = 0; i < SIZE; ++i) {
475 : jsr166 1.12 assertEquals(i, q.getFirst());
476 :     assertEquals(i, q.pollFirst());
477 : dl 1.1 }
478 :     try {
479 :     q.getFirst();
480 :     shouldThrow();
481 : jsr166 1.9 } catch (NoSuchElementException success) {}
482 : dl 1.1 }
483 :    
484 :     /**
485 : jsr166 1.16 * getLast() returns last element, or throws NSEE if empty
486 : dl 1.1 */
487 :     public void testLastElement() {
488 :     ArrayDeque q = populatedDeque(SIZE);
489 :     for (int i = SIZE-1; i >= 0; --i) {
490 : jsr166 1.12 assertEquals(i, q.getLast());
491 :     assertEquals(i, q.pollLast());
492 : dl 1.1 }
493 :     try {
494 :     q.getLast();
495 :     shouldThrow();
496 : jsr166 1.9 } catch (NoSuchElementException success) {}
497 : jsr166 1.8 assertNull(q.peekLast());
498 : dl 1.1 }
499 :    
500 :     /**
501 : jsr166 1.16 * removeFirst() removes first element, or throws NSEE if empty
502 : dl 1.1 */
503 :     public void testRemoveFirst() {
504 :     ArrayDeque q = populatedDeque(SIZE);
505 :     for (int i = 0; i < SIZE; ++i) {
506 : jsr166 1.12 assertEquals(i, q.removeFirst());
507 : dl 1.1 }
508 :     try {
509 :     q.removeFirst();
510 :     shouldThrow();
511 : jsr166 1.9 } catch (NoSuchElementException success) {}
512 : jsr166 1.16 assertNull(q.peekFirst());
513 :     }
514 :    
515 :     /**
516 :     * removeLast() removes last element, or throws NSEE if empty
517 :     */
518 :     public void testRemoveLast() {
519 :     ArrayDeque q = populatedDeque(SIZE);
520 :     for (int i = SIZE - 1; i >= 0; --i) {
521 :     assertEquals(i, q.removeLast());
522 :     }
523 :     try {
524 :     q.removeLast();
525 :     shouldThrow();
526 :     } catch (NoSuchElementException success) {}
527 :     assertNull(q.peekLast());
528 : dl 1.1 }
529 :    
530 :     /**
531 :     * removeFirstOccurrence(x) removes x and returns true if present
532 :     */
533 :     public void testRemoveFirstOccurrence() {
534 :     ArrayDeque q = populatedDeque(SIZE);
535 : jsr166 1.31 for (int i = 1; i < SIZE; i += 2) {
536 : dl 1.1 assertTrue(q.removeFirstOccurrence(new Integer(i)));
537 :     }
538 : jsr166 1.31 for (int i = 0; i < SIZE; i += 2) {
539 : dl 1.1 assertTrue(q.removeFirstOccurrence(new Integer(i)));
540 :     assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
541 :     }
542 :     assertTrue(q.isEmpty());
543 :     }
544 :    
545 :     /**
546 :     * removeLastOccurrence(x) removes x and returns true if present
547 :     */
548 :     public void testRemoveLastOccurrence() {
549 :     ArrayDeque q = populatedDeque(SIZE);
550 : jsr166 1.31 for (int i = 1; i < SIZE; i += 2) {
551 : dl 1.1 assertTrue(q.removeLastOccurrence(new Integer(i)));
552 :     }
553 : jsr166 1.31 for (int i = 0; i < SIZE; i += 2) {
554 : dl 1.1 assertTrue(q.removeLastOccurrence(new Integer(i)));
555 :     assertFalse(q.removeLastOccurrence(new Integer(i+1)));
556 :     }
557 :     assertTrue(q.isEmpty());
558 :     }
559 :    
560 :     /**
561 :     * contains(x) reports true when elements added but not yet removed
562 :     */
563 :     public void testContains() {
564 :     ArrayDeque q = populatedDeque(SIZE);
565 :     for (int i = 0; i < SIZE; ++i) {
566 :     assertTrue(q.contains(new Integer(i)));
567 : jsr166 1.12 assertEquals(i, q.pollFirst());
568 : dl 1.1 assertFalse(q.contains(new Integer(i)));
569 :     }
570 :     }
571 :    
572 :     /**
573 :     * clear removes all elements
574 :     */
575 :     public void testClear() {
576 :     ArrayDeque q = populatedDeque(SIZE);
577 :     q.clear();
578 :     assertTrue(q.isEmpty());
579 :     assertEquals(0, q.size());
580 : jsr166 1.12 assertTrue(q.add(new Integer(1)));
581 : dl 1.1 assertFalse(q.isEmpty());
582 :     q.clear();
583 :     assertTrue(q.isEmpty());
584 :     }
585 :    
586 :     /**
587 :     * containsAll(c) is true when c contains a subset of elements
588 :     */
589 :     public void testContainsAll() {
590 :     ArrayDeque q = populatedDeque(SIZE);
591 :     ArrayDeque p = new ArrayDeque();
592 :     for (int i = 0; i < SIZE; ++i) {
593 :     assertTrue(q.containsAll(p));
594 :     assertFalse(p.containsAll(q));
595 : jsr166 1.12 assertTrue(p.add(new Integer(i)));
596 : dl 1.1 }
597 :     assertTrue(p.containsAll(q));
598 :     }
599 :    
600 :     /**
601 :     * retainAll(c) retains only those elements of c and reports true if changed
602 :     */
603 :     public void testRetainAll() {
604 :     ArrayDeque q = populatedDeque(SIZE);
605 :     ArrayDeque p = populatedDeque(SIZE);
606 :     for (int i = 0; i < SIZE; ++i) {
607 :     boolean changed = q.retainAll(p);
608 : jsr166 1.12 assertEquals(changed, (i > 0));
609 : dl 1.1 assertTrue(q.containsAll(p));
610 :     assertEquals(SIZE-i, q.size());
611 :     p.removeFirst();
612 :     }
613 :     }
614 :    
615 :     /**
616 :     * removeAll(c) removes only those elements of c and reports true if changed
617 :     */
618 :     public void testRemoveAll() {
619 :     for (int i = 1; i < SIZE; ++i) {
620 :     ArrayDeque q = populatedDeque(SIZE);
621 :     ArrayDeque p = populatedDeque(i);
622 :     assertTrue(q.removeAll(p));
623 :     assertEquals(SIZE-i, q.size());
624 :     for (int j = 0; j < i; ++j) {
625 : jsr166 1.12 assertFalse(q.contains(p.removeFirst()));
626 : dl 1.1 }
627 :     }
628 :     }
629 :    
630 : jsr166 1.27 void checkToArray(ArrayDeque q) {
631 :     int size = q.size();
632 :     Object[] o = q.toArray();
633 :     assertEquals(size, o.length);
634 :     Iterator it = q.iterator();
635 :     for (int i = 0; i < size; i++) {
636 :     Integer x = (Integer) it.next();
637 :     assertEquals((Integer)o[0] + i, (int) x);
638 :     assertSame(o[i], x);
639 :     }
640 :     }
641 :    
642 : dl 1.1 /**
643 : jsr166 1.19 * toArray() contains all elements in FIFO order
644 : dl 1.1 */
645 :     public void testToArray() {
646 : jsr166 1.27 ArrayDeque q = new ArrayDeque();
647 :     for (int i = 0; i < SIZE; i++) {
648 :     checkToArray(q);
649 :     q.addLast(i);
650 :     }
651 :     // Provoke wraparound
652 :     for (int i = 0; i < SIZE; i++) {
653 :     checkToArray(q);
654 :     assertEquals(i, q.poll());
655 :     q.addLast(SIZE+i);
656 :     }
657 :     for (int i = 0; i < SIZE; i++) {
658 :     checkToArray(q);
659 :     assertEquals(SIZE+i, q.poll());
660 :     }
661 :     }
662 :    
663 :     void checkToArray2(ArrayDeque q) {
664 :     int size = q.size();
665 :     Integer[] a1 = size == 0 ? null : new Integer[size-1];
666 :     Integer[] a2 = new Integer[size];
667 :     Integer[] a3 = new Integer[size+2];
668 :     if (size > 0) Arrays.fill(a1, 42);
669 :     Arrays.fill(a2, 42);
670 :     Arrays.fill(a3, 42);
671 :     Integer[] b1 = size == 0 ? null : (Integer[]) q.toArray(a1);
672 :     Integer[] b2 = (Integer[]) q.toArray(a2);
673 :     Integer[] b3 = (Integer[]) q.toArray(a3);
674 :     assertSame(a2, b2);
675 :     assertSame(a3, b3);
676 :     Iterator it = q.iterator();
677 :     for (int i = 0; i < size; i++) {
678 :     Integer x = (Integer) it.next();
679 :     assertSame(b1[i], x);
680 :     assertEquals(b1[0] + i, (int) x);
681 :     assertSame(b2[i], x);
682 :     assertSame(b3[i], x);
683 :     }
684 :     assertNull(a3[size]);
685 :     assertEquals(42, (int) a3[size+1]);
686 :     if (size > 0) {
687 :     assertNotSame(a1, b1);
688 :     assertEquals(size, b1.length);
689 :     for (int i = 0; i < a1.length; i++) {
690 :     assertEquals(42, (int) a1[i]);
691 :     }
692 :     }
693 : dl 1.1 }
694 :    
695 :     /**
696 : jsr166 1.19 * toArray(a) contains all elements in FIFO order
697 : dl 1.1 */
698 :     public void testToArray2() {
699 : jsr166 1.27 ArrayDeque q = new ArrayDeque();
700 :     for (int i = 0; i < SIZE; i++) {
701 :     checkToArray2(q);
702 :     q.addLast(i);
703 :     }
704 :     // Provoke wraparound
705 :     for (int i = 0; i < SIZE; i++) {
706 :     checkToArray2(q);
707 :     assertEquals(i, q.poll());
708 :     q.addLast(SIZE+i);
709 :     }
710 :     for (int i = 0; i < SIZE; i++) {
711 :     checkToArray2(q);
712 :     assertEquals(SIZE+i, q.poll());
713 :     }
714 : dl 1.1 }
715 :    
716 :     /**
717 : jsr166 1.18 * toArray(null) throws NullPointerException
718 : dl 1.1 */
719 : jsr166 1.18 public void testToArray_NullArg() {
720 : jsr166 1.12 ArrayDeque l = new ArrayDeque();
721 :     l.add(new Object());
722 : jsr166 1.8 try {
723 : jsr166 1.18 l.toArray(null);
724 : jsr166 1.8 shouldThrow();
725 :     } catch (NullPointerException success) {}
726 : dl 1.1 }
727 :    
728 :     /**
729 : jsr166 1.17 * toArray(incompatible array type) throws ArrayStoreException
730 : dl 1.1 */
731 :     public void testToArray1_BadArg() {
732 : jsr166 1.12 ArrayDeque l = new ArrayDeque();
733 :     l.add(new Integer(5));
734 : jsr166 1.8 try {
735 : jsr166 1.17 l.toArray(new String[10]);
736 : jsr166 1.8 shouldThrow();
737 : jsr166 1.9 } catch (ArrayStoreException success) {}
738 : dl 1.1 }
739 : jsr166 1.5
740 : dl 1.1 /**
741 : jsr166 1.16 * Iterator iterates through all elements
742 : dl 1.1 */
743 :     public void testIterator() {
744 :     ArrayDeque q = populatedDeque(SIZE);
745 : jsr166 1.8 Iterator it = q.iterator();
746 : jsr166 1.32 int i;
747 :     for (i = 0; it.hasNext(); i++)
748 : dl 1.1 assertTrue(q.contains(it.next()));
749 :     assertEquals(i, SIZE);
750 : jsr166 1.32 assertIteratorExhausted(it);
751 :     }
752 :    
753 :     /**
754 :     * iterator of empty collection has no elements
755 :     */
756 :     public void testEmptyIterator() {
757 :     Deque c = new ArrayDeque();
758 :     assertIteratorExhausted(c.iterator());
759 :     assertIteratorExhausted(c.descendingIterator());
760 : dl 1.1 }
761 :    
762 :     /**
763 : jsr166 1.16 * Iterator ordering is FIFO
764 : dl 1.1 */
765 :     public void testIteratorOrdering() {
766 :     final ArrayDeque q = new ArrayDeque();
767 : jsr166 1.16 q.add(one);
768 :     q.add(two);
769 :     q.add(three);
770 : dl 1.1 int k = 0;
771 :     for (Iterator it = q.iterator(); it.hasNext();) {
772 : jsr166 1.12 assertEquals(++k, it.next());
773 : dl 1.1 }
774 :    
775 :     assertEquals(3, k);
776 :     }
777 :    
778 :     /**
779 : jsr166 1.16 * iterator.remove() removes current element
780 : dl 1.1 */
781 : jsr166 1.16 public void testIteratorRemove() {
782 : dl 1.1 final ArrayDeque q = new ArrayDeque();
783 : dl 1.4 final Random rng = new Random();
784 : dl 1.3 for (int iters = 0; iters < 100; ++iters) {
785 : dl 1.4 int max = rng.nextInt(5) + 2;
786 :     int split = rng.nextInt(max-1) + 1;
787 :     for (int j = 1; j <= max; ++j)
788 :     q.add(new Integer(j));
789 : dl 1.3 Iterator it = q.iterator();
790 : jsr166 1.5 for (int j = 1; j <= split; ++j)
791 : dl 1.4 assertEquals(it.next(), new Integer(j));
792 : dl 1.3 it.remove();
793 : dl 1.4 assertEquals(it.next(), new Integer(split+1));
794 : jsr166 1.5 for (int j = 1; j <= split; ++j)
795 : dl 1.4 q.remove(new Integer(j));
796 : dl 1.3 it = q.iterator();
797 : dl 1.4 for (int j = split+1; j <= max; ++j) {
798 :     assertEquals(it.next(), new Integer(j));
799 :     it.remove();
800 :     }
801 : dl 1.3 assertFalse(it.hasNext());
802 : dl 1.4 assertTrue(q.isEmpty());
803 : dl 1.3 }
804 : dl 1.1 }
805 :    
806 : dl 1.2 /**
807 : jsr166 1.16 * Descending iterator iterates through all elements
808 : dl 1.2 */
809 :     public void testDescendingIterator() {
810 :     ArrayDeque q = populatedDeque(SIZE);
811 :     int i = 0;
812 : jsr166 1.8 Iterator it = q.descendingIterator();
813 : jsr166 1.6 while (it.hasNext()) {
814 : dl 1.2 assertTrue(q.contains(it.next()));
815 :     ++i;
816 :     }
817 :     assertEquals(i, SIZE);
818 :     assertFalse(it.hasNext());
819 :     try {
820 :     it.next();
821 : jsr166 1.11 shouldThrow();
822 : jsr166 1.9 } catch (NoSuchElementException success) {}
823 : dl 1.2 }
824 :    
825 :     /**
826 : jsr166 1.16 * Descending iterator ordering is reverse FIFO
827 : dl 1.2 */
828 :     public void testDescendingIteratorOrdering() {
829 :     final ArrayDeque q = new ArrayDeque();
830 : dl 1.3 for (int iters = 0; iters < 100; ++iters) {
831 :     q.add(new Integer(3));
832 :     q.add(new Integer(2));
833 :     q.add(new Integer(1));
834 :     int k = 0;
835 :     for (Iterator it = q.descendingIterator(); it.hasNext();) {
836 : jsr166 1.12 assertEquals(++k, it.next());
837 : dl 1.3 }
838 : jsr166 1.5
839 : dl 1.3 assertEquals(3, k);
840 :     q.remove();
841 :     q.remove();
842 :     q.remove();
843 : dl 1.2 }
844 :     }
845 :    
846 :     /**
847 : jsr166 1.16 * descendingIterator.remove() removes current element
848 : dl 1.2 */
849 : jsr166 1.16 public void testDescendingIteratorRemove() {
850 : dl 1.2 final ArrayDeque q = new ArrayDeque();
851 : dl 1.4 final Random rng = new Random();
852 : dl 1.3 for (int iters = 0; iters < 100; ++iters) {
853 : dl 1.4 int max = rng.nextInt(5) + 2;
854 :     int split = rng.nextInt(max-1) + 1;
855 :     for (int j = max; j >= 1; --j)
856 :     q.add(new Integer(j));
857 : dl 1.3 Iterator it = q.descendingIterator();
858 : jsr166 1.5 for (int j = 1; j <= split; ++j)
859 : dl 1.4 assertEquals(it.next(), new Integer(j));
860 : dl 1.3 it.remove();
861 : dl 1.4 assertEquals(it.next(), new Integer(split+1));
862 : jsr166 1.5 for (int j = 1; j <= split; ++j)
863 : dl 1.4 q.remove(new Integer(j));
864 : dl 1.3 it = q.descendingIterator();
865 : dl 1.4 for (int j = split+1; j <= max; ++j) {
866 :     assertEquals(it.next(), new Integer(j));
867 :     it.remove();
868 :     }
869 : dl 1.3 assertFalse(it.hasNext());
870 : dl 1.4 assertTrue(q.isEmpty());
871 : dl 1.3 }
872 : dl 1.2 }
873 :    
874 : dl 1.1 /**
875 : jsr166 1.16 * toString() contains toStrings of elements
876 : dl 1.1 */
877 :     public void testToString() {
878 :     ArrayDeque q = populatedDeque(SIZE);
879 :     String s = q.toString();
880 :     for (int i = 0; i < SIZE; ++i) {
881 : jsr166 1.23 assertTrue(s.contains(String.valueOf(i)));
882 : dl 1.1 }
883 : jsr166 1.5 }
884 : dl 1.1
885 :     /**
886 : jsr166 1.16 * A deserialized serialized deque has same elements in same order
887 : dl 1.1 */
888 : jsr166 1.16 public void testSerialization() throws Exception {
889 : jsr166 1.24 Queue x = populatedDeque(SIZE);
890 :     Queue y = serialClone(x);
891 :    
892 : jsr166 1.28 assertNotSame(y, x);
893 : jsr166 1.24 assertEquals(x.size(), y.size());
894 :     assertEquals(x.toString(), y.toString());
895 :     assertTrue(Arrays.equals(x.toArray(), y.toArray()));
896 :     while (!x.isEmpty()) {
897 :     assertFalse(y.isEmpty());
898 :     assertEquals(x.remove(), y.remove());
899 :     }
900 :     assertTrue(y.isEmpty());
901 : jsr166 1.5 }
902 : dl 1.1
903 : jsr166 1.29 /**
904 :     * remove(null), contains(null) always return false
905 :     */
906 :     public void testNeverContainsNull() {
907 :     Deque<?>[] qs = {
908 :     new ArrayDeque<Object>(),
909 :     populatedDeque(2),
910 :     };
911 :    
912 :     for (Deque<?> q : qs) {
913 :     assertFalse(q.contains(null));
914 :     assertFalse(q.remove(null));
915 :     assertFalse(q.removeFirstOccurrence(null));
916 :     assertFalse(q.removeLastOccurrence(null));
917 :     }
918 :     }
919 :    
920 : dl 1.1 }

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8