ViewVC Help

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

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

Comparing jsr166/src/test/tck/TreeSubSetTest.java (file contents):
Revision 1.1 by dl, Thu Mar 31 15:24:29 2005 UTC vs.
Revision 1.39 by dl, Tue Jan 26 13:33:06 2021 UTC

#	Line 1 | Line 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	<	* http://creativecommons.org/licenses/publicdomain
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6
7	<	import junit.framework.*;
8	<	import java.util.*;
9	<	import java.util.concurrent.*;
10	<	import java.io.*;
7	>	import java.util.Arrays;
8	>	import java.util.Comparator;
9	>	import java.util.Iterator;
10	>	import java.util.NavigableSet;
11	>	import java.util.Set;
12	>	import java.util.SortedSet;
13	>	import java.util.TreeSet;
14	>
15	>	import junit.framework.Test;
16	>	import junit.framework.TestSuite;
17
18		public class TreeSubSetTest extends JSR166TestCase {
19		public static void main(String[] args) {
20	<	junit.textui.TestRunner.run (suite());
20	>	main(suite(), args);
21		}
22		public static Test suite() {
23	<	return new TestSuite(TreeSubSetTest.class);
23	>	return new TestSuite(TreeSubSetTest.class);
24		}
25
26	<	static class MyReverseComparator implements Comparator {
26	>	static class MyReverseComparator implements Comparator {
27	>	@SuppressWarnings("unchecked")
28		public int compare(Object x, Object y) {
29	<	int i = ((Integer)x).intValue();
23	<	int j = ((Integer)y).intValue();
24	<	if (i < j) return 1;
25	<	if (i > j) return -1;
26	<	return 0;
29	>	return ((Comparable)y).compareTo(x);
30		}
31		}
32
33		/**
34	<	* Create a set of given size containing consecutive
35	<	* Integers 0 ... n.
34	>	* Returns a new set of given size containing consecutive
35	>	* Items 0 ... n - 1.
36		*/
37	<	private NavigableSet populatedSet(int n) {
38	<	TreeSet q = new TreeSet();
37	>	private static NavigableSet<Item> populatedSet(int n) {
38	>	TreeSet<Item> q = new TreeSet<>();
39		assertTrue(q.isEmpty());
40
41	<	for(int i = n-1; i >= 0; i-=2)
42	<	assertTrue(q.add(new Integer(i)));
43	<	for(int i = (n & 1); i < n; i+=2)
44	<	assertTrue(q.add(new Integer(i)));
45	<	assertTrue(q.add(new Integer(-n)));
46	<	assertTrue(q.add(new Integer(n)));
47	<	NavigableSet s = q.navigableSubSet(new Integer(0), new Integer(n));
41	>	for (int i = n - 1; i >= 0; i -= 2)
42	>	mustAdd(q, i);
43	>	for (int i = (n & 1); i < n; i += 2)
44	>	mustAdd(q, i);
45	>	mustAdd(q, new Item(-n));
46	>	mustAdd(q, new Item(n));
47	>	NavigableSet<Item> s = q.subSet(zero, true, itemFor(n), false);
48		assertFalse(s.isEmpty());
49	<	assertEquals(n, s.size());
49	>	mustEqual(n, s.size());
50		return s;
51		}
52
53		/**
54	<	* Create set of first 5 ints
54	>	* Returns a new set of first 5 ints.
55		*/
56	<	private NavigableSet set5() {
57	<	TreeSet q = new TreeSet();
56	>	private static NavigableSet<Item> set5() {
57	>	TreeSet<Item> q = new TreeSet<Item>();
58		assertTrue(q.isEmpty());
59		q.add(one);
60		q.add(two);
#	Line 60 | Line 63 | public class TreeSubSetTest extends JSR1
63		q.add(five);
64		q.add(zero);
65		q.add(seven);
66	<	NavigableSet s = q.navigableSubSet(one, seven);
67	<	assertEquals(5, s.size());
66	>	NavigableSet<Item> s = q.subSet(one, true, seven, false);
67	>	mustEqual(5, s.size());
68	>	return s;
69	>	}
70	>
71	>	private static NavigableSet<Item> dset5() {
72	>	TreeSet<Item> q = new TreeSet<Item>();
73	>	assertTrue(q.isEmpty());
74	>	q.add(minusOne);
75	>	q.add(minusTwo);
76	>	q.add(minusThree);
77	>	q.add(minusFour);
78	>	q.add(minusFive);
79	>	NavigableSet<Item> s = q.descendingSet();
80	>	mustEqual(5, s.size());
81		return s;
82		}
83
84	<	private static NavigableSet set0() {
85	<	TreeSet set = new TreeSet();
84	>	private static NavigableSet<Item> set0() {
85	>	TreeSet<Item> set = new TreeSet<Item>();
86		assertTrue(set.isEmpty());
87	<	return set.navigableTailSet(m1);
87	>	return set.tailSet(minusOne, false);
88		}
89	<
89	>
90	>	private static NavigableSet<Item> dset0() {
91	>	TreeSet<Item> set = new TreeSet<Item>();
92	>	assertTrue(set.isEmpty());
93	>	return set;
94	>	}
95	>
96		/**
97		* A new set has unbounded capacity
98		*/
99		public void testConstructor1() {
100	<	assertEquals(0, set0().size());
100	>	mustEqual(0, set0().size());
101		}
102
81	–
103		/**
104		* isEmpty is true before add, false after
105		*/
106		public void testEmpty() {
107	<	NavigableSet q = set0();
107	>	NavigableSet<Item> q = set0();
108		assertTrue(q.isEmpty());
109	<	q.add(new Integer(1));
109	>	assertTrue(q.add(one));
110		assertFalse(q.isEmpty());
111	<	q.add(new Integer(2));
111	>	assertTrue(q.add(two));
112		q.pollFirst();
113		q.pollFirst();
114		assertTrue(q.isEmpty());
#	Line 97 | Line 118 | public class TreeSubSetTest extends JSR1
118		* size changes when elements added and removed
119		*/
120		public void testSize() {
121	<	NavigableSet q = populatedSet(SIZE);
121	>	NavigableSet<Item> q = populatedSet(SIZE);
122		for (int i = 0; i < SIZE; ++i) {
123	<	assertEquals(SIZE-i, q.size());
123	>	mustEqual(SIZE - i, q.size());
124		q.pollFirst();
125		}
126		for (int i = 0; i < SIZE; ++i) {
127	<	assertEquals(i, q.size());
128	<	q.add(new Integer(i));
127	>	mustEqual(i, q.size());
128	>	mustAdd(q, i);
129		}
130		}
131
#	Line 112 | Line 133 | public class TreeSubSetTest extends JSR1
133		* add(null) throws NPE
134		*/
135		public void testAddNull() {
136	<	try {
137	<	NavigableSet q = set0();
136	>	NavigableSet<Item> q = set0();
137	>	try {
138		q.add(null);
139		shouldThrow();
140	<	} catch (NullPointerException success) { }
140	>	} catch (NullPointerException success) {}
141		}
142
143		/**
144		* Add of comparable element succeeds
145		*/
146		public void testAdd() {
147	<	NavigableSet q = set0();
147	>	NavigableSet<Item> q = set0();
148		assertTrue(q.add(six));
149		}
150
#	Line 131 | Line 152 | public class TreeSubSetTest extends JSR1
152		* Add of duplicate element fails
153		*/
154		public void testAddDup() {
155	<	NavigableSet q = set0();
155	>	NavigableSet<Item> q = set0();
156		assertTrue(q.add(six));
157		assertFalse(q.add(six));
158		}
#	Line 140 | Line 161 | public class TreeSubSetTest extends JSR1
161		* Add of non-Comparable throws CCE
162		*/
163		public void testAddNonComparable() {
164	+	NavigableSet<Object> q = new TreeSet<Object>();
165		try {
144	–	NavigableSet q = set0();
145	–	q.add(new Object());
166		q.add(new Object());
167		q.add(new Object());
168		shouldThrow();
169	<	}
150	<	catch(ClassCastException success) {}
169	>	} catch (ClassCastException success) {}
170		}
171
153	–
172		/**
173		* addAll(null) throws NPE
174		*/
175		public void testAddAll1() {
176	+	NavigableSet<Item> q = set0();
177		try {
159	–	NavigableSet q = set0();
178		q.addAll(null);
179		shouldThrow();
180	<	}
163	<	catch (NullPointerException success) {}
180	>	} catch (NullPointerException success) {}
181		}
182	+
183		/**
184		* addAll of a collection with null elements throws NPE
185		*/
186		public void testAddAll2() {
187	+	NavigableSet<Item> q = set0();
188	+	Item[] items = new Item[2];
189		try {
190	<	NavigableSet q = set0();
171	<	Integer[] ints = new Integer[SIZE];
172	<	q.addAll(Arrays.asList(ints));
190	>	q.addAll(Arrays.asList(items));
191		shouldThrow();
192	<	}
175	<	catch (NullPointerException success) {}
192	>	} catch (NullPointerException success) {}
193		}
194	+
195		/**
196		* addAll of a collection with any null elements throws NPE after
197		* possibly adding some elements
198		*/
199		public void testAddAll3() {
200	+	NavigableSet<Item> q = set0();
201	+	Item[] items = new Item[2];
202	+	items[0] = zero;
203		try {
204	<	NavigableSet q = set0();
184	<	Integer[] ints = new Integer[SIZE];
185	<	for (int i = 0; i < SIZE-1; ++i)
186	<	ints[i] = new Integer(i+SIZE);
187	<	q.addAll(Arrays.asList(ints));
204	>	q.addAll(Arrays.asList(items));
205		shouldThrow();
206	<	}
190	<	catch (NullPointerException success) {}
206	>	} catch (NullPointerException success) {}
207		}
208
209		/**
210		* Set contains all elements of successful addAll
211		*/
212		public void testAddAll5() {
213	<	try {
214	<	Integer[] empty = new Integer[0];
215	<	Integer[] ints = new Integer[SIZE];
216	<	for (int i = 0; i < SIZE; ++i)
217	<	ints[i] = new Integer(SIZE-1- i);
218	<	NavigableSet q = set0();
219	<	assertFalse(q.addAll(Arrays.asList(empty)));
220	<	assertTrue(q.addAll(Arrays.asList(ints)));
221	<	for (int i = 0; i < SIZE; ++i)
206	<	assertEquals(new Integer(i), q.pollFirst());
207	<	}
208	<	finally {}
213	>	Item[] empty = new Item[0];
214	>	Item[] items = new Item[SIZE];
215	>	for (int i = 0; i < SIZE; ++i)
216	>	items[i] = itemFor(SIZE - 1 - i);
217	>	NavigableSet<Item> q = set0();
218	>	assertFalse(q.addAll(Arrays.asList(empty)));
219	>	assertTrue(q.addAll(Arrays.asList(items)));
220	>	for (int i = 0; i < SIZE; ++i)
221	>	mustEqual(i, q.pollFirst());
222		}
223
224		/**
225		* poll succeeds unless empty
226		*/
227		public void testPoll() {
228	<	NavigableSet q = populatedSet(SIZE);
228	>	NavigableSet<Item> q = populatedSet(SIZE);
229		for (int i = 0; i < SIZE; ++i) {
230	<	assertEquals(i, ((Integer)q.pollFirst()).intValue());
230	>	mustEqual(i, q.pollFirst());
231		}
232	<	assertNull(q.pollFirst());
232	>	assertNull(q.pollFirst());
233		}
234
235		/**
236		* remove(x) removes x and returns true if present
237		*/
238		public void testRemoveElement() {
239	<	NavigableSet q = populatedSet(SIZE);
240	<	for (int i = 1; i < SIZE; i+=2) {
241	<	assertTrue(q.remove(new Integer(i)));
239	>	NavigableSet<Item> q = populatedSet(SIZE);
240	>	for (int i = 1; i < SIZE; i += 2) {
241	>	mustContain(q, i);
242	>	mustRemove(q, i);
243	>	mustNotContain(q, i);
244	>	mustContain(q, i - 1);
245		}
246	<	for (int i = 0; i < SIZE; i+=2) {
247	<	assertTrue(q.remove(new Integer(i)));
248	<	assertFalse(q.remove(new Integer(i+1)));
246	>	for (int i = 0; i < SIZE; i += 2) {
247	>	mustContain(q, i);
248	>	mustRemove(q, i);
249	>	mustNotContain(q, i);
250	>	mustNotRemove(q, i + 1);
251	>	mustNotContain(q, i + 1);
252		}
253		assertTrue(q.isEmpty());
254		}
255	<
255	>
256		/**
257		* contains(x) reports true when elements added but not yet removed
258		*/
259		public void testContains() {
260	<	NavigableSet q = populatedSet(SIZE);
260	>	NavigableSet<Item> q = populatedSet(SIZE);
261		for (int i = 0; i < SIZE; ++i) {
262	<	assertTrue(q.contains(new Integer(i)));
263	<	q.pollFirst();
245	<	assertFalse(q.contains(new Integer(i)));
262	>	mustContain(q, i);
263	>	mustNotContain(q, q.pollFirst());
264		}
265		}
266
#	Line 250 | Line 268 | public class TreeSubSetTest extends JSR1
268		* clear removes all elements
269		*/
270		public void testClear() {
271	<	NavigableSet q = populatedSet(SIZE);
271	>	NavigableSet<Item> q = populatedSet(SIZE);
272		q.clear();
273		assertTrue(q.isEmpty());
274	<	assertEquals(0, q.size());
275	<	q.add(new Integer(1));
274	>	mustEqual(0, q.size());
275	>	assertTrue(q.add(one));
276		assertFalse(q.isEmpty());
277		q.clear();
278		assertTrue(q.isEmpty());
#	Line 264 | Line 282 | public class TreeSubSetTest extends JSR1
282		* containsAll(c) is true when c contains a subset of elements
283		*/
284		public void testContainsAll() {
285	<	NavigableSet q = populatedSet(SIZE);
286	<	NavigableSet p = set0();
285	>	NavigableSet<Item> q = populatedSet(SIZE);
286	>	NavigableSet<Item> p = set0();
287		for (int i = 0; i < SIZE; ++i) {
288		assertTrue(q.containsAll(p));
289		assertFalse(p.containsAll(q));
290	<	p.add(new Integer(i));
290	>	mustAdd(p, i);
291		}
292		assertTrue(p.containsAll(q));
293		}
#	Line 278 | Line 296 | public class TreeSubSetTest extends JSR1
296		* retainAll(c) retains only those elements of c and reports true if changed
297		*/
298		public void testRetainAll() {
299	<	NavigableSet q = populatedSet(SIZE);
300	<	NavigableSet p = populatedSet(SIZE);
299	>	NavigableSet<Item> q = populatedSet(SIZE);
300	>	NavigableSet<Item> p = populatedSet(SIZE);
301		for (int i = 0; i < SIZE; ++i) {
302		boolean changed = q.retainAll(p);
303		if (i == 0)
#	Line 288 | Line 306 | public class TreeSubSetTest extends JSR1
306		assertTrue(changed);
307
308		assertTrue(q.containsAll(p));
309	<	assertEquals(SIZE-i, q.size());
309	>	mustEqual(SIZE - i, q.size());
310		p.pollFirst();
311		}
312		}
#	Line 298 | Line 316 | public class TreeSubSetTest extends JSR1
316		*/
317		public void testRemoveAll() {
318		for (int i = 1; i < SIZE; ++i) {
319	<	NavigableSet q = populatedSet(SIZE);
320	<	NavigableSet p = populatedSet(i);
319	>	NavigableSet<Item> q = populatedSet(SIZE);
320	>	NavigableSet<Item> p = populatedSet(i);
321		assertTrue(q.removeAll(p));
322	<	assertEquals(SIZE-i, q.size());
322	>	mustEqual(SIZE - i, q.size());
323		for (int j = 0; j < i; ++j) {
324	<	Integer I = (Integer)(p.pollFirst());
307	<	assertFalse(q.contains(I));
324	>	mustNotContain(q, p.pollFirst());
325		}
326		}
327		}
328
312	–
313	–
329		/**
330		* lower returns preceding element
331		*/
332		public void testLower() {
333	<	NavigableSet q = set5();
333	>	NavigableSet<Item> q = set5();
334		Object e1 = q.lower(three);
335	<	assertEquals(two, e1);
335	>	mustEqual(two, e1);
336
337		Object e2 = q.lower(six);
338	<	assertEquals(five, e2);
338	>	mustEqual(five, e2);
339
340		Object e3 = q.lower(one);
341		assertNull(e3);
342
343		Object e4 = q.lower(zero);
344		assertNull(e4);
330	–
345		}
346
347		/**
348		* higher returns next element
349		*/
350		public void testHigher() {
351	<	NavigableSet q = set5();
351	>	NavigableSet<Item> q = set5();
352		Object e1 = q.higher(three);
353	<	assertEquals(four, e1);
353	>	mustEqual(four, e1);
354
355		Object e2 = q.higher(zero);
356	<	assertEquals(one, e2);
356	>	mustEqual(one, e2);
357
358		Object e3 = q.higher(five);
359		assertNull(e3);
360
361		Object e4 = q.higher(six);
362		assertNull(e4);
349	–
363		}
364
365		/**
366		* floor returns preceding element
367		*/
368		public void testFloor() {
369	<	NavigableSet q = set5();
369	>	NavigableSet<Item> q = set5();
370		Object e1 = q.floor(three);
371	<	assertEquals(three, e1);
371	>	mustEqual(three, e1);
372
373		Object e2 = q.floor(six);
374	<	assertEquals(five, e2);
374	>	mustEqual(five, e2);
375
376		Object e3 = q.floor(one);
377	<	assertEquals(one, e3);
377	>	mustEqual(one, e3);
378
379		Object e4 = q.floor(zero);
380		assertNull(e4);
368	–
381		}
382
383		/**
384		* ceiling returns next element
385		*/
386		public void testCeiling() {
387	<	NavigableSet q = set5();
387	>	NavigableSet<Item> q = set5();
388		Object e1 = q.ceiling(three);
389	<	assertEquals(three, e1);
389	>	mustEqual(three, e1);
390
391		Object e2 = q.ceiling(zero);
392	<	assertEquals(one, e2);
392	>	mustEqual(one, e2);
393
394		Object e3 = q.ceiling(five);
395	<	assertEquals(five, e3);
395	>	mustEqual(five, e3);
396
397		Object e4 = q.ceiling(six);
398		assertNull(e4);
399	+	}
400	+
401	+	/**
402	+	* toArray contains all elements in sorted order
403	+	*/
404	+	public void testToArray() {
405	+	NavigableSet<Item> q = populatedSet(SIZE);
406	+	Object[] a = q.toArray();
407	+	assertSame(Object[].class, a.getClass());
408	+	for (Object o : a)
409	+	assertSame(o, q.pollFirst());
410	+	assertTrue(q.isEmpty());
411	+	}
412	+
413	+	/**
414	+	* toArray(a) contains all elements in sorted order
415	+	*/
416	+	public void testToArray2() {
417	+	NavigableSet<Item> q = populatedSet(SIZE);
418	+	Item[] items = seqItems(SIZE);
419	+	Item[] array = q.toArray(items);
420	+	assertSame(items, array);
421	+	for (Item o : items)
422	+	assertSame(o, q.pollFirst());
423	+	assertTrue(q.isEmpty());
424	+	}
425	+
426	+	/**
427	+	* iterator iterates through all elements
428	+	*/
429	+	public void testIterator() {
430	+	NavigableSet<Item> q = populatedSet(SIZE);
431	+	Iterator<? extends Item> it = q.iterator();
432	+	int i;
433	+	for (i = 0; it.hasNext(); i++)
434	+	mustContain(q, it.next());
435	+	mustEqual(i, SIZE);
436	+	assertIteratorExhausted(it);
437	+	}
438	+
439	+	/**
440	+	* iterator of empty set has no elements
441	+	*/
442	+	public void testEmptyIterator() {
443	+	assertIteratorExhausted(set0().iterator());
444	+	}
445	+
446	+	/**
447	+	* iterator.remove removes current element
448	+	*/
449	+	public void testIteratorRemove() {
450	+	final NavigableSet<Item> q = set0();
451	+	q.add(two);
452	+	q.add(one);
453	+	q.add(three);
454	+
455	+	Iterator<? extends Item> it = q.iterator();
456	+	it.next();
457	+	it.remove();
458	+
459	+	it = q.iterator();
460	+	mustEqual(two, it.next());
461	+	mustEqual(three, it.next());
462	+	assertFalse(it.hasNext());
463	+	}
464	+
465	+	/**
466	+	* toString contains toStrings of elements
467	+	*/
468	+	public void testToString() {
469	+	NavigableSet<Item> q = populatedSet(SIZE);
470	+	String s = q.toString();
471	+	for (int i = 0; i < SIZE; ++i) {
472	+	assertTrue(s.contains(String.valueOf(i)));
473	+	}
474	+	}
475	+
476	+	/**
477	+	* A deserialized/reserialized set equals original
478	+	*/
479	+	public void testSerialization() throws Exception {
480	+	NavigableSet<Item> x = populatedSet(SIZE);
481	+	NavigableSet<Item> y = serialClone(x);
482	+
483	+	assertNotSame(x, y);
484	+	mustEqual(x.size(), y.size());
485	+	mustEqual(x, y);
486	+	mustEqual(y, x);
487	+	while (!x.isEmpty()) {
488	+	assertFalse(y.isEmpty());
489	+	mustEqual(x.pollFirst(), y.pollFirst());
490	+	}
491	+	assertTrue(y.isEmpty());
492	+	}
493	+
494	+	/**
495	+	* subSet returns set with keys in requested range
496	+	*/
497	+	public void testSubSetContents() {
498	+	NavigableSet<Item> set = set5();
499	+	SortedSet<Item> sm = set.subSet(two, four);
500	+	mustEqual(two, sm.first());
501	+	mustEqual(three, sm.last());
502	+	mustEqual(2, sm.size());
503	+	mustNotContain(sm, one);
504	+	mustContain(sm, two);
505	+	mustContain(sm, three);
506	+	mustNotContain(sm, four);
507	+	mustNotContain(sm, five);
508	+	Iterator<? extends Item> i = sm.iterator();
509	+	Item k = i.next();
510	+	mustEqual(two, k);
511	+	k = i.next();
512	+	mustEqual(three, k);
513	+	assertFalse(i.hasNext());
514	+	Iterator<? extends Item> j = sm.iterator();
515	+	j.next();
516	+	j.remove();
517	+	mustNotContain(set, two);
518	+	mustEqual(4, set.size());
519	+	mustEqual(1, sm.size());
520	+	mustEqual(three, sm.first());
521	+	mustEqual(three, sm.last());
522	+	mustRemove(sm, three);
523	+	assertTrue(sm.isEmpty());
524	+	mustEqual(3, set.size());
525	+	}
526	+
527	+	public void testSubSetContents2() {
528	+	NavigableSet<Item> set = set5();
529	+	SortedSet<Item> sm = set.subSet(two, three);
530	+	mustEqual(1, sm.size());
531	+	mustEqual(two, sm.first());
532	+	mustEqual(two, sm.last());
533	+	mustNotContain(sm, one);
534	+	mustContain(sm, two);
535	+	mustNotContain(sm, three);
536	+	mustNotContain(sm, four);
537	+	mustNotContain(sm, five);
538	+	Iterator<? extends Item> i = sm.iterator();
539	+	Item k = i.next();
540	+	mustEqual(two, k);
541	+	assertFalse(i.hasNext());
542	+	Iterator<? extends Item> j = sm.iterator();
543	+	j.next();
544	+	j.remove();
545	+	mustNotContain(set, two);
546	+	mustEqual(4, set.size());
547	+	mustEqual(0, sm.size());
548	+	assertTrue(sm.isEmpty());
549	+	mustNotRemove(sm, three);
550	+	mustEqual(4, set.size());
551	+	}
552	+
553	+	/**
554	+	* headSet returns set with keys in requested range
555	+	*/
556	+	public void testHeadSetContents() {
557	+	NavigableSet<Item> set = set5();
558	+	SortedSet<Item> sm = set.headSet(four);
559	+	mustContain(sm, one);
560	+	mustContain(sm, two);
561	+	mustContain(sm, three);
562	+	mustNotContain(sm, four);
563	+	mustNotContain(sm, five);
564	+	Iterator<? extends Item> i = sm.iterator();
565	+	Item k = i.next();
566	+	mustEqual(one, k);
567	+	k = i.next();
568	+	mustEqual(two, k);
569	+	k = i.next();
570	+	mustEqual(three, k);
571	+	assertFalse(i.hasNext());
572	+	sm.clear();
573	+	assertTrue(sm.isEmpty());
574	+	mustEqual(2, set.size());
575	+	mustEqual(four, set.first());
576	+	}
577	+
578	+	/**
579	+	* tailSet returns set with keys in requested range
580	+	*/
581	+	public void testTailSetContents() {
582	+	NavigableSet<Item> set = set5();
583	+	SortedSet<Item> sm = set.tailSet(two);
584	+	mustNotContain(sm, one);
585	+	mustContain(sm, two);
586	+	mustContain(sm, three);
587	+	mustContain(sm, four);
588	+	mustContain(sm, five);
589	+	Iterator<? extends Item> i = sm.iterator();
590	+	Item k = i.next();
591	+	mustEqual(two, k);
592	+	k = i.next();
593	+	mustEqual(three, k);
594	+	k = i.next();
595	+	mustEqual(four, k);
596	+	k = i.next();
597	+	mustEqual(five, k);
598	+	assertFalse(i.hasNext());
599	+
600	+	SortedSet<Item> ssm = sm.tailSet(four);
601	+	mustEqual(four, ssm.first());
602	+	mustEqual(five, ssm.last());
603	+	mustRemove(ssm, four);
604	+	mustEqual(1, ssm.size());
605	+	mustEqual(3, sm.size());
606	+	mustEqual(4, set.size());
607	+	}
608	+
609	+	/**
610	+	* size changes when elements added and removed
611	+	*/
612	+	public void testDescendingSize() {
613	+	NavigableSet<Item> q = populatedSet(SIZE);
614	+	for (int i = 0; i < SIZE; ++i) {
615	+	mustEqual(SIZE - i, q.size());
616	+	q.pollFirst();
617	+	}
618	+	for (int i = 0; i < SIZE; ++i) {
619	+	mustEqual(i, q.size());
620	+	mustAdd(q, i);
621	+	}
622	+	}
623	+
624	+	/**
625	+	* Add of comparable element succeeds
626	+	*/
627	+	public void testDescendingAdd() {
628	+	NavigableSet<Item> q = dset0();
629	+	assertTrue(q.add(minusSix));
630	+	}
631	+
632	+	/**
633	+	* Add of duplicate element fails
634	+	*/
635	+	public void testDescendingAddDup() {
636	+	NavigableSet<Item> q = dset0();
637	+	assertTrue(q.add(minusSix));
638	+	assertFalse(q.add(minusSix));
639	+	}
640	+
641	+	/**
642	+	* Add of non-Comparable throws CCE
643	+	*/
644	+	public void testDescendingAddNonComparable() {
645	+	NavigableSet<Object> q = new TreeSet<Object>();
646	+	try {
647	+	q.add(new Object());
648	+	q.add(new Object());
649	+	shouldThrow();
650	+	} catch (ClassCastException success) {}
651	+	}
652	+
653	+	/**
654	+	* addAll(null) throws NPE
655	+	*/
656	+	public void testDescendingAddAll1() {
657	+	NavigableSet<Item> q = dset0();
658	+	try {
659	+	q.addAll(null);
660	+	shouldThrow();
661	+	} catch (NullPointerException success) {}
662	+	}
663	+
664	+	/**
665	+	* addAll of a collection with null elements throws NPE
666	+	*/
667	+	public void testDescendingAddAll2() {
668	+	NavigableSet<Item> q = dset0();
669	+	Item[] items = new Item[2]; items[0] = zero;
670	+	try {
671	+	q.addAll(Arrays.asList(items));
672	+	shouldThrow();
673	+	} catch (NullPointerException success) {}
674	+	}
675	+
676	+	/**
677	+	* addAll of a collection with any null elements throws NPE after
678	+	* possibly adding some elements
679	+	*/
680	+	public void testDescendingAddAll3() {
681	+	NavigableSet<Item> q = dset0();
682	+	Item[] items = new Item[2];
683	+	items[0] = ninetynine;
684	+	try {
685	+	q.addAll(Arrays.asList(items));
686	+	shouldThrow();
687	+	} catch (NullPointerException success) {}
688	+	}
689	+
690	+	/**
691	+	* Set contains all elements of successful addAll
692	+	*/
693	+	public void testDescendingAddAll5() {
694	+	Item[] empty = new Item[0];
695	+	Item[] items = new Item[SIZE];
696	+	for (int i = 0; i < SIZE; ++i)
697	+	items[i] = itemFor(SIZE - 1 - i);
698	+	NavigableSet<Item> q = dset0();
699	+	assertFalse(q.addAll(Arrays.asList(empty)));
700	+	assertTrue(q.addAll(Arrays.asList(items)));
701	+	for (int i = 0; i < SIZE; ++i)
702	+	mustEqual(i, q.pollFirst());
703	+	}
704	+
705	+	/**
706	+	* poll succeeds unless empty
707	+	*/
708	+	public void testDescendingPoll() {
709	+	NavigableSet<Item> q = populatedSet(SIZE);
710	+	for (int i = 0; i < SIZE; ++i) {
711	+	mustEqual(i, q.pollFirst());
712	+	}
713	+	assertNull(q.pollFirst());
714	+	}
715	+
716	+	/**
717	+	* remove(x) removes x and returns true if present
718	+	*/
719	+	public void testDescendingRemoveElement() {
720	+	NavigableSet<Item> q = populatedSet(SIZE);
721	+	for (int i = 1; i < SIZE; i += 2) {
722	+	mustRemove(q, i);
723	+	}
724	+	for (int i = 0; i < SIZE; i += 2) {
725	+	mustRemove(q, i);
726	+	mustNotRemove(q, i + 1);
727	+	}
728	+	assertTrue(q.isEmpty());
729	+	}
730	+
731	+	/**
732	+	* contains(x) reports true when elements added but not yet removed
733	+	*/
734	+	public void testDescendingContains() {
735	+	NavigableSet<Item> q = populatedSet(SIZE);
736	+	for (int i = 0; i < SIZE; ++i) {
737	+	mustContain(q, i);
738	+	q.pollFirst();
739	+	mustNotContain(q, i);
740	+	}
741	+	}
742	+
743	+	/**
744	+	* clear removes all elements
745	+	*/
746	+	public void testDescendingClear() {
747	+	NavigableSet<Item> q = populatedSet(SIZE);
748	+	q.clear();
749	+	assertTrue(q.isEmpty());
750	+	mustEqual(0, q.size());
751	+	mustAdd(q, one);
752	+	assertFalse(q.isEmpty());
753	+	q.clear();
754	+	assertTrue(q.isEmpty());
755	+	}
756	+
757	+	/**
758	+	* containsAll(c) is true when c contains a subset of elements
759	+	*/
760	+	public void testDescendingContainsAll() {
761	+	NavigableSet<Item> q = populatedSet(SIZE);
762	+	NavigableSet<Item> p = dset0();
763	+	for (int i = 0; i < SIZE; ++i) {
764	+	assertTrue(q.containsAll(p));
765	+	assertFalse(p.containsAll(q));
766	+	mustAdd(p, i);
767	+	}
768	+	assertTrue(p.containsAll(q));
769	+	}
770	+
771	+	/**
772	+	* retainAll(c) retains only those elements of c and reports true if changed
773	+	*/
774	+	public void testDescendingRetainAll() {
775	+	NavigableSet<Item> q = populatedSet(SIZE);
776	+	NavigableSet<Item> p = populatedSet(SIZE);
777	+	for (int i = 0; i < SIZE; ++i) {
778	+	boolean changed = q.retainAll(p);
779	+	if (i == 0)
780	+	assertFalse(changed);
781	+	else
782	+	assertTrue(changed);
783	+
784	+	assertTrue(q.containsAll(p));
785	+	mustEqual(SIZE - i, q.size());
786	+	p.pollFirst();
787	+	}
788	+	}
789	+
790	+	/**
791	+	* removeAll(c) removes only those elements of c and reports true if changed
792	+	*/
793	+	public void testDescendingRemoveAll() {
794	+	for (int i = 1; i < SIZE; ++i) {
795	+	NavigableSet<Item> q = populatedSet(SIZE);
796	+	NavigableSet<Item> p = populatedSet(i);
797	+	assertTrue(q.removeAll(p));
798	+	mustEqual(SIZE - i, q.size());
799	+	for (int j = 0; j < i; ++j) {
800	+	mustNotContain(q, p.pollFirst());
801	+	}
802	+	}
803	+	}
804	+
805	+	/**
806	+	* lower returns preceding element
807	+	*/
808	+	public void testDescendingLower() {
809	+	NavigableSet<Item> q = dset5();
810	+	Object e1 = q.lower(minusThree);
811	+	mustEqual(minusTwo, e1);
812	+
813	+	Object e2 = q.lower(minusSix);
814	+	mustEqual(minusFive, e2);
815	+
816	+	Object e3 = q.lower(minusOne);
817	+	assertNull(e3);
818	+
819	+	Object e4 = q.lower(zero);
820	+	assertNull(e4);
821	+	}
822	+
823	+	/**
824	+	* higher returns next element
825	+	*/
826	+	public void testDescendingHigher() {
827	+	NavigableSet<Item> q = dset5();
828	+	Object e1 = q.higher(minusThree);
829	+	mustEqual(minusFour, e1);
830	+
831	+	Object e2 = q.higher(zero);
832	+	mustEqual(minusOne, e2);
833	+
834	+	Object e3 = q.higher(minusFive);
835	+	assertNull(e3);
836	+
837	+	Object e4 = q.higher(minusSix);
838	+	assertNull(e4);
839	+	}
840	+
841	+	/**
842	+	* floor returns preceding element
843	+	*/
844	+	public void testDescendingFloor() {
845	+	NavigableSet<Item> q = dset5();
846	+	Object e1 = q.floor(minusThree);
847	+	mustEqual(minusThree, e1);
848	+
849	+	Object e2 = q.floor(minusSix);
850	+	mustEqual(minusFive, e2);
851	+
852	+	Object e3 = q.floor(minusOne);
853	+	mustEqual(minusOne, e3);
854	+
855	+	Object e4 = q.floor(zero);
856	+	assertNull(e4);
857	+	}
858
859	+	/**
860	+	* ceiling returns next element
861	+	*/
862	+	public void testDescendingCeiling() {
863	+	NavigableSet<Item> q = dset5();
864	+	Object e1 = q.ceiling(minusThree);
865	+	mustEqual(minusThree, e1);
866	+
867	+	Object e2 = q.ceiling(zero);
868	+	mustEqual(minusOne, e2);
869	+
870	+	Object e3 = q.ceiling(minusFive);
871	+	mustEqual(minusFive, e3);
872	+
873	+	Object e4 = q.ceiling(minusSix);
874	+	assertNull(e4);
875		}
876
877		/**
878		* toArray contains all elements
879		*/
880	<	public void testToArray() {
881	<	NavigableSet q = populatedSet(SIZE);
882	<	Object[] o = q.toArray();
880	>	public void testDescendingToArray() {
881	>	NavigableSet<Item> q = populatedSet(SIZE);
882	>	Object[] o = q.toArray();
883		Arrays.sort(o);
884	<	for(int i = 0; i < o.length; i++)
885	<	assertEquals(o[i], q.pollFirst());
884	>	for (int i = 0; i < o.length; i++)
885	>	mustEqual((Item)o[i], q.pollFirst());
886		}
887
888		/**
889		* toArray(a) contains all elements
890		*/
891	<	public void testToArray2() {
892	<	NavigableSet q = populatedSet(SIZE);
893	<	Integer[] ints = new Integer[SIZE];
894	<	ints = (Integer[])q.toArray(ints);
895	<	Arrays.sort(ints);
896	<	for(int i = 0; i < ints.length; i++)
897	<	assertEquals(ints[i], q.pollFirst());
891	>	public void testDescendingToArray2() {
892	>	NavigableSet<Item> q = populatedSet(SIZE);
893	>	Item[] items = new Item[SIZE];
894	>	assertSame(items, q.toArray(items));
895	>	Arrays.sort(items);
896	>	for (int i = 0; i < items.length; i++)
897	>	mustEqual(items[i], q.pollFirst());
898		}
899	<
899	>
900		/**
901		* iterator iterates through all elements
902		*/
903	<	public void testIterator() {
904	<	NavigableSet q = populatedSet(SIZE);
903	>	public void testDescendingIterator() {
904	>	NavigableSet<Item> q = populatedSet(SIZE);
905		int i = 0;
906	<	Iterator it = q.iterator();
907	<	while(it.hasNext()) {
908	<	assertTrue(q.contains(it.next()));
906	>	Iterator<? extends Item> it = q.iterator();
907	>	while (it.hasNext()) {
908	>	mustContain(q, it.next());
909		++i;
910		}
911	<	assertEquals(i, SIZE);
911	>	mustEqual(i, SIZE);
912		}
913
914		/**
915		* iterator of empty set has no elements
916		*/
917	<	public void testEmptyIterator() {
918	<	NavigableSet q = set0();
917	>	public void testDescendingEmptyIterator() {
918	>	NavigableSet<Item> q = dset0();
919		int i = 0;
920	<	Iterator it = q.iterator();
921	<	while(it.hasNext()) {
922	<	assertTrue(q.contains(it.next()));
920	>	Iterator<? extends Item> it = q.iterator();
921	>	while (it.hasNext()) {
922	>	mustContain(q, it.next());
923		++i;
924		}
925	<	assertEquals(i, 0);
925	>	mustEqual(0, i);
926		}
927
928		/**
929		* iterator.remove removes current element
930		*/
931	<	public void testIteratorRemove () {
932	<	final NavigableSet q = set0();
933	<	q.add(new Integer(2));
934	<	q.add(new Integer(1));
935	<	q.add(new Integer(3));
931	>	public void testDescendingIteratorRemove() {
932	>	final NavigableSet<Item> q = dset0();
933	>	q.add(two);
934	>	q.add(one);
935	>	q.add(three);
936
937	<	Iterator it = q.iterator();
937	>	Iterator<? extends Item> it = q.iterator();
938		it.next();
939		it.remove();
940
941		it = q.iterator();
942	<	assertEquals(it.next(), new Integer(2));
943	<	assertEquals(it.next(), new Integer(3));
942	>	mustEqual(two, it.next());
943	>	mustEqual(three, it.next());
944		assertFalse(it.hasNext());
945		}
946
460	–
947		/**
948		* toString contains toStrings of elements
949		*/
950	<	public void testToString() {
951	<	NavigableSet q = populatedSet(SIZE);
950	>	public void testDescendingToString() {
951	>	NavigableSet<Item> q = populatedSet(SIZE);
952		String s = q.toString();
953		for (int i = 0; i < SIZE; ++i) {
954	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
954	>	assertTrue(s.contains(String.valueOf(i)));
955		}
956	<	}
956	>	}
957
958		/**
959	<	* A deserialized serialized set has same elements
959	>	* A deserialized/reserialized set equals original
960		*/
961	<	public void testSerialization() {
962	<	NavigableSet q = populatedSet(SIZE);
963	<	try {
964	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
965	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
966	<	out.writeObject(q);
967	<	out.close();
968	<
969	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
970	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
971	<	NavigableSet r = (NavigableSet)in.readObject();
972	<	assertEquals(q.size(), r.size());
487	<	while (!q.isEmpty())
488	<	assertEquals(q.pollFirst(), r.pollFirst());
489	<	} catch(Exception e){
490	<	e.printStackTrace();
491	<	unexpectedException();
961	>	public void testDescendingSerialization() throws Exception {
962	>	NavigableSet<Item> x = dset5();
963	>	NavigableSet<Item> y = serialClone(x);
964	>
965	>	assertNotSame(x, y);
966	>	mustEqual(x.size(), y.size());
967	>	mustEqual(x.toString(), y.toString());
968	>	mustEqual(x, y);
969	>	mustEqual(y, x);
970	>	while (!x.isEmpty()) {
971	>	assertFalse(y.isEmpty());
972	>	mustEqual(x.pollFirst(), y.pollFirst());
973		}
974	+	assertTrue(y.isEmpty());
975		}
976
977		/**
978		* subSet returns set with keys in requested range
979		*/
980	<	public void testSubSetContents() {
981	<	NavigableSet set = set5();
982	<	SortedSet sm = set.subSet(two, four);
983	<	assertEquals(two, sm.first());
984	<	assertEquals(three, sm.last());
985	<	assertEquals(2, sm.size());
986	<	assertFalse(sm.contains(one));
987	<	assertTrue(sm.contains(two));
988	<	assertTrue(sm.contains(three));
989	<	assertFalse(sm.contains(four));
990	<	assertFalse(sm.contains(five));
991	<	Iterator i = sm.iterator();
992	<	Object k;
993	<	k = (Integer)(i.next());
994	<	assertEquals(two, k);
995	<	k = (Integer)(i.next());
514	<	assertEquals(three, k);
980	>	public void testDescendingSubSetContents() {
981	>	NavigableSet<Item> set = dset5();
982	>	SortedSet<Item> sm = set.subSet(minusTwo, minusFour);
983	>	mustEqual(minusTwo, sm.first());
984	>	mustEqual(minusThree, sm.last());
985	>	mustEqual(2, sm.size());
986	>	mustNotContain(sm, minusOne);
987	>	mustContain(sm, minusTwo);
988	>	mustContain(sm, minusThree);
989	>	mustNotContain(sm, minusFour);
990	>	mustNotContain(sm, minusFive);
991	>	Iterator<? extends Item> i = sm.iterator();
992	>	Item k = i.next();
993	>	mustEqual(minusTwo, k);
994	>	k = i.next();
995	>	mustEqual(minusThree, k);
996		assertFalse(i.hasNext());
997	<	Iterator j = sm.iterator();
997	>	Iterator<? extends Item> j = sm.iterator();
998		j.next();
999		j.remove();
1000	<	assertFalse(set.contains(two));
1001	<	assertEquals(4, set.size());
1002	<	assertEquals(1, sm.size());
1003	<	assertEquals(three, sm.first());
1004	<	assertEquals(three, sm.last());
1005	<	assertTrue(sm.remove(three));
1000	>	mustNotContain(set, minusTwo);
1001	>	mustEqual(4, set.size());
1002	>	mustEqual(1, sm.size());
1003	>	mustEqual(minusThree, sm.first());
1004	>	mustEqual(minusThree, sm.last());
1005	>	mustRemove(sm, minusThree);
1006		assertTrue(sm.isEmpty());
1007	<	assertEquals(3, set.size());
1007	>	mustEqual(3, set.size());
1008		}
1009
1010	<	public void testSubSetContents2() {
1011	<	NavigableSet set = set5();
1012	<	SortedSet sm = set.subSet(two, three);
1013	<	assertEquals(1, sm.size());
1014	<	assertEquals(two, sm.first());
1015	<	assertEquals(two, sm.last());
1016	<	assertFalse(sm.contains(one));
1017	<	assertTrue(sm.contains(two));
1018	<	assertFalse(sm.contains(three));
1019	<	assertFalse(sm.contains(four));
1020	<	assertFalse(sm.contains(five));
1021	<	Iterator i = sm.iterator();
1022	<	Object k;
1023	<	k = (Integer)(i.next());
543	<	assertEquals(two, k);
1010	>	public void testDescendingSubSetContents2() {
1011	>	NavigableSet<Item> set = dset5();
1012	>	SortedSet<Item> sm = set.subSet(minusTwo, minusThree);
1013	>	mustEqual(1, sm.size());
1014	>	mustEqual(minusTwo, sm.first());
1015	>	mustEqual(minusTwo, sm.last());
1016	>	mustNotContain(sm, minusOne);
1017	>	mustContain(sm, minusTwo);
1018	>	mustNotContain(sm, minusThree);
1019	>	mustNotContain(sm, minusFour);
1020	>	mustNotContain(sm, minusFive);
1021	>	Iterator<? extends Item> i = sm.iterator();
1022	>	Item k = i.next();
1023	>	mustEqual(minusTwo, k);
1024		assertFalse(i.hasNext());
1025	<	Iterator j = sm.iterator();
1025	>	Iterator<? extends Item> j = sm.iterator();
1026		j.next();
1027		j.remove();
1028	<	assertFalse(set.contains(two));
1029	<	assertEquals(4, set.size());
1030	<	assertEquals(0, sm.size());
1028	>	mustNotContain(set, minusTwo);
1029	>	mustEqual(4, set.size());
1030	>	mustEqual(0, sm.size());
1031		assertTrue(sm.isEmpty());
1032	<	assertFalse(sm.remove(three));
1033	<	assertEquals(4, set.size());
1032	>	mustNotRemove(sm, minusThree);
1033	>	mustEqual(4, set.size());
1034		}
1035
1036		/**
1037		* headSet returns set with keys in requested range
1038		*/
1039	<	public void testHeadSetContents() {
1040	<	NavigableSet set = set5();
1041	<	SortedSet sm = set.headSet(four);
1042	<	assertTrue(sm.contains(one));
1043	<	assertTrue(sm.contains(two));
1044	<	assertTrue(sm.contains(three));
1045	<	assertFalse(sm.contains(four));
1046	<	assertFalse(sm.contains(five));
1047	<	Iterator i = sm.iterator();
1048	<	Object k;
1049	<	k = (Integer)(i.next());
1050	<	assertEquals(one, k);
1051	<	k = (Integer)(i.next());
1052	<	assertEquals(two, k);
1053	<	k = (Integer)(i.next());
574	<	assertEquals(three, k);
1039	>	public void testDescendingHeadSetContents() {
1040	>	NavigableSet<Item> set = dset5();
1041	>	SortedSet<Item> sm = set.headSet(minusFour);
1042	>	mustContain(sm, minusOne);
1043	>	mustContain(sm, minusTwo);
1044	>	mustContain(sm, minusThree);
1045	>	mustNotContain(sm, minusFour);
1046	>	mustNotContain(sm, minusFive);
1047	>	Iterator<? extends Item> i = sm.iterator();
1048	>	Item k = i.next();
1049	>	mustEqual(minusOne, k);
1050	>	k = i.next();
1051	>	mustEqual(minusTwo, k);
1052	>	k = i.next();
1053	>	mustEqual(minusThree, k);
1054		assertFalse(i.hasNext());
1055		sm.clear();
1056		assertTrue(sm.isEmpty());
1057	<	assertEquals(2, set.size());
1058	<	assertEquals(four, set.first());
1057	>	mustEqual(2, set.size());
1058	>	mustEqual(minusFour, set.first());
1059		}
1060
1061		/**
1062		* tailSet returns set with keys in requested range
1063		*/
1064	<	public void testTailSetContents() {
1065	<	NavigableSet set = set5();
1066	<	SortedSet sm = set.tailSet(two);
1067	<	assertFalse(sm.contains(one));
1068	<	assertTrue(sm.contains(two));
1069	<	assertTrue(sm.contains(three));
1070	<	assertTrue(sm.contains(four));
1071	<	assertTrue(sm.contains(five));
1072	<	Iterator i = sm.iterator();
1073	<	Object k;
1074	<	k = (Integer)(i.next());
1075	<	assertEquals(two, k);
1076	<	k = (Integer)(i.next());
1077	<	assertEquals(three, k);
1078	<	k = (Integer)(i.next());
1079	<	assertEquals(four, k);
1080	<	k = (Integer)(i.next());
602	<	assertEquals(five, k);
1064	>	public void testDescendingTailSetContents() {
1065	>	NavigableSet<Item> set = dset5();
1066	>	SortedSet<Item> sm = set.tailSet(minusTwo);
1067	>	mustNotContain(sm, minusOne);
1068	>	mustContain(sm, minusTwo);
1069	>	mustContain(sm, minusThree);
1070	>	mustContain(sm, minusFour);
1071	>	mustContain(sm, minusFive);
1072	>	Iterator<? extends Item> i = sm.iterator();
1073	>	Item k = i.next();
1074	>	mustEqual(minusTwo, k);
1075	>	k = i.next();
1076	>	mustEqual(minusThree, k);
1077	>	k = i.next();
1078	>	mustEqual(minusFour, k);
1079	>	k = i.next();
1080	>	mustEqual(minusFive, k);
1081		assertFalse(i.hasNext());
1082
1083	<	SortedSet ssm = sm.tailSet(four);
1084	<	assertEquals(four, ssm.first());
1085	<	assertEquals(five, ssm.last());
1086	<	assertTrue(ssm.remove(four));
1087	<	assertEquals(1, ssm.size());
1088	<	assertEquals(3, sm.size());
1089	<	assertEquals(4, set.size());
1083	>	SortedSet<Item> ssm = sm.tailSet(minusFour);
1084	>	mustEqual(minusFour, ssm.first());
1085	>	mustEqual(minusFive, ssm.last());
1086	>	mustRemove(ssm, minusFour);
1087	>	mustEqual(1, ssm.size());
1088	>	mustEqual(3, sm.size());
1089	>	mustEqual(4, set.size());
1090	>	}
1091	>
1092	>	/**
1093	>	* addAll is idempotent
1094	>	*/
1095	>	public void testAddAll_idempotent() throws Exception {
1096	>	Set<Item> x = populatedSet(SIZE);
1097	>	Set<Item> y = new TreeSet<Item>(x);
1098	>	y.addAll(x);
1099	>	mustEqual(x, y);
1100	>	mustEqual(y, x);
1101		}
1102
1103		}

Diff Legend

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