ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/ArrayDequeTest.java

Comparing jsr166/src/test/tck/ArrayDequeTest.java (file contents):
Revision 1.58 by jsr166, Mon Dec 16 21:16:09 2019 UTC vs.
Revision 1.59 by dl, Tue Jan 26 13:33:05 2021 UTC

#	Line 26 | Line 26 | public class ArrayDequeTest extends JSR1
26		class Implementation implements CollectionImplementation {
27		public Class<?> klazz() { return ArrayDeque.class; }
28		public Collection emptyCollection() { return populatedDeque(0); }
29	<	public Object makeElement(int i) { return i; }
29	>	public Object makeElement(int i) { return JSR166TestCase.itemFor(i); }
30		public boolean isConcurrent() { return false; }
31		public boolean permitsNulls() { return false; }
32		}
#	Line 36 | Line 36 | public class ArrayDequeTest extends JSR1
36
37		/**
38		* Returns a new deque of given size containing consecutive
39	<	* Integers 0 ... n - 1.
39	>	* Items 0 ... n - 1.
40		*/
41	<	private static ArrayDeque<Integer> populatedDeque(int n) {
41	>	private static ArrayDeque<Item> populatedDeque(int n) {
42		// Randomize various aspects of memory layout, including
43		// capacity slop and wraparound.
44	<	final ArrayDeque<Integer> q;
44	>	final ArrayDeque<Item> q;
45		ThreadLocalRandom rnd = ThreadLocalRandom.current();
46		switch (rnd.nextInt(6)) {
47	<	case 0: q = new ArrayDeque<Integer>();      break;
48	<	case 1: q = new ArrayDeque<Integer>(0);     break;
49	<	case 2: q = new ArrayDeque<Integer>(1);     break;
50	<	case 3: q = new ArrayDeque<Integer>(Math.max(0, n - 1)); break;
51	<	case 4: q = new ArrayDeque<Integer>(n);     break;
52	<	case 5: q = new ArrayDeque<Integer>(n + 1); break;
47	>	case 0: q = new ArrayDeque<Item>();      break;
48	>	case 1: q = new ArrayDeque<Item>(0);     break;
49	>	case 2: q = new ArrayDeque<Item>(1);     break;
50	>	case 3: q = new ArrayDeque<Item>(Math.max(0, n - 1)); break;
51	>	case 4: q = new ArrayDeque<Item>(n);     break;
52	>	case 5: q = new ArrayDeque<Item>(n + 1); break;
53		default: throw new AssertionError();
54		}
55		switch (rnd.nextInt(3)) {
56		case 0:
57	<	q.addFirst(42);
58	<	assertEquals((Integer) 42, q.removeLast());
57	>	q.addFirst(fortytwo);
58	>	mustEqual(42, q.removeLast());
59		break;
60		case 1:
61	<	q.addLast(42);
62	<	assertEquals((Integer) 42, q.removeFirst());
61	>	q.addLast(fortytwo);
62	>	mustEqual(42, q.removeFirst());
63		break;
64		case 2: /* do nothing */ break;
65		default: throw new AssertionError();
#	Line 67 | Line 67 | public class ArrayDequeTest extends JSR1
67		assertTrue(q.isEmpty());
68		if (rnd.nextBoolean())
69		for (int i = 0; i < n; i++)
70	<	assertTrue(q.offerLast((Integer) i));
70	>	assertTrue(q.offerLast(itemFor(i)));
71		else
72		for (int i = n; --i >= 0; )
73	<	q.addFirst((Integer) i);
74	<	assertEquals(n, q.size());
73	>	q.addFirst(itemFor(i));
74	>	mustEqual(n, q.size());
75		if (n > 0) {
76		assertFalse(q.isEmpty());
77	<	assertEquals((Integer) 0, q.peekFirst());
78	<	assertEquals((Integer) (n - 1), q.peekLast());
77	>	mustEqual(0, q.peekFirst());
78	>	mustEqual((n - 1), q.peekLast());
79		}
80		return q;
81		}
#	Line 84 | Line 84 | public class ArrayDequeTest extends JSR1
84		* new deque is empty
85		*/
86		public void testConstructor1() {
87	<	assertEquals(0, new ArrayDeque().size());
87	>	mustEqual(0, new ArrayDeque<Item>().size());
88		}
89
90		/**
#	Line 92 | Line 92 | public class ArrayDequeTest extends JSR1
92		*/
93		public void testConstructor3() {
94		try {
95	<	new ArrayDeque((Collection)null);
95	>	new ArrayDeque<Object>((Collection<Object>)null);
96		shouldThrow();
97		} catch (NullPointerException success) {}
98		}
#	Line 102 | Line 102 | public class ArrayDequeTest extends JSR1
102		*/
103		public void testConstructor4() {
104		try {
105	<	new ArrayDeque(Arrays.asList(new Integer[SIZE]));
105	>	new ArrayDeque<Item>(Arrays.asList(new Item[SIZE]));
106		shouldThrow();
107		} catch (NullPointerException success) {}
108		}
#	Line 111 | Line 111 | public class ArrayDequeTest extends JSR1
111		* Initializing from Collection with some null elements throws NPE
112		*/
113		public void testConstructor5() {
114	<	Integer[] ints = new Integer[SIZE];
115	<	for (int i = 0; i < SIZE - 1; ++i)
116	<	ints[i] = new Integer(i);
114	>	Item[] items = new Item[2]; items[0] = zero;
115		try {
116	<	new ArrayDeque(Arrays.asList(ints));
116	>	new ArrayDeque<Item>(Arrays.asList(items));
117		shouldThrow();
118		} catch (NullPointerException success) {}
119		}
#	Line 124 | Line 122 | public class ArrayDequeTest extends JSR1
122		* Deque contains all elements of collection used to initialize
123		*/
124		public void testConstructor6() {
125	<	Integer[] ints = new Integer[SIZE];
125	>	Item[] items = defaultItems;
126	>	ArrayDeque<Item> q = new ArrayDeque<Item>(Arrays.asList(items));
127		for (int i = 0; i < SIZE; ++i)
128	<	ints[i] = new Integer(i);
130	<	ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
131	<	for (int i = 0; i < SIZE; ++i)
132	<	assertEquals(ints[i], q.pollFirst());
128	>	mustEqual(items[i], q.pollFirst());
129		}
130
131		/**
132		* isEmpty is true before add, false after
133		*/
134		public void testEmpty() {
135	<	ArrayDeque q = new ArrayDeque();
135	>	ArrayDeque<Item> q = new ArrayDeque<Item>();
136		assertTrue(q.isEmpty());
137	<	q.add(new Integer(1));
137	>	q.add(one);
138		assertFalse(q.isEmpty());
139	<	q.add(new Integer(2));
139	>	q.add(two);
140		q.removeFirst();
141		q.removeFirst();
142		assertTrue(q.isEmpty());
#	Line 150 | Line 146 | public class ArrayDequeTest extends JSR1
146		* size changes when elements added and removed
147		*/
148		public void testSize() {
149	<	ArrayDeque q = populatedDeque(SIZE);
149	>	ArrayDeque<Item> q = populatedDeque(SIZE);
150		for (int i = 0; i < SIZE; ++i) {
151	<	assertEquals(SIZE - i, q.size());
151	>	mustEqual(SIZE - i, q.size());
152		q.removeFirst();
153		}
154		for (int i = 0; i < SIZE; ++i) {
155	<	assertEquals(i, q.size());
156	<	q.add(new Integer(i));
155	>	mustEqual(i, q.size());
156	>	mustAdd(q, i);
157		}
158		}
159
#	Line 165 | Line 161 | public class ArrayDequeTest extends JSR1
161		* push(null) throws NPE
162		*/
163		public void testPushNull() {
164	<	ArrayDeque q = new ArrayDeque(1);
164	>	ArrayDeque<Item> q = new ArrayDeque<Item>(1);
165		try {
166		q.push(null);
167		shouldThrow();
#	Line 176 | Line 172 | public class ArrayDequeTest extends JSR1
172		* peekFirst() returns element inserted with push
173		*/
174		public void testPush() {
175	<	ArrayDeque q = populatedDeque(3);
175	>	ArrayDeque<Item> q = populatedDeque(3);
176		q.pollLast();
177		q.push(four);
178		assertSame(four, q.peekFirst());
#	Line 186 | Line 182 | public class ArrayDequeTest extends JSR1
182		* pop() removes next element, or throws NSEE if empty
183		*/
184		public void testPop() {
185	<	ArrayDeque q = populatedDeque(SIZE);
185	>	ArrayDeque<Item> q = populatedDeque(SIZE);
186		for (int i = 0; i < SIZE; ++i) {
187	<	assertEquals(i, q.pop());
187	>	mustEqual(i, q.pop());
188		}
189		try {
190		q.pop();
#	Line 200 | Line 196 | public class ArrayDequeTest extends JSR1
196		* offer(null) throws NPE
197		*/
198		public void testOfferNull() {
199	<	ArrayDeque q = new ArrayDeque();
199	>	ArrayDeque<Item> q = new ArrayDeque<Item>();
200		try {
201		q.offer(null);
202		shouldThrow();
#	Line 211 | Line 207 | public class ArrayDequeTest extends JSR1
207		* offerFirst(null) throws NPE
208		*/
209		public void testOfferFirstNull() {
210	<	ArrayDeque q = new ArrayDeque();
210	>	ArrayDeque<Item> q = new ArrayDeque<Item>();
211		try {
212		q.offerFirst(null);
213		shouldThrow();
#	Line 222 | Line 218 | public class ArrayDequeTest extends JSR1
218		* offerLast(null) throws NPE
219		*/
220		public void testOfferLastNull() {
221	<	ArrayDeque q = new ArrayDeque();
221	>	ArrayDeque<Item> q = new ArrayDeque<Item>();
222		try {
223		q.offerLast(null);
224		shouldThrow();
#	Line 233 | Line 229 | public class ArrayDequeTest extends JSR1
229		* offer(x) succeeds
230		*/
231		public void testOffer() {
232	<	ArrayDeque q = new ArrayDeque();
232	>	ArrayDeque<Item> q = new ArrayDeque<Item>();
233		assertTrue(q.offer(zero));
234		assertTrue(q.offer(one));
235		assertSame(zero, q.peekFirst());
#	Line 244 | Line 240 | public class ArrayDequeTest extends JSR1
240		* offerFirst(x) succeeds
241		*/
242		public void testOfferFirst() {
243	<	ArrayDeque q = new ArrayDeque();
243	>	ArrayDeque<Item> q = new ArrayDeque<Item>();
244		assertTrue(q.offerFirst(zero));
245		assertTrue(q.offerFirst(one));
246		assertSame(one, q.peekFirst());
#	Line 255 | Line 251 | public class ArrayDequeTest extends JSR1
251		* offerLast(x) succeeds
252		*/
253		public void testOfferLast() {
254	<	ArrayDeque q = new ArrayDeque();
254	>	ArrayDeque<Item> q = new ArrayDeque<Item>();
255		assertTrue(q.offerLast(zero));
256		assertTrue(q.offerLast(one));
257		assertSame(zero, q.peekFirst());
#	Line 266 | Line 262 | public class ArrayDequeTest extends JSR1
262		* add(null) throws NPE
263		*/
264		public void testAddNull() {
265	<	ArrayDeque q = new ArrayDeque();
265	>	ArrayDeque<Item> q = new ArrayDeque<Item>();
266		try {
267		q.add(null);
268		shouldThrow();
#	Line 277 | Line 273 | public class ArrayDequeTest extends JSR1
273		* addFirst(null) throws NPE
274		*/
275		public void testAddFirstNull() {
276	<	ArrayDeque q = new ArrayDeque();
276	>	ArrayDeque<Item> q = new ArrayDeque<Item>();
277		try {
278		q.addFirst(null);
279		shouldThrow();
#	Line 288 | Line 284 | public class ArrayDequeTest extends JSR1
284		* addLast(null) throws NPE
285		*/
286		public void testAddLastNull() {
287	<	ArrayDeque q = new ArrayDeque();
287	>	ArrayDeque<Item> q = new ArrayDeque<Item>();
288		try {
289		q.addLast(null);
290		shouldThrow();
#	Line 299 | Line 295 | public class ArrayDequeTest extends JSR1
295		* add(x) succeeds
296		*/
297		public void testAdd() {
298	<	ArrayDeque q = new ArrayDeque();
298	>	ArrayDeque<Item> q = new ArrayDeque<Item>();
299		assertTrue(q.add(zero));
300		assertTrue(q.add(one));
301		assertSame(zero, q.peekFirst());
#	Line 310 | Line 306 | public class ArrayDequeTest extends JSR1
306		* addFirst(x) succeeds
307		*/
308		public void testAddFirst() {
309	<	ArrayDeque q = new ArrayDeque();
309	>	ArrayDeque<Item> q = new ArrayDeque<Item>();
310		q.addFirst(zero);
311		q.addFirst(one);
312		assertSame(one, q.peekFirst());
#	Line 321 | Line 317 | public class ArrayDequeTest extends JSR1
317		* addLast(x) succeeds
318		*/
319		public void testAddLast() {
320	<	ArrayDeque q = new ArrayDeque();
320	>	ArrayDeque<Item> q = new ArrayDeque<Item>();
321		q.addLast(zero);
322		q.addLast(one);
323		assertSame(zero, q.peekFirst());
#	Line 332 | Line 328 | public class ArrayDequeTest extends JSR1
328		* addAll(null) throws NPE
329		*/
330		public void testAddAll1() {
331	<	ArrayDeque q = new ArrayDeque();
331	>	ArrayDeque<Item> q = new ArrayDeque<Item>();
332		try {
333		q.addAll(null);
334		shouldThrow();
#	Line 343 | Line 339 | public class ArrayDequeTest extends JSR1
339		* addAll of a collection with null elements throws NPE
340		*/
341		public void testAddAll2() {
342	<	ArrayDeque q = new ArrayDeque();
342	>	ArrayDeque<Item> q = new ArrayDeque<Item>();
343		try {
344	<	q.addAll(Arrays.asList(new Integer[SIZE]));
344	>	q.addAll(Arrays.asList(new Item[SIZE]));
345		shouldThrow();
346		} catch (NullPointerException success) {}
347		}
#	Line 355 | Line 351 | public class ArrayDequeTest extends JSR1
351		* possibly adding some elements
352		*/
353		public void testAddAll3() {
354	<	ArrayDeque q = new ArrayDeque();
355	<	Integer[] ints = new Integer[SIZE];
360	<	for (int i = 0; i < SIZE - 1; ++i)
361	<	ints[i] = new Integer(i);
354	>	ArrayDeque<Item> q = new ArrayDeque<Item>();
355	>	Item[] items = new Item[2]; items[0] = zero;
356		try {
357	<	q.addAll(Arrays.asList(ints));
357	>	q.addAll(Arrays.asList(items));
358		shouldThrow();
359		} catch (NullPointerException success) {}
360		}
#	Line 369 | Line 363 | public class ArrayDequeTest extends JSR1
363		* Deque contains all elements, in traversal order, of successful addAll
364		*/
365		public void testAddAll5() {
366	<	Integer[] empty = new Integer[0];
367	<	Integer[] ints = new Integer[SIZE];
368	<	for (int i = 0; i < SIZE; ++i)
375	<	ints[i] = new Integer(i);
376	<	ArrayDeque q = new ArrayDeque();
366	>	Item[] empty = new Item[0];
367	>	Item[] items = defaultItems;
368	>	ArrayDeque<Item> q = new ArrayDeque<Item>();
369		assertFalse(q.addAll(Arrays.asList(empty)));
370	<	assertTrue(q.addAll(Arrays.asList(ints)));
370	>	assertTrue(q.addAll(Arrays.asList(items)));
371		for (int i = 0; i < SIZE; ++i)
372	<	assertEquals(ints[i], q.pollFirst());
372	>	mustEqual(items[i], q.pollFirst());
373		}
374
375		/**
376		* pollFirst() succeeds unless empty
377		*/
378		public void testPollFirst() {
379	<	ArrayDeque q = populatedDeque(SIZE);
379	>	ArrayDeque<Item> q = populatedDeque(SIZE);
380		for (int i = 0; i < SIZE; ++i) {
381	<	assertEquals(i, q.pollFirst());
381	>	mustEqual(i, q.pollFirst());
382		}
383		assertNull(q.pollFirst());
384		}
#	Line 395 | Line 387 | public class ArrayDequeTest extends JSR1
387		* pollLast() succeeds unless empty
388		*/
389		public void testPollLast() {
390	<	ArrayDeque q = populatedDeque(SIZE);
390	>	ArrayDeque<Item> q = populatedDeque(SIZE);
391		for (int i = SIZE - 1; i >= 0; --i) {
392	<	assertEquals(i, q.pollLast());
392	>	mustEqual(i, q.pollLast());
393		}
394		assertNull(q.pollLast());
395		}
#	Line 406 | Line 398 | public class ArrayDequeTest extends JSR1
398		* poll() succeeds unless empty
399		*/
400		public void testPoll() {
401	<	ArrayDeque q = populatedDeque(SIZE);
401	>	ArrayDeque<Item> q = populatedDeque(SIZE);
402		for (int i = 0; i < SIZE; ++i) {
403	<	assertEquals(i, q.poll());
403	>	mustEqual(i, q.poll());
404		}
405		assertNull(q.poll());
406		}
#	Line 417 | Line 409 | public class ArrayDequeTest extends JSR1
409		* remove() removes next element, or throws NSEE if empty
410		*/
411		public void testRemove() {
412	<	ArrayDeque q = populatedDeque(SIZE);
412	>	ArrayDeque<Item> q = populatedDeque(SIZE);
413		for (int i = 0; i < SIZE; ++i) {
414	<	assertEquals(i, q.remove());
414	>	mustEqual(i, q.remove());
415		}
416		try {
417		q.remove();
#	Line 431 | Line 423 | public class ArrayDequeTest extends JSR1
423		* remove(x) removes x and returns true if present
424		*/
425		public void testRemoveElement() {
426	<	ArrayDeque q = populatedDeque(SIZE);
426	>	ArrayDeque<Item> q = populatedDeque(SIZE);
427		for (int i = 1; i < SIZE; i += 2) {
428	<	assertTrue(q.contains(i));
429	<	assertTrue(q.remove(i));
430	<	assertFalse(q.contains(i));
431	<	assertTrue(q.contains(i - 1));
428	>	mustContain(q, i);
429	>	mustRemove(q, i);
430	>	mustNotContain(q, i);
431	>	mustContain(q, i - 1);
432		}
433		for (int i = 0; i < SIZE; i += 2) {
434	<	assertTrue(q.contains(i));
435	<	assertTrue(q.remove(i));
436	<	assertFalse(q.contains(i));
437	<	assertFalse(q.remove(i + 1));
438	<	assertFalse(q.contains(i + 1));
434	>	mustContain(q, i);
435	>	mustRemove(q, i);
436	>	mustNotContain(q, i);
437	>	mustNotRemove(q, i + 1);
438	>	mustNotContain(q, i + 1);
439		}
440		assertTrue(q.isEmpty());
441		}
#	Line 452 | Line 444 | public class ArrayDequeTest extends JSR1
444		* peekFirst() returns next element, or null if empty
445		*/
446		public void testPeekFirst() {
447	<	ArrayDeque q = populatedDeque(SIZE);
447	>	ArrayDeque<Item> q = populatedDeque(SIZE);
448		for (int i = 0; i < SIZE; ++i) {
449	<	assertEquals(i, q.peekFirst());
450	<	assertEquals(i, q.pollFirst());
449	>	mustEqual(i, q.peekFirst());
450	>	mustEqual(i, q.pollFirst());
451		assertTrue(q.peekFirst() == null ||
452		!q.peekFirst().equals(i));
453		}
#	Line 466 | Line 458 | public class ArrayDequeTest extends JSR1
458		* peek() returns next element, or null if empty
459		*/
460		public void testPeek() {
461	<	ArrayDeque q = populatedDeque(SIZE);
461	>	ArrayDeque<Item> q = populatedDeque(SIZE);
462		for (int i = 0; i < SIZE; ++i) {
463	<	assertEquals(i, q.peek());
464	<	assertEquals(i, q.poll());
463	>	mustEqual(i, q.peek());
464	>	mustEqual(i, q.poll());
465		assertTrue(q.peek() == null ||
466		!q.peek().equals(i));
467		}
#	Line 480 | Line 472 | public class ArrayDequeTest extends JSR1
472		* peekLast() returns next element, or null if empty
473		*/
474		public void testPeekLast() {
475	<	ArrayDeque q = populatedDeque(SIZE);
475	>	ArrayDeque<Item> q = populatedDeque(SIZE);
476		for (int i = SIZE - 1; i >= 0; --i) {
477	<	assertEquals(i, q.peekLast());
478	<	assertEquals(i, q.pollLast());
477	>	mustEqual(i, q.peekLast());
478	>	mustEqual(i, q.pollLast());
479		assertTrue(q.peekLast() == null ||
480		!q.peekLast().equals(i));
481		}
#	Line 494 | Line 486 | public class ArrayDequeTest extends JSR1
486		* element() returns first element, or throws NSEE if empty
487		*/
488		public void testElement() {
489	<	ArrayDeque q = populatedDeque(SIZE);
489	>	ArrayDeque<Item> q = populatedDeque(SIZE);
490		for (int i = 0; i < SIZE; ++i) {
491	<	assertEquals(i, q.element());
492	<	assertEquals(i, q.poll());
491	>	mustEqual(i, q.element());
492	>	mustEqual(i, q.poll());
493		}
494		try {
495		q.element();
#	Line 509 | Line 501 | public class ArrayDequeTest extends JSR1
501		* getFirst() returns first element, or throws NSEE if empty
502		*/
503		public void testFirstElement() {
504	<	ArrayDeque q = populatedDeque(SIZE);
504	>	ArrayDeque<Item> q = populatedDeque(SIZE);
505		for (int i = 0; i < SIZE; ++i) {
506	<	assertEquals(i, q.getFirst());
507	<	assertEquals(i, q.pollFirst());
506	>	mustEqual(i, q.getFirst());
507	>	mustEqual(i, q.pollFirst());
508		}
509		try {
510		q.getFirst();
#	Line 524 | Line 516 | public class ArrayDequeTest extends JSR1
516		* getLast() returns last element, or throws NSEE if empty
517		*/
518		public void testLastElement() {
519	<	ArrayDeque q = populatedDeque(SIZE);
519	>	ArrayDeque<Item> q = populatedDeque(SIZE);
520		for (int i = SIZE - 1; i >= 0; --i) {
521	<	assertEquals(i, q.getLast());
522	<	assertEquals(i, q.pollLast());
521	>	mustEqual(i, q.getLast());
522	>	mustEqual(i, q.pollLast());
523		}
524		try {
525		q.getLast();
#	Line 540 | Line 532 | public class ArrayDequeTest extends JSR1
532		* removeFirst() removes first element, or throws NSEE if empty
533		*/
534		public void testRemoveFirst() {
535	<	ArrayDeque q = populatedDeque(SIZE);
535	>	ArrayDeque<Item> q = populatedDeque(SIZE);
536		for (int i = 0; i < SIZE; ++i) {
537	<	assertEquals(i, q.removeFirst());
537	>	mustEqual(i, q.removeFirst());
538		}
539		try {
540		q.removeFirst();
#	Line 555 | Line 547 | public class ArrayDequeTest extends JSR1
547		* removeLast() removes last element, or throws NSEE if empty
548		*/
549		public void testRemoveLast() {
550	<	ArrayDeque q = populatedDeque(SIZE);
550	>	ArrayDeque<Item> q = populatedDeque(SIZE);
551		for (int i = SIZE - 1; i >= 0; --i) {
552	<	assertEquals(i, q.removeLast());
552	>	mustEqual(i, q.removeLast());
553		}
554		try {
555		q.removeLast();
#	Line 570 | Line 562 | public class ArrayDequeTest extends JSR1
562		* removeFirstOccurrence(x) removes x and returns true if present
563		*/
564		public void testRemoveFirstOccurrence() {
565	<	Deque<Integer> q = populatedDeque(SIZE);
565	>	Deque<Item> q = populatedDeque(SIZE);
566		assertFalse(q.removeFirstOccurrence(null));
567		for (int i = 1; i < SIZE; i += 2) {
568	<	assertTrue(q.removeFirstOccurrence(i));
569	<	assertFalse(q.contains(i));
568	>	assertTrue(q.removeFirstOccurrence(itemFor(i)));
569	>	mustNotContain(q, i);
570		}
571		for (int i = 0; i < SIZE; i += 2) {
572	<	assertTrue(q.removeFirstOccurrence(i));
573	<	assertFalse(q.removeFirstOccurrence(i + 1));
574	<	assertFalse(q.contains(i));
575	<	assertFalse(q.contains(i + 1));
572	>	assertTrue(q.removeFirstOccurrence(itemFor(i)));
573	>	assertFalse(q.removeFirstOccurrence(itemFor(i + 1)));
574	>	mustNotContain(q, i);
575	>	mustNotContain(q, i + 1);
576		}
577		assertTrue(q.isEmpty());
578		assertFalse(q.removeFirstOccurrence(null));
579	<	assertFalse(q.removeFirstOccurrence(42));
580	<	q = new ArrayDeque();
579	>	assertFalse(q.removeFirstOccurrence(fortytwo));
580	>	q = new ArrayDeque<Item>();
581		assertFalse(q.removeFirstOccurrence(null));
582	<	assertFalse(q.removeFirstOccurrence(42));
582	>	assertFalse(q.removeFirstOccurrence(fortytwo));
583		}
584
585		/**
586		* removeLastOccurrence(x) removes x and returns true if present
587		*/
588		public void testRemoveLastOccurrence() {
589	<	Deque<Integer> q = populatedDeque(SIZE);
589	>	Deque<Item> q = populatedDeque(SIZE);
590		assertFalse(q.removeLastOccurrence(null));
591		for (int i = 1; i < SIZE; i += 2) {
592	<	assertTrue(q.removeLastOccurrence(i));
593	<	assertFalse(q.contains(i));
592	>	assertTrue(q.removeLastOccurrence(itemFor(i)));
593	>	mustNotContain(q, i);
594		}
595		for (int i = 0; i < SIZE; i += 2) {
596	<	assertTrue(q.removeLastOccurrence(i));
597	<	assertFalse(q.removeLastOccurrence(i + 1));
598	<	assertFalse(q.contains(i));
599	<	assertFalse(q.contains(i + 1));
596	>	assertTrue(q.removeLastOccurrence(itemFor(i)));
597	>	assertFalse(q.removeLastOccurrence(itemFor(i + 1)));
598	>	mustNotContain(q, i);
599	>	mustNotContain(q, i + 1);
600		}
601		assertTrue(q.isEmpty());
602		assertFalse(q.removeLastOccurrence(null));
603	<	assertFalse(q.removeLastOccurrence(42));
604	<	q = new ArrayDeque();
603	>	assertFalse(q.removeLastOccurrence(fortytwo));
604	>	q = new ArrayDeque<Item>();
605		assertFalse(q.removeLastOccurrence(null));
606	<	assertFalse(q.removeLastOccurrence(42));
606	>	assertFalse(q.removeLastOccurrence(fortytwo));
607		}
608
609		/**
610		* contains(x) reports true when elements added but not yet removed
611		*/
612		public void testContains() {
613	<	ArrayDeque q = populatedDeque(SIZE);
613	>	ArrayDeque<Item> q = populatedDeque(SIZE);
614		for (int i = 0; i < SIZE; ++i) {
615	<	assertTrue(q.contains(new Integer(i)));
616	<	assertEquals(i, q.pollFirst());
617	<	assertFalse(q.contains(new Integer(i)));
615	>	mustContain(q, i);
616	>	mustEqual(i, q.pollFirst());
617	>	mustNotContain(q, i);
618		}
619		}
620
#	Line 630 | Line 622 | public class ArrayDequeTest extends JSR1
622		* clear removes all elements
623		*/
624		public void testClear() {
625	<	ArrayDeque q = populatedDeque(SIZE);
625	>	ArrayDeque<Item> q = populatedDeque(SIZE);
626		q.clear();
627		assertTrue(q.isEmpty());
628	<	assertEquals(0, q.size());
629	<	assertTrue(q.add(new Integer(1)));
628	>	mustEqual(0, q.size());
629	>	mustAdd(q, one);
630		assertFalse(q.isEmpty());
631		q.clear();
632		assertTrue(q.isEmpty());
#	Line 644 | Line 636 | public class ArrayDequeTest extends JSR1
636		* containsAll(c) is true when c contains a subset of elements
637		*/
638		public void testContainsAll() {
639	<	ArrayDeque q = populatedDeque(SIZE);
640	<	ArrayDeque p = new ArrayDeque();
639	>	ArrayDeque<Item> q = populatedDeque(SIZE);
640	>	ArrayDeque<Item> p = new ArrayDeque<Item>();
641		for (int i = 0; i < SIZE; ++i) {
642		assertTrue(q.containsAll(p));
643		assertFalse(p.containsAll(q));
644	<	assertTrue(p.add(new Integer(i)));
644	>	mustAdd(p, i);
645		}
646		assertTrue(p.containsAll(q));
647		}
#	Line 658 | Line 650 | public class ArrayDequeTest extends JSR1
650		* retainAll(c) retains only those elements of c and reports true if changed
651		*/
652		public void testRetainAll() {
653	<	ArrayDeque q = populatedDeque(SIZE);
654	<	ArrayDeque p = populatedDeque(SIZE);
653	>	ArrayDeque<Item> q = populatedDeque(SIZE);
654	>	ArrayDeque<Item> p = populatedDeque(SIZE);
655		for (int i = 0; i < SIZE; ++i) {
656		boolean changed = q.retainAll(p);
657	<	assertEquals(changed, (i > 0));
657	>	mustEqual(changed, (i > 0));
658		assertTrue(q.containsAll(p));
659	<	assertEquals(SIZE - i, q.size());
659	>	mustEqual(SIZE - i, q.size());
660		p.removeFirst();
661		}
662		}
#	Line 674 | Line 666 | public class ArrayDequeTest extends JSR1
666		*/
667		public void testRemoveAll() {
668		for (int i = 1; i < SIZE; ++i) {
669	<	ArrayDeque q = populatedDeque(SIZE);
670	<	ArrayDeque p = populatedDeque(i);
669	>	ArrayDeque<Item> q = populatedDeque(SIZE);
670	>	ArrayDeque<Item> p = populatedDeque(i);
671		assertTrue(q.removeAll(p));
672	<	assertEquals(SIZE - i, q.size());
672	>	mustEqual(SIZE - i, q.size());
673		for (int j = 0; j < i; ++j) {
674	<	assertFalse(q.contains(p.removeFirst()));
674	>	mustNotContain(q, p.removeFirst());
675		}
676		}
677		}
678
679	<	void checkToArray(ArrayDeque<Integer> q) {
679	>	void checkToArray(ArrayDeque<Item> q) {
680		int size = q.size();
681		Object[] a1 = q.toArray();
682	<	assertEquals(size, a1.length);
683	<	Integer[] a2 = q.toArray(new Integer[0]);
684	<	assertEquals(size, a2.length);
685	<	Integer[] a3 = q.toArray(new Integer[Math.max(0, size - 1)]);
686	<	assertEquals(size, a3.length);
687	<	Integer[] a4 = new Integer[size];
682	>	mustEqual(size, a1.length);
683	>	Item[] a2 = q.toArray(new Item[0]);
684	>	mustEqual(size, a2.length);
685	>	Item[] a3 = q.toArray(new Item[Math.max(0, size - 1)]);
686	>	mustEqual(size, a3.length);
687	>	Item[] a4 = new Item[size];
688		assertSame(a4, q.toArray(a4));
689	<	Integer[] a5 = new Integer[size + 1];
690	<	Arrays.fill(a5, 42);
689	>	Item[] a5 = new Item[size + 1];
690	>	Arrays.fill(a5, fortytwo);
691		assertSame(a5, q.toArray(a5));
692	<	Integer[] a6 = new Integer[size + 2];
693	<	Arrays.fill(a6, 42);
692	>	Item[] a6 = new Item[size + 2];
693	>	Arrays.fill(a6, fortytwo);
694		assertSame(a6, q.toArray(a6));
695		Object[][] as = { a1, a2, a3, a4, a5, a6 };
696		for (Object[] a : as) {
697		if (a.length > size) assertNull(a[size]);
698	<	if (a.length > size + 1) assertEquals(42, a[size + 1]);
698	>	if (a.length > size + 1) mustEqual(fortytwo, a[size + 1]);
699		}
700	<	Iterator it = q.iterator();
701	<	Integer s = q.peekFirst();
700	>	Iterator<? extends Item> it = q.iterator();
701	>	Item s = q.peekFirst();
702		for (int i = 0; i < size; i++) {
703	<	Integer x = (Integer) it.next();
704	<	assertEquals(s + i, (int) x);
703	>	Item x = (Item) it.next();
704	>	mustEqual(s.value + i, x);
705		for (Object[] a : as)
706		assertSame(a[i], x);
707		}
#	Line 720 | Line 712 | public class ArrayDequeTest extends JSR1
712		*/
713		public void testToArray() {
714		final int size = ThreadLocalRandom.current().nextInt(10);
715	<	ArrayDeque<Integer> q = new ArrayDeque<>(size);
715	>	ArrayDeque<Item> q = new ArrayDeque<>(size);
716		for (int i = 0; i < size; i++) {
717		checkToArray(q);
718	<	q.addLast(i);
718	>	q.addLast(itemFor(i));
719		}
720		// Provoke wraparound
721		int added = size * 2;
722		for (int i = 0; i < added; i++) {
723		checkToArray(q);
724	<	assertEquals((Integer) i, q.poll());
725	<	q.addLast(size + i);
724	>	mustEqual(i, q.poll());
725	>	q.addLast(itemFor(size + i));
726		}
727		for (int i = 0; i < size; i++) {
728		checkToArray(q);
729	<	assertEquals((Integer) (added + i), q.poll());
729	>	mustEqual((added + i), q.poll());
730		}
731		}
732
#	Line 742 | Line 734 | public class ArrayDequeTest extends JSR1
734		* toArray(null) throws NullPointerException
735		*/
736		public void testToArray_NullArg() {
737	<	ArrayDeque l = new ArrayDeque();
738	<	l.add(new Object());
737	>	ArrayDeque<Item> l = new ArrayDeque<Item>();
738	>	l.add(zero);
739		try {
740		l.toArray((Object[])null);
741		shouldThrow();
#	Line 754 | Line 746 | public class ArrayDequeTest extends JSR1
746		* toArray(incompatible array type) throws ArrayStoreException
747		*/
748		public void testToArray_incompatibleArrayType() {
749	<	ArrayDeque l = new ArrayDeque();
750	<	l.add(new Integer(5));
749	>	ArrayDeque<Item> l = new ArrayDeque<Item>();
750	>	l.add(five);
751		try {
752		l.toArray(new String[10]);
753		shouldThrow();
#	Line 770 | Line 762 | public class ArrayDequeTest extends JSR1
762		* Iterator iterates through all elements
763		*/
764		public void testIterator() {
765	<	ArrayDeque q = populatedDeque(SIZE);
766	<	Iterator it = q.iterator();
765	>	ArrayDeque<Item> q = populatedDeque(SIZE);
766	>	Iterator<? extends Item> it = q.iterator();
767		int i;
768		for (i = 0; it.hasNext(); i++)
769	<	assertTrue(q.contains(it.next()));
770	<	assertEquals(i, SIZE);
769	>	mustContain(q, it.next());
770	>	mustEqual(i, SIZE);
771		assertIteratorExhausted(it);
772		}
773
#	Line 783 | Line 775 | public class ArrayDequeTest extends JSR1
775		* iterator of empty collection has no elements
776		*/
777		public void testEmptyIterator() {
778	<	Deque c = new ArrayDeque();
778	>	Deque<Item> c = new ArrayDeque<Item>();
779		assertIteratorExhausted(c.iterator());
780		assertIteratorExhausted(c.descendingIterator());
781		}
#	Line 792 | Line 784 | public class ArrayDequeTest extends JSR1
784		* Iterator ordering is FIFO
785		*/
786		public void testIteratorOrdering() {
787	<	final ArrayDeque q = new ArrayDeque();
787	>	final ArrayDeque<Item> q = new ArrayDeque<Item>();
788		q.add(one);
789		q.add(two);
790		q.add(three);
791		int k = 0;
792	<	for (Iterator it = q.iterator(); it.hasNext();) {
793	<	assertEquals(++k, it.next());
792	>	for (Iterator<? extends Item> it = q.iterator(); it.hasNext();) {
793	>	mustEqual(++k, it.next());
794		}
795
796	<	assertEquals(3, k);
796	>	mustEqual(3, k);
797		}
798
799		/**
800		* iterator.remove() removes current element
801		*/
802		public void testIteratorRemove() {
803	<	final ArrayDeque q = new ArrayDeque();
803	>	final ArrayDeque<Item> q = new ArrayDeque<Item>();
804		final Random rng = new Random();
805		for (int iters = 0; iters < 100; ++iters) {
806		int max = rng.nextInt(5) + 2;
807		int split = rng.nextInt(max - 1) + 1;
808		for (int j = 1; j <= max; ++j)
809	<	q.add(new Integer(j));
810	<	Iterator it = q.iterator();
809	>	mustAdd(q, j);
810	>	Iterator<? extends Item> it = q.iterator();
811		for (int j = 1; j <= split; ++j)
812	<	assertEquals(it.next(), new Integer(j));
812	>	mustEqual(it.next(), j);
813		it.remove();
814	<	assertEquals(it.next(), new Integer(split + 1));
814	>	mustEqual(it.next(), split + 1);
815		for (int j = 1; j <= split; ++j)
816	<	q.remove(new Integer(j));
816	>	q.remove(itemFor(j));
817		it = q.iterator();
818		for (int j = split + 1; j <= max; ++j) {
819	<	assertEquals(it.next(), new Integer(j));
819	>	mustEqual(it.next(), j);
820		it.remove();
821		}
822		assertFalse(it.hasNext());
#	Line 836 | Line 828 | public class ArrayDequeTest extends JSR1
828		* Descending iterator iterates through all elements
829		*/
830		public void testDescendingIterator() {
831	<	ArrayDeque q = populatedDeque(SIZE);
831	>	ArrayDeque<Item> q = populatedDeque(SIZE);
832		int i = 0;
833	<	Iterator it = q.descendingIterator();
833	>	Iterator<? extends Item> it = q.descendingIterator();
834		while (it.hasNext()) {
835	<	assertTrue(q.contains(it.next()));
835	>	mustContain(q, it.next());
836		++i;
837		}
838	<	assertEquals(i, SIZE);
838	>	mustEqual(i, SIZE);
839		assertFalse(it.hasNext());
840		try {
841		it.next();
#	Line 855 | Line 847 | public class ArrayDequeTest extends JSR1
847		* Descending iterator ordering is reverse FIFO
848		*/
849		public void testDescendingIteratorOrdering() {
850	<	final ArrayDeque q = new ArrayDeque();
850	>	final ArrayDeque<Item> q = new ArrayDeque<Item>();
851		for (int iters = 0; iters < 100; ++iters) {
852	<	q.add(new Integer(3));
853	<	q.add(new Integer(2));
854	<	q.add(new Integer(1));
852	>	q.add(three);
853	>	q.add(two);
854	>	q.add(one);
855		int k = 0;
856	<	for (Iterator it = q.descendingIterator(); it.hasNext();) {
857	<	assertEquals(++k, it.next());
856	>	for (Iterator<? extends Item> it = q.descendingIterator(); it.hasNext();) {
857	>	mustEqual(++k, it.next());
858		}
859
860	<	assertEquals(3, k);
860	>	mustEqual(3, k);
861		q.remove();
862		q.remove();
863		q.remove();
#	Line 876 | Line 868 | public class ArrayDequeTest extends JSR1
868		* descendingIterator.remove() removes current element
869		*/
870		public void testDescendingIteratorRemove() {
871	<	final ArrayDeque q = new ArrayDeque();
871	>	final ArrayDeque<Item> q = new ArrayDeque<Item>();
872		final Random rng = new Random();
873		for (int iters = 0; iters < 100; ++iters) {
874		int max = rng.nextInt(5) + 2;
875		int split = rng.nextInt(max - 1) + 1;
876		for (int j = max; j >= 1; --j)
877	<	q.add(new Integer(j));
878	<	Iterator it = q.descendingIterator();
877	>	q.add(itemFor(j));
878	>	Iterator<? extends Item> it = q.descendingIterator();
879		for (int j = 1; j <= split; ++j)
880	<	assertEquals(it.next(), new Integer(j));
880	>	mustEqual(it.next(), itemFor(j));
881		it.remove();
882	<	assertEquals(it.next(), new Integer(split + 1));
882	>	mustEqual(it.next(), itemFor(split + 1));
883		for (int j = 1; j <= split; ++j)
884	<	q.remove(new Integer(j));
884	>	q.remove(itemFor(j));
885		it = q.descendingIterator();
886		for (int j = split + 1; j <= max; ++j) {
887	<	assertEquals(it.next(), new Integer(j));
887	>	mustEqual(it.next(), j);
888		it.remove();
889		}
890		assertFalse(it.hasNext());
#	Line 904 | Line 896 | public class ArrayDequeTest extends JSR1
896		* toString() contains toStrings of elements
897		*/
898		public void testToString() {
899	<	ArrayDeque q = populatedDeque(SIZE);
899	>	ArrayDeque<Item> q = populatedDeque(SIZE);
900		String s = q.toString();
901		for (int i = 0; i < SIZE; ++i) {
902		assertTrue(s.contains(String.valueOf(i)));
#	Line 915 | Line 907 | public class ArrayDequeTest extends JSR1
907		* A deserialized/reserialized deque has same elements in same order
908		*/
909		public void testSerialization() throws Exception {
910	<	Queue x = populatedDeque(SIZE);
911	<	Queue y = serialClone(x);
910	>	Queue<Item> x = populatedDeque(SIZE);
911	>	Queue<Item> y = serialClone(x);
912
913		assertNotSame(y, x);
914	<	assertEquals(x.size(), y.size());
915	<	assertEquals(x.toString(), y.toString());
916	<	assertEquals(Arrays.toString(x.toArray()), Arrays.toString(y.toArray()));
914	>	mustEqual(x.size(), y.size());
915	>	mustEqual(x.toString(), y.toString());
916	>	mustEqual(Arrays.toString(x.toArray()), Arrays.toString(y.toArray()));
917		assertTrue(Arrays.equals(x.toArray(), y.toArray()));
918		while (!x.isEmpty()) {
919		assertFalse(y.isEmpty());
920	<	assertEquals(x.remove(), y.remove());
920	>	mustEqual(x.remove(), y.remove());
921		}
922		assertTrue(y.isEmpty());
923		}
#	Line 934 | Line 926 | public class ArrayDequeTest extends JSR1
926		* A cloned deque has same elements in same order
927		*/
928		public void testClone() throws Exception {
929	<	ArrayDeque<Integer> x = populatedDeque(SIZE);
930	<	ArrayDeque<Integer> y = x.clone();
929	>	ArrayDeque<Item> x = populatedDeque(SIZE);
930	>	ArrayDeque<Item> y = x.clone();
931
932		assertNotSame(y, x);
933	<	assertEquals(x.size(), y.size());
934	<	assertEquals(x.toString(), y.toString());
933	>	mustEqual(x.size(), y.size());
934	>	mustEqual(x.toString(), y.toString());
935		assertTrue(Arrays.equals(x.toArray(), y.toArray()));
936		while (!x.isEmpty()) {
937		assertFalse(y.isEmpty());
938	<	assertEquals(x.remove(), y.remove());
938	>	mustEqual(x.remove(), y.remove());
939		}
940		assertTrue(y.isEmpty());
941		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines