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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8