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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8