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.38 by jsr166, Mon May 28 21:19:50 2018 UTC vs.
Revision 1.39 by dl, Tue Jan 26 13:33:06 2021 UTC

#	Line 24 | Line 24 | public class TreeSubSetTest extends JSR1
24		}
25
26		static class MyReverseComparator implements Comparator {
27	+	@SuppressWarnings("unchecked")
28		public int compare(Object x, Object y) {
29		return ((Comparable)y).compareTo(x);
30		}
#	Line 31 | Line 32 | public class TreeSubSetTest extends JSR1
32
33		/**
34		* Returns a new set of given size containing consecutive
35	<	* Integers 0 ... n - 1.
35	>	* Items 0 ... n - 1.
36		*/
37	<	private static NavigableSet<Integer> populatedSet(int n) {
38	<	TreeSet<Integer> 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)));
42	>	mustAdd(q, 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.subSet(new Integer(0), true, new Integer(n), false);
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		* Returns a new set of first 5 ints.
55		*/
56	<	private static 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 62 | Line 63 | public class TreeSubSetTest extends JSR1
63		q.add(five);
64		q.add(zero);
65		q.add(seven);
66	<	NavigableSet s = q.subSet(one, true, seven, false);
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 dset5() {
72	<	TreeSet q = new TreeSet();
71	>	private static NavigableSet<Item> dset5() {
72	>	TreeSet<Item> q = new TreeSet<Item>();
73		assertTrue(q.isEmpty());
74	<	q.add(m1);
75	<	q.add(m2);
76	<	q.add(m3);
77	<	q.add(m4);
78	<	q.add(m5);
79	<	NavigableSet s = q.descendingSet();
80	<	assertEquals(5, s.size());
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.tailSet(m1, false);
87	>	return set.tailSet(minusOne, false);
88		}
89
90	<	private static NavigableSet dset0() {
91	<	TreeSet set = new TreeSet();
90	>	private static NavigableSet<Item> dset0() {
91	>	TreeSet<Item> set = new TreeSet<Item>();
92		assertTrue(set.isEmpty());
93		return set;
94		}
#	Line 96 | Line 97 | public class TreeSubSetTest extends JSR1
97		* A new set has unbounded capacity
98		*/
99		public void testConstructor1() {
100	<	assertEquals(0, set0().size());
100	>	mustEqual(0, set0().size());
101		}
102
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	<	assertTrue(q.add(new Integer(1)));
109	>	assertTrue(q.add(one));
110		assertFalse(q.isEmpty());
111	<	assertTrue(q.add(new Integer(2)));
111	>	assertTrue(q.add(two));
112		q.pollFirst();
113		q.pollFirst();
114		assertTrue(q.isEmpty());
#	Line 117 | 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 132 | Line 133 | public class TreeSubSetTest extends JSR1
133		* add(null) throws NPE
134		*/
135		public void testAddNull() {
136	<	NavigableSet q = set0();
136	>	NavigableSet<Item> q = set0();
137		try {
138		q.add(null);
139		shouldThrow();
#	Line 143 | Line 144 | public class TreeSubSetTest extends JSR1
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 151 | 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 160 | Line 161 | public class TreeSubSetTest extends JSR1
161		* Add of non-Comparable throws CCE
162		*/
163		public void testAddNonComparable() {
164	<	NavigableSet q = set0();
164	>	NavigableSet<Object> q = new TreeSet<Object>();
165		try {
166		q.add(new Object());
167		q.add(new Object());
#	Line 172 | Line 173 | public class TreeSubSetTest extends JSR1
173		* addAll(null) throws NPE
174		*/
175		public void testAddAll1() {
176	<	NavigableSet q = set0();
176	>	NavigableSet<Item> q = set0();
177		try {
178		q.addAll(null);
179		shouldThrow();
#	Line 183 | Line 184 | public class TreeSubSetTest extends JSR1
184		* addAll of a collection with null elements throws NPE
185		*/
186		public void testAddAll2() {
187	<	NavigableSet q = set0();
188	<	Integer[] ints = new Integer[SIZE];
187	>	NavigableSet<Item> q = set0();
188	>	Item[] items = new Item[2];
189		try {
190	<	q.addAll(Arrays.asList(ints));
190	>	q.addAll(Arrays.asList(items));
191		shouldThrow();
192		} catch (NullPointerException success) {}
193		}
#	Line 196 | Line 197 | public class TreeSubSetTest extends JSR1
197		* possibly adding some elements
198		*/
199		public void testAddAll3() {
200	<	NavigableSet q = set0();
201	<	Integer[] ints = new Integer[SIZE];
202	<	for (int i = 0; i < SIZE - 1; ++i)
202	<	ints[i] = new Integer(i + SIZE);
200	>	NavigableSet<Item> q = set0();
201	>	Item[] items = new Item[2];
202	>	items[0] = zero;
203		try {
204	<	q.addAll(Arrays.asList(ints));
204	>	q.addAll(Arrays.asList(items));
205		shouldThrow();
206		} catch (NullPointerException success) {}
207		}
#	Line 210 | Line 210 | public class TreeSubSetTest extends JSR1
210		* Set contains all elements of successful addAll
211		*/
212		public void testAddAll5() {
213	<	Integer[] empty = new Integer[0];
214	<	Integer[] ints = new Integer[SIZE];
213	>	Item[] empty = new Item[0];
214	>	Item[] items = new Item[SIZE];
215		for (int i = 0; i < SIZE; ++i)
216	<	ints[i] = new Integer(SIZE - 1 - i);
217	<	NavigableSet q = set0();
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(ints)));
219	>	assertTrue(q.addAll(Arrays.asList(items)));
220		for (int i = 0; i < SIZE; ++i)
221	<	assertEquals(new Integer(i), q.pollFirst());
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, q.pollFirst());
230	>	mustEqual(i, q.pollFirst());
231		}
232		assertNull(q.pollFirst());
233		}
#	Line 236 | Line 236 | public class TreeSubSetTest extends JSR1
236		* remove(x) removes x and returns true if present
237		*/
238		public void testRemoveElement() {
239	<	NavigableSet q = populatedSet(SIZE);
239	>	NavigableSet<Item> q = populatedSet(SIZE);
240		for (int i = 1; i < SIZE; i += 2) {
241	<	assertTrue(q.contains(i));
242	<	assertTrue(q.remove(i));
243	<	assertFalse(q.contains(i));
244	<	assertTrue(q.contains(i - 1));
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.contains(i));
248	<	assertTrue(q.remove(i));
249	<	assertFalse(q.contains(i));
250	<	assertFalse(q.remove(i + 1));
251	<	assertFalse(q.contains(i + 1));
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		}
#	Line 257 | Line 257 | public class TreeSubSetTest extends JSR1
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();
264	<	assertFalse(q.contains(new Integer(i)));
262	>	mustContain(q, i);
263	>	mustNotContain(q, q.pollFirst());
264		}
265		}
266
#	Line 269 | 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	<	assertTrue(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 283 | 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 297 | 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 307 | 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 317 | 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 x = (Integer)(p.pollFirst());
326	<	assertFalse(q.contains(x));
324	>	mustNotContain(q, p.pollFirst());
325		}
326		}
327		}
#	Line 332 | Line 330 | public class TreeSubSetTest extends JSR1
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);
#	Line 350 | Line 348 | public class TreeSubSetTest extends JSR1
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);
#	Line 368 | Line 366 | public class TreeSubSetTest extends JSR1
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);
#	Line 386 | Line 384 | public class TreeSubSetTest extends JSR1
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);
#	Line 404 | Line 402 | public class TreeSubSetTest extends JSR1
402		* toArray contains all elements in sorted order
403		*/
404		public void testToArray() {
405	<	NavigableSet q = populatedSet(SIZE);
405	>	NavigableSet<Item> q = populatedSet(SIZE);
406		Object[] a = q.toArray();
407		assertSame(Object[].class, a.getClass());
408		for (Object o : a)
#	Line 416 | Line 414 | public class TreeSubSetTest extends JSR1
414		* toArray(a) contains all elements in sorted order
415		*/
416		public void testToArray2() {
417	<	NavigableSet<Integer> q = populatedSet(SIZE);
418	<	Integer[] ints = new Integer[SIZE];
419	<	Integer[] array = q.toArray(ints);
420	<	assertSame(ints, array);
421	<	for (Integer o : ints)
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		}
#	Line 429 | Line 427 | public class TreeSubSetTest extends JSR1
427		* iterator iterates through all elements
428		*/
429		public void testIterator() {
430	<	NavigableSet q = populatedSet(SIZE);
431	<	Iterator it = q.iterator();
430	>	NavigableSet<Item> q = populatedSet(SIZE);
431	>	Iterator<? extends Item> it = q.iterator();
432		int i;
433		for (i = 0; it.hasNext(); i++)
434	<	assertTrue(q.contains(it.next()));
435	<	assertEquals(i, SIZE);
434	>	mustContain(q, it.next());
435	>	mustEqual(i, SIZE);
436		assertIteratorExhausted(it);
437		}
438
#	Line 449 | Line 447 | public class TreeSubSetTest extends JSR1
447		* iterator.remove removes current element
448		*/
449		public void testIteratorRemove() {
450	<	final NavigableSet q = set0();
451	<	q.add(new Integer(2));
452	<	q.add(new Integer(1));
453	<	q.add(new Integer(3));
450	>	final NavigableSet<Item> q = set0();
451	>	q.add(two);
452	>	q.add(one);
453	>	q.add(three);
454
455	<	Iterator it = q.iterator();
455	>	Iterator<? extends Item> it = q.iterator();
456		it.next();
457		it.remove();
458
459		it = q.iterator();
460	<	assertEquals(2, it.next());
461	<	assertEquals(3, it.next());
460	>	mustEqual(two, it.next());
461	>	mustEqual(three, it.next());
462		assertFalse(it.hasNext());
463		}
464
#	Line 468 | Line 466 | public class TreeSubSetTest extends JSR1
466		* toString contains toStrings of elements
467		*/
468		public void testToString() {
469	<	NavigableSet q = populatedSet(SIZE);
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)));
#	Line 479 | Line 477 | public class TreeSubSetTest extends JSR1
477		* A deserialized/reserialized set equals original
478		*/
479		public void testSerialization() throws Exception {
480	<	NavigableSet x = populatedSet(SIZE);
481	<	NavigableSet y = serialClone(x);
480	>	NavigableSet<Item> x = populatedSet(SIZE);
481	>	NavigableSet<Item> y = serialClone(x);
482
483		assertNotSame(x, y);
484	<	assertEquals(x.size(), y.size());
485	<	assertEquals(x, y);
486	<	assertEquals(y, x);
484	>	mustEqual(x.size(), y.size());
485	>	mustEqual(x, y);
486	>	mustEqual(y, x);
487		while (!x.isEmpty()) {
488		assertFalse(y.isEmpty());
489	<	assertEquals(x.pollFirst(), y.pollFirst());
489	>	mustEqual(x.pollFirst(), y.pollFirst());
490		}
491		assertTrue(y.isEmpty());
492		}
#	Line 497 | Line 495 | public class TreeSubSetTest extends JSR1
495		* subSet returns set with keys in requested range
496		*/
497		public void testSubSetContents() {
498	<	NavigableSet set = set5();
499	<	SortedSet sm = set.subSet(two, four);
500	<	assertEquals(two, sm.first());
501	<	assertEquals(three, sm.last());
502	<	assertEquals(2, sm.size());
503	<	assertFalse(sm.contains(one));
504	<	assertTrue(sm.contains(two));
505	<	assertTrue(sm.contains(three));
506	<	assertFalse(sm.contains(four));
507	<	assertFalse(sm.contains(five));
508	<	Iterator i = sm.iterator();
509	<	Object k;
510	<	k = (Integer)(i.next());
511	<	assertEquals(two, k);
512	<	k = (Integer)(i.next());
515	<	assertEquals(three, k);
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 j = sm.iterator();
514	>	Iterator<? extends Item> j = sm.iterator();
515		j.next();
516		j.remove();
517	<	assertFalse(set.contains(two));
518	<	assertEquals(4, set.size());
519	<	assertEquals(1, sm.size());
520	<	assertEquals(three, sm.first());
521	<	assertEquals(three, sm.last());
522	<	assertTrue(sm.remove(three));
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	<	assertEquals(3, set.size());
524	>	mustEqual(3, set.size());
525		}
526
527		public void testSubSetContents2() {
528	<	NavigableSet set = set5();
529	<	SortedSet sm = set.subSet(two, three);
530	<	assertEquals(1, sm.size());
531	<	assertEquals(two, sm.first());
532	<	assertEquals(two, sm.last());
533	<	assertFalse(sm.contains(one));
534	<	assertTrue(sm.contains(two));
535	<	assertFalse(sm.contains(three));
536	<	assertFalse(sm.contains(four));
537	<	assertFalse(sm.contains(five));
538	<	Iterator i = sm.iterator();
539	<	Object k;
540	<	k = (Integer)(i.next());
544	<	assertEquals(two, k);
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 j = sm.iterator();
542	>	Iterator<? extends Item> j = sm.iterator();
543		j.next();
544		j.remove();
545	<	assertFalse(set.contains(two));
546	<	assertEquals(4, set.size());
547	<	assertEquals(0, sm.size());
545	>	mustNotContain(set, two);
546	>	mustEqual(4, set.size());
547	>	mustEqual(0, sm.size());
548		assertTrue(sm.isEmpty());
549	<	assertFalse(sm.remove(three));
550	<	assertEquals(4, set.size());
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 set = set5();
558	<	SortedSet sm = set.headSet(four);
559	<	assertTrue(sm.contains(one));
560	<	assertTrue(sm.contains(two));
561	<	assertTrue(sm.contains(three));
562	<	assertFalse(sm.contains(four));
563	<	assertFalse(sm.contains(five));
564	<	Iterator i = sm.iterator();
565	<	Object k;
566	<	k = (Integer)(i.next());
567	<	assertEquals(one, k);
568	<	k = (Integer)(i.next());
569	<	assertEquals(two, k);
570	<	k = (Integer)(i.next());
575	<	assertEquals(three, k);
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	<	assertEquals(2, set.size());
575	<	assertEquals(four, set.first());
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 set = set5();
583	<	SortedSet sm = set.tailSet(two);
584	<	assertFalse(sm.contains(one));
585	<	assertTrue(sm.contains(two));
586	<	assertTrue(sm.contains(three));
587	<	assertTrue(sm.contains(four));
588	<	assertTrue(sm.contains(five));
589	<	Iterator i = sm.iterator();
590	<	Object k;
591	<	k = (Integer)(i.next());
592	<	assertEquals(two, k);
593	<	k = (Integer)(i.next());
594	<	assertEquals(three, k);
595	<	k = (Integer)(i.next());
596	<	assertEquals(four, k);
597	<	k = (Integer)(i.next());
603	<	assertEquals(five, k);
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 ssm = sm.tailSet(four);
601	<	assertEquals(four, ssm.first());
602	<	assertEquals(five, ssm.last());
603	<	assertTrue(ssm.remove(four));
604	<	assertEquals(1, ssm.size());
605	<	assertEquals(3, sm.size());
606	<	assertEquals(4, set.size());
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 q = populatedSet(SIZE);
613	>	NavigableSet<Item> q = populatedSet(SIZE);
614		for (int i = 0; i < SIZE; ++i) {
615	<	assertEquals(SIZE - i, q.size());
615	>	mustEqual(SIZE - i, q.size());
616		q.pollFirst();
617		}
618		for (int i = 0; i < SIZE; ++i) {
619	<	assertEquals(i, q.size());
620	<	q.add(new Integer(i));
619	>	mustEqual(i, q.size());
620	>	mustAdd(q, i);
621		}
622		}
623
#	Line 631 | Line 625 | public class TreeSubSetTest extends JSR1
625		* Add of comparable element succeeds
626		*/
627		public void testDescendingAdd() {
628	<	NavigableSet q = dset0();
629	<	assertTrue(q.add(m6));
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 q = dset0();
637	<	assertTrue(q.add(m6));
638	<	assertFalse(q.add(m6));
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 q = dset0();
645	>	NavigableSet<Object> q = new TreeSet<Object>();
646		try {
647		q.add(new Object());
648		q.add(new Object());
#	Line 660 | Line 654 | public class TreeSubSetTest extends JSR1
654		* addAll(null) throws NPE
655		*/
656		public void testDescendingAddAll1() {
657	<	NavigableSet q = dset0();
657	>	NavigableSet<Item> q = dset0();
658		try {
659		q.addAll(null);
660		shouldThrow();
#	Line 671 | Line 665 | public class TreeSubSetTest extends JSR1
665		* addAll of a collection with null elements throws NPE
666		*/
667		public void testDescendingAddAll2() {
668	<	NavigableSet q = dset0();
669	<	Integer[] ints = new Integer[SIZE];
668	>	NavigableSet<Item> q = dset0();
669	>	Item[] items = new Item[2]; items[0] = zero;
670		try {
671	<	q.addAll(Arrays.asList(ints));
671	>	q.addAll(Arrays.asList(items));
672		shouldThrow();
673		} catch (NullPointerException success) {}
674		}
#	Line 684 | Line 678 | public class TreeSubSetTest extends JSR1
678		* possibly adding some elements
679		*/
680		public void testDescendingAddAll3() {
681	<	NavigableSet q = dset0();
682	<	Integer[] ints = new Integer[SIZE];
683	<	for (int i = 0; i < SIZE - 1; ++i)
690	<	ints[i] = new Integer(i + SIZE);
681	>	NavigableSet<Item> q = dset0();
682	>	Item[] items = new Item[2];
683	>	items[0] = ninetynine;
684		try {
685	<	q.addAll(Arrays.asList(ints));
685	>	q.addAll(Arrays.asList(items));
686		shouldThrow();
687		} catch (NullPointerException success) {}
688		}
#	Line 698 | Line 691 | public class TreeSubSetTest extends JSR1
691		* Set contains all elements of successful addAll
692		*/
693		public void testDescendingAddAll5() {
694	<	Integer[] empty = new Integer[0];
695	<	Integer[] ints = new Integer[SIZE];
694	>	Item[] empty = new Item[0];
695	>	Item[] items = new Item[SIZE];
696		for (int i = 0; i < SIZE; ++i)
697	<	ints[i] = new Integer(SIZE - 1 - i);
698	<	NavigableSet q = dset0();
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(ints)));
700	>	assertTrue(q.addAll(Arrays.asList(items)));
701		for (int i = 0; i < SIZE; ++i)
702	<	assertEquals(new Integer(i), q.pollFirst());
702	>	mustEqual(i, q.pollFirst());
703		}
704
705		/**
706		* poll succeeds unless empty
707		*/
708		public void testDescendingPoll() {
709	<	NavigableSet q = populatedSet(SIZE);
709	>	NavigableSet<Item> q = populatedSet(SIZE);
710		for (int i = 0; i < SIZE; ++i) {
711	<	assertEquals(i, q.pollFirst());
711	>	mustEqual(i, q.pollFirst());
712		}
713		assertNull(q.pollFirst());
714		}
#	Line 724 | Line 717 | public class TreeSubSetTest extends JSR1
717		* remove(x) removes x and returns true if present
718		*/
719		public void testDescendingRemoveElement() {
720	<	NavigableSet q = populatedSet(SIZE);
720	>	NavigableSet<Item> q = populatedSet(SIZE);
721		for (int i = 1; i < SIZE; i += 2) {
722	<	assertTrue(q.remove(new Integer(i)));
722	>	mustRemove(q, i);
723		}
724		for (int i = 0; i < SIZE; i += 2) {
725	<	assertTrue(q.remove(new Integer(i)));
726	<	assertFalse(q.remove(new Integer(i + 1)));
725	>	mustRemove(q, i);
726	>	mustNotRemove(q, i + 1);
727		}
728		assertTrue(q.isEmpty());
729		}
#	Line 739 | Line 732 | public class TreeSubSetTest extends JSR1
732		* contains(x) reports true when elements added but not yet removed
733		*/
734		public void testDescendingContains() {
735	<	NavigableSet q = populatedSet(SIZE);
735	>	NavigableSet<Item> q = populatedSet(SIZE);
736		for (int i = 0; i < SIZE; ++i) {
737	<	assertTrue(q.contains(new Integer(i)));
737	>	mustContain(q, i);
738		q.pollFirst();
739	<	assertFalse(q.contains(new Integer(i)));
739	>	mustNotContain(q, i);
740		}
741		}
742
#	Line 751 | Line 744 | public class TreeSubSetTest extends JSR1
744		* clear removes all elements
745		*/
746		public void testDescendingClear() {
747	<	NavigableSet q = populatedSet(SIZE);
747	>	NavigableSet<Item> q = populatedSet(SIZE);
748		q.clear();
749		assertTrue(q.isEmpty());
750	<	assertEquals(0, q.size());
751	<	assertTrue(q.add(new Integer(1)));
750	>	mustEqual(0, q.size());
751	>	mustAdd(q, one);
752		assertFalse(q.isEmpty());
753		q.clear();
754		assertTrue(q.isEmpty());
#	Line 765 | Line 758 | public class TreeSubSetTest extends JSR1
758		* containsAll(c) is true when c contains a subset of elements
759		*/
760		public void testDescendingContainsAll() {
761	<	NavigableSet q = populatedSet(SIZE);
762	<	NavigableSet p = dset0();
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	<	p.add(new Integer(i));
766	>	mustAdd(p, i);
767		}
768		assertTrue(p.containsAll(q));
769		}
#	Line 779 | Line 772 | public class TreeSubSetTest extends JSR1
772		* retainAll(c) retains only those elements of c and reports true if changed
773		*/
774		public void testDescendingRetainAll() {
775	<	NavigableSet q = populatedSet(SIZE);
776	<	NavigableSet p = populatedSet(SIZE);
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)
#	Line 789 | Line 782 | public class TreeSubSetTest extends JSR1
782		assertTrue(changed);
783
784		assertTrue(q.containsAll(p));
785	<	assertEquals(SIZE - i, q.size());
785	>	mustEqual(SIZE - i, q.size());
786		p.pollFirst();
787		}
788		}
#	Line 799 | Line 792 | public class TreeSubSetTest extends JSR1
792		*/
793		public void testDescendingRemoveAll() {
794		for (int i = 1; i < SIZE; ++i) {
795	<	NavigableSet q = populatedSet(SIZE);
796	<	NavigableSet p = populatedSet(i);
795	>	NavigableSet<Item> q = populatedSet(SIZE);
796	>	NavigableSet<Item> p = populatedSet(i);
797		assertTrue(q.removeAll(p));
798	<	assertEquals(SIZE - i, q.size());
798	>	mustEqual(SIZE - i, q.size());
799		for (int j = 0; j < i; ++j) {
800	<	Integer x = (Integer)(p.pollFirst());
808	<	assertFalse(q.contains(x));
800	>	mustNotContain(q, p.pollFirst());
801		}
802		}
803		}
#	Line 814 | Line 806 | public class TreeSubSetTest extends JSR1
806		* lower returns preceding element
807		*/
808		public void testDescendingLower() {
809	<	NavigableSet q = dset5();
810	<	Object e1 = q.lower(m3);
811	<	assertEquals(m2, e1);
809	>	NavigableSet<Item> q = dset5();
810	>	Object e1 = q.lower(minusThree);
811	>	mustEqual(minusTwo, e1);
812
813	<	Object e2 = q.lower(m6);
814	<	assertEquals(m5, e2);
813	>	Object e2 = q.lower(minusSix);
814	>	mustEqual(minusFive, e2);
815
816	<	Object e3 = q.lower(m1);
816	>	Object e3 = q.lower(minusOne);
817		assertNull(e3);
818
819		Object e4 = q.lower(zero);
#	Line 832 | Line 824 | public class TreeSubSetTest extends JSR1
824		* higher returns next element
825		*/
826		public void testDescendingHigher() {
827	<	NavigableSet q = dset5();
828	<	Object e1 = q.higher(m3);
829	<	assertEquals(m4, e1);
827	>	NavigableSet<Item> q = dset5();
828	>	Object e1 = q.higher(minusThree);
829	>	mustEqual(minusFour, e1);
830
831		Object e2 = q.higher(zero);
832	<	assertEquals(m1, e2);
832	>	mustEqual(minusOne, e2);
833
834	<	Object e3 = q.higher(m5);
834	>	Object e3 = q.higher(minusFive);
835		assertNull(e3);
836
837	<	Object e4 = q.higher(m6);
837	>	Object e4 = q.higher(minusSix);
838		assertNull(e4);
839		}
840
#	Line 850 | Line 842 | public class TreeSubSetTest extends JSR1
842		* floor returns preceding element
843		*/
844		public void testDescendingFloor() {
845	<	NavigableSet q = dset5();
846	<	Object e1 = q.floor(m3);
847	<	assertEquals(m3, e1);
845	>	NavigableSet<Item> q = dset5();
846	>	Object e1 = q.floor(minusThree);
847	>	mustEqual(minusThree, e1);
848
849	<	Object e2 = q.floor(m6);
850	<	assertEquals(m5, e2);
849	>	Object e2 = q.floor(minusSix);
850	>	mustEqual(minusFive, e2);
851
852	<	Object e3 = q.floor(m1);
853	<	assertEquals(m1, e3);
852	>	Object e3 = q.floor(minusOne);
853	>	mustEqual(minusOne, e3);
854
855		Object e4 = q.floor(zero);
856		assertNull(e4);
#	Line 868 | Line 860 | public class TreeSubSetTest extends JSR1
860		* ceiling returns next element
861		*/
862		public void testDescendingCeiling() {
863	<	NavigableSet q = dset5();
864	<	Object e1 = q.ceiling(m3);
865	<	assertEquals(m3, e1);
863	>	NavigableSet<Item> q = dset5();
864	>	Object e1 = q.ceiling(minusThree);
865	>	mustEqual(minusThree, e1);
866
867		Object e2 = q.ceiling(zero);
868	<	assertEquals(m1, e2);
868	>	mustEqual(minusOne, e2);
869
870	<	Object e3 = q.ceiling(m5);
871	<	assertEquals(m5, e3);
870	>	Object e3 = q.ceiling(minusFive);
871	>	mustEqual(minusFive, e3);
872
873	<	Object e4 = q.ceiling(m6);
873	>	Object e4 = q.ceiling(minusSix);
874		assertNull(e4);
875		}
876
#	Line 886 | Line 878 | public class TreeSubSetTest extends JSR1
878		* toArray contains all elements
879		*/
880		public void testDescendingToArray() {
881	<	NavigableSet q = populatedSet(SIZE);
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());
885	>	mustEqual((Item)o[i], q.pollFirst());
886		}
887
888		/**
889		* toArray(a) contains all elements
890		*/
891		public void testDescendingToArray2() {
892	<	NavigableSet q = populatedSet(SIZE);
893	<	Integer[] ints = new Integer[SIZE];
894	<	assertSame(ints, q.toArray(ints));
895	<	Arrays.sort(ints);
896	<	for (int i = 0; i < ints.length; i++)
897	<	assertEquals(ints[i], q.pollFirst());
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
900		/**
901		* iterator iterates through all elements
902		*/
903		public void testDescendingIterator() {
904	<	NavigableSet q = populatedSet(SIZE);
904	>	NavigableSet<Item> q = populatedSet(SIZE);
905		int i = 0;
906	<	Iterator it = q.iterator();
906	>	Iterator<? extends Item> it = q.iterator();
907		while (it.hasNext()) {
908	<	assertTrue(q.contains(it.next()));
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 testDescendingEmptyIterator() {
918	<	NavigableSet q = dset0();
918	>	NavigableSet<Item> q = dset0();
919		int i = 0;
920	<	Iterator it = q.iterator();
920	>	Iterator<? extends Item> it = q.iterator();
921		while (it.hasNext()) {
922	<	assertTrue(q.contains(it.next()));
922	>	mustContain(q, it.next());
923		++i;
924		}
925	<	assertEquals(0, i);
925	>	mustEqual(0, i);
926		}
927
928		/**
929		* iterator.remove removes current element
930		*/
931		public void testDescendingIteratorRemove() {
932	<	final NavigableSet q = dset0();
933	<	q.add(new Integer(2));
934	<	q.add(new Integer(1));
935	<	q.add(new Integer(3));
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(2, it.next());
943	<	assertEquals(3, it.next());
942	>	mustEqual(two, it.next());
943	>	mustEqual(three, it.next());
944		assertFalse(it.hasNext());
945		}
946
#	Line 956 | Line 948 | public class TreeSubSetTest extends JSR1
948		* toString contains toStrings of elements
949		*/
950		public void testDescendingToString() {
951	<	NavigableSet q = populatedSet(SIZE);
951	>	NavigableSet<Item> q = populatedSet(SIZE);
952		String s = q.toString();
953		for (int i = 0; i < SIZE; ++i) {
954		assertTrue(s.contains(String.valueOf(i)));
#	Line 967 | Line 959 | public class TreeSubSetTest extends JSR1
959		* A deserialized/reserialized set equals original
960		*/
961		public void testDescendingSerialization() throws Exception {
962	<	NavigableSet x = dset5();
963	<	NavigableSet y = serialClone(x);
962	>	NavigableSet<Item> x = dset5();
963	>	NavigableSet<Item> y = serialClone(x);
964
965		assertNotSame(x, y);
966	<	assertEquals(x.size(), y.size());
967	<	assertEquals(x.toString(), y.toString());
968	<	assertEquals(x, y);
969	<	assertEquals(y, x);
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	<	assertEquals(x.pollFirst(), y.pollFirst());
972	>	mustEqual(x.pollFirst(), y.pollFirst());
973		}
974		assertTrue(y.isEmpty());
975		}
#	Line 986 | Line 978 | public class TreeSubSetTest extends JSR1
978		* subSet returns set with keys in requested range
979		*/
980		public void testDescendingSubSetContents() {
981	<	NavigableSet set = dset5();
982	<	SortedSet sm = set.subSet(m2, m4);
983	<	assertEquals(m2, sm.first());
984	<	assertEquals(m3, sm.last());
985	<	assertEquals(2, sm.size());
986	<	assertFalse(sm.contains(m1));
987	<	assertTrue(sm.contains(m2));
988	<	assertTrue(sm.contains(m3));
989	<	assertFalse(sm.contains(m4));
990	<	assertFalse(sm.contains(m5));
991	<	Iterator i = sm.iterator();
992	<	Object k;
993	<	k = (Integer)(i.next());
994	<	assertEquals(m2, k);
995	<	k = (Integer)(i.next());
1004	<	assertEquals(m3, k);
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(m2));
1001	<	assertEquals(4, set.size());
1002	<	assertEquals(1, sm.size());
1003	<	assertEquals(m3, sm.first());
1004	<	assertEquals(m3, sm.last());
1005	<	assertTrue(sm.remove(m3));
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 testDescendingSubSetContents2() {
1011	<	NavigableSet set = dset5();
1012	<	SortedSet sm = set.subSet(m2, m3);
1013	<	assertEquals(1, sm.size());
1014	<	assertEquals(m2, sm.first());
1015	<	assertEquals(m2, sm.last());
1016	<	assertFalse(sm.contains(m1));
1017	<	assertTrue(sm.contains(m2));
1018	<	assertFalse(sm.contains(m3));
1019	<	assertFalse(sm.contains(m4));
1020	<	assertFalse(sm.contains(m5));
1021	<	Iterator i = sm.iterator();
1022	<	Object k;
1023	<	k = (Integer)(i.next());
1033	<	assertEquals(m2, k);
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(m2));
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(m3));
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 testDescendingHeadSetContents() {
1040	<	NavigableSet set = dset5();
1041	<	SortedSet sm = set.headSet(m4);
1042	<	assertTrue(sm.contains(m1));
1043	<	assertTrue(sm.contains(m2));
1044	<	assertTrue(sm.contains(m3));
1045	<	assertFalse(sm.contains(m4));
1046	<	assertFalse(sm.contains(m5));
1047	<	Iterator i = sm.iterator();
1048	<	Object k;
1049	<	k = (Integer)(i.next());
1050	<	assertEquals(m1, k);
1051	<	k = (Integer)(i.next());
1052	<	assertEquals(m2, k);
1053	<	k = (Integer)(i.next());
1064	<	assertEquals(m3, k);
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(m4, 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 testDescendingTailSetContents() {
1065	<	NavigableSet set = dset5();
1066	<	SortedSet sm = set.tailSet(m2);
1067	<	assertFalse(sm.contains(m1));
1068	<	assertTrue(sm.contains(m2));
1069	<	assertTrue(sm.contains(m3));
1070	<	assertTrue(sm.contains(m4));
1071	<	assertTrue(sm.contains(m5));
1072	<	Iterator i = sm.iterator();
1073	<	Object k;
1074	<	k = (Integer)(i.next());
1075	<	assertEquals(m2, k);
1076	<	k = (Integer)(i.next());
1077	<	assertEquals(m3, k);
1078	<	k = (Integer)(i.next());
1079	<	assertEquals(m4, k);
1080	<	k = (Integer)(i.next());
1092	<	assertEquals(m5, k);
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(m4);
1084	<	assertEquals(m4, ssm.first());
1085	<	assertEquals(m5, ssm.last());
1086	<	assertTrue(ssm.remove(m4));
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 x = populatedSet(SIZE);
1097	<	Set y = new TreeSet(x);
1096	>	Set<Item> x = populatedSet(SIZE);
1097	>	Set<Item> y = new TreeSet<Item>(x);
1098		y.addAll(x);
1099	<	assertEquals(x, y);
1100	<	assertEquals(y, x);
1099	>	mustEqual(x, y);
1100	>	mustEqual(y, x);
1101		}
1102
1103		}

Diff Legend

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