ViewVC Help

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

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

Comparing jsr166/src/test/tck/TreeSubMapTest.java (file contents):
Revision 1.24 by jsr166, Fri Aug 4 03:30:21 2017 UTC vs.
Revision 1.25 by dl, Tue Jan 26 13:33:06 2021 UTC

#	Line 26 | Line 26 | public class TreeSubMapTest extends JSR1
26		}
27
28		/**
29	<	* Returns a new map from Integers 1-5 to Strings "A"-"E".
29	>	* Returns a new map from Items 1-5 to Strings "A"-"E".
30		*/
31	<	private static NavigableMap map5() {
32	<	TreeMap map = new TreeMap();
31	>	private static NavigableMap<Item,String> map5() {
32	>	TreeMap<Item,String> map = new TreeMap<Item,String>();
33		assertTrue(map.isEmpty());
34		map.put(zero, "Z");
35		map.put(one, "A");
#	Line 39 | Line 39 | public class TreeSubMapTest extends JSR1
39		map.put(four, "D");
40		map.put(seven, "F");
41		assertFalse(map.isEmpty());
42	<	assertEquals(7, map.size());
42	>	mustEqual(7, map.size());
43		return map.subMap(one, true, seven, false);
44		}
45
46	<	private static NavigableMap map0() {
47	<	TreeMap map = new TreeMap();
46	>	private static NavigableMap<Item,String> map0() {
47	>	TreeMap<Item,String> map = new TreeMap<Item,String>();
48		assertTrue(map.isEmpty());
49		return map.tailMap(one, true);
50		}
51
52		/**
53	<	* Returns a new map from Integers -5 to -1 to Strings "A"-"E".
53	>	* Returns a new map from Items -5 to -1 to Strings "A"-"E".
54		*/
55	<	private static NavigableMap dmap5() {
56	<	TreeMap map = new TreeMap();
55	>	private static NavigableMap<Item,String> dmap5() {
56	>	TreeMap<Item,String> map = new TreeMap<Item,String>();
57		assertTrue(map.isEmpty());
58	<	map.put(m1, "A");
59	<	map.put(m5, "E");
60	<	map.put(m3, "C");
61	<	map.put(m2, "B");
62	<	map.put(m4, "D");
58	>	map.put(minusOne, "A");
59	>	map.put(minusFive, "E");
60	>	map.put(minusThree, "C");
61	>	map.put(minusTwo, "B");
62	>	map.put(minusFour, "D");
63		assertFalse(map.isEmpty());
64	<	assertEquals(5, map.size());
64	>	mustEqual(5, map.size());
65		return map.descendingMap();
66		}
67
68	<	private static NavigableMap dmap0() {
69	<	TreeMap map = new TreeMap();
68	>	private static NavigableMap<Item,String> dmap0() {
69	>	TreeMap<Item,String> map = new TreeMap<Item,String>();
70		assertTrue(map.isEmpty());
71		return map;
72		}
#	Line 75 | Line 75 | public class TreeSubMapTest extends JSR1
75		* clear removes all pairs
76		*/
77		public void testClear() {
78	<	NavigableMap map = map5();
78	>	NavigableMap<Item,String> map = map5();
79		map.clear();
80	<	assertEquals(0, map.size());
80	>	mustEqual(0, map.size());
81		}
82
83		/**
84		* Maps with same contents are equal
85		*/
86		public void testEquals() {
87	<	NavigableMap map1 = map5();
88	<	NavigableMap map2 = map5();
89	<	assertEquals(map1, map2);
90	<	assertEquals(map2, map1);
87	>	NavigableMap<Item,String> map1 = map5();
88	>	NavigableMap<Item,String> map2 = map5();
89	>	mustEqual(map1, map2);
90	>	mustEqual(map2, map1);
91		map1.clear();
92		assertFalse(map1.equals(map2));
93		assertFalse(map2.equals(map1));
#	Line 97 | Line 97 | public class TreeSubMapTest extends JSR1
97		* containsKey returns true for contained key
98		*/
99		public void testContainsKey() {
100	<	NavigableMap map = map5();
100	>	NavigableMap<Item,String> map = map5();
101		assertTrue(map.containsKey(one));
102		assertFalse(map.containsKey(zero));
103		}
#	Line 106 | Line 106 | public class TreeSubMapTest extends JSR1
106		* containsValue returns true for held values
107		*/
108		public void testContainsValue() {
109	<	NavigableMap map = map5();
109	>	NavigableMap<Item,String> map = map5();
110		assertTrue(map.containsValue("A"));
111		assertFalse(map.containsValue("Z"));
112		}
#	Line 116 | Line 116 | public class TreeSubMapTest extends JSR1
116		* or null if not present
117		*/
118		public void testGet() {
119	<	NavigableMap map = map5();
120	<	assertEquals("A", (String)map.get(one));
121	<	NavigableMap empty = map0();
119	>	NavigableMap<Item,String> map = map5();
120	>	mustEqual("A", map.get(one));
121	>	NavigableMap<Item,String> empty = map0();
122		assertNull(empty.get(one));
123		}
124
#	Line 126 | Line 126 | public class TreeSubMapTest extends JSR1
126		* isEmpty is true of empty map and false for non-empty
127		*/
128		public void testIsEmpty() {
129	<	NavigableMap empty = map0();
130	<	NavigableMap map = map5();
129	>	NavigableMap<Item,String> empty = map0();
130	>	NavigableMap<Item,String> map = map5();
131		assertTrue(empty.isEmpty());
132		assertFalse(map.isEmpty());
133		}
#	Line 136 | Line 136 | public class TreeSubMapTest extends JSR1
136		* firstKey returns first key
137		*/
138		public void testFirstKey() {
139	<	NavigableMap map = map5();
140	<	assertEquals(one, map.firstKey());
139	>	NavigableMap<Item,String> map = map5();
140	>	mustEqual(one, map.firstKey());
141		}
142
143		/**
144		* lastKey returns last key
145		*/
146		public void testLastKey() {
147	<	NavigableMap map = map5();
148	<	assertEquals(five, map.lastKey());
147	>	NavigableMap<Item,String> map = map5();
148	>	mustEqual(five, map.lastKey());
149		}
150
151		/**
152		* keySet returns a Set containing all the keys
153		*/
154		public void testKeySet() {
155	<	NavigableMap map = map5();
156	<	Set s = map.keySet();
157	<	assertEquals(5, s.size());
158	<	assertTrue(s.contains(one));
159	<	assertTrue(s.contains(two));
160	<	assertTrue(s.contains(three));
161	<	assertTrue(s.contains(four));
162	<	assertTrue(s.contains(five));
155	>	NavigableMap<Item,String> map = map5();
156	>	Set<Item> s = map.keySet();
157	>	mustEqual(5, s.size());
158	>	mustContain(s, one);
159	>	mustContain(s, two);
160	>	mustContain(s, three);
161	>	mustContain(s, four);
162	>	mustContain(s, five);
163		}
164
165		/**
166		* keySet is ordered
167		*/
168		public void testKeySetOrder() {
169	<	NavigableMap map = map5();
170	<	Set s = map.keySet();
171	<	Iterator i = s.iterator();
172	<	Integer last = (Integer)i.next();
173	<	assertEquals(last, one);
169	>	NavigableMap<Item,String> map = map5();
170	>	Set<Item> s = map.keySet();
171	>	Iterator<? extends Item> i = s.iterator();
172	>	Item last = i.next();
173	>	mustEqual(last, one);
174		while (i.hasNext()) {
175	<	Integer k = (Integer)i.next();
175	>	Item k = i.next();
176		assertTrue(last.compareTo(k) < 0);
177		last = k;
178		}
#	Line 182 | Line 182 | public class TreeSubMapTest extends JSR1
182		* values collection contains all values
183		*/
184		public void testValues() {
185	<	NavigableMap map = map5();
186	<	Collection s = map.values();
187	<	assertEquals(5, s.size());
185	>	NavigableMap<Item,String> map = map5();
186	>	Collection<String> s = map.values();
187	>	mustEqual(5, s.size());
188		assertTrue(s.contains("A"));
189		assertTrue(s.contains("B"));
190		assertTrue(s.contains("C"));
#	Line 196 | Line 196 | public class TreeSubMapTest extends JSR1
196		* entrySet contains all pairs
197		*/
198		public void testEntrySet() {
199	<	NavigableMap map = map5();
200	<	Set s = map.entrySet();
201	<	assertEquals(5, s.size());
202	<	Iterator it = s.iterator();
199	>	NavigableMap<Item,String> map = map5();
200	>	Set<Map.Entry<Item,String>> s = map.entrySet();
201	>	mustEqual(5, s.size());
202	>	Iterator<? extends Map.Entry<Item,String>> it = s.iterator();
203		while (it.hasNext()) {
204	<	Map.Entry e = (Map.Entry) it.next();
204	>	Map.Entry<Item,String> e = it.next();
205		assertTrue(
206		(e.getKey().equals(one) && e.getValue().equals("A")) ||
207		(e.getKey().equals(two) && e.getValue().equals("B")) ||
#	Line 215 | Line 215 | public class TreeSubMapTest extends JSR1
215		* putAll adds all key-value pairs from the given map
216		*/
217		public void testPutAll() {
218	<	NavigableMap empty = map0();
219	<	NavigableMap map = map5();
218	>	NavigableMap<Item,String> empty = map0();
219	>	NavigableMap<Item,String> map = map5();
220		empty.putAll(map);
221	<	assertEquals(5, empty.size());
221	>	mustEqual(5, empty.size());
222		assertTrue(empty.containsKey(one));
223		assertTrue(empty.containsKey(two));
224		assertTrue(empty.containsKey(three));
#	Line 230 | Line 230 | public class TreeSubMapTest extends JSR1
230		* remove removes the correct key-value pair from the map
231		*/
232		public void testRemove() {
233	<	NavigableMap map = map5();
233	>	NavigableMap<Item,String> map = map5();
234		map.remove(five);
235	<	assertEquals(4, map.size());
235	>	mustEqual(4, map.size());
236		assertFalse(map.containsKey(five));
237		}
238
#	Line 240 | Line 240 | public class TreeSubMapTest extends JSR1
240		* lowerEntry returns preceding entry.
241		*/
242		public void testLowerEntry() {
243	<	NavigableMap map = map5();
244	<	Map.Entry e1 = map.lowerEntry(three);
245	<	assertEquals(two, e1.getKey());
243	>	NavigableMap<Item,String> map = map5();
244	>	Map.Entry<Item,String> e1 = map.lowerEntry(three);
245	>	mustEqual(two, e1.getKey());
246
247	<	Map.Entry e2 = map.lowerEntry(six);
248	<	assertEquals(five, e2.getKey());
247	>	Map.Entry<Item,String> e2 = map.lowerEntry(six);
248	>	mustEqual(five, e2.getKey());
249
250	<	Map.Entry e3 = map.lowerEntry(one);
250	>	Map.Entry<Item,String> e3 = map.lowerEntry(one);
251		assertNull(e3);
252
253	<	Map.Entry e4 = map.lowerEntry(zero);
253	>	Map.Entry<Item,String> e4 = map.lowerEntry(zero);
254		assertNull(e4);
255		}
256
#	Line 258 | Line 258 | public class TreeSubMapTest extends JSR1
258		* higherEntry returns next entry.
259		*/
260		public void testHigherEntry() {
261	<	NavigableMap map = map5();
262	<	Map.Entry e1 = map.higherEntry(three);
263	<	assertEquals(four, e1.getKey());
261	>	NavigableMap<Item,String> map = map5();
262	>	Map.Entry<Item,String> e1 = map.higherEntry(three);
263	>	mustEqual(four, e1.getKey());
264
265	<	Map.Entry e2 = map.higherEntry(zero);
266	<	assertEquals(one, e2.getKey());
265	>	Map.Entry<Item,String> e2 = map.higherEntry(zero);
266	>	mustEqual(one, e2.getKey());
267
268	<	Map.Entry e3 = map.higherEntry(five);
268	>	Map.Entry<Item,String> e3 = map.higherEntry(five);
269		assertNull(e3);
270
271	<	Map.Entry e4 = map.higherEntry(six);
271	>	Map.Entry<Item,String> e4 = map.higherEntry(six);
272		assertNull(e4);
273		}
274
#	Line 276 | Line 276 | public class TreeSubMapTest extends JSR1
276		* floorEntry returns preceding entry.
277		*/
278		public void testFloorEntry() {
279	<	NavigableMap map = map5();
280	<	Map.Entry e1 = map.floorEntry(three);
281	<	assertEquals(three, e1.getKey());
279	>	NavigableMap<Item,String> map = map5();
280	>	Map.Entry<Item,String> e1 = map.floorEntry(three);
281	>	mustEqual(three, e1.getKey());
282
283	<	Map.Entry e2 = map.floorEntry(six);
284	<	assertEquals(five, e2.getKey());
283	>	Map.Entry<Item,String> e2 = map.floorEntry(six);
284	>	mustEqual(five, e2.getKey());
285
286	<	Map.Entry e3 = map.floorEntry(one);
287	<	assertEquals(one, e3.getKey());
286	>	Map.Entry<Item,String> e3 = map.floorEntry(one);
287	>	mustEqual(one, e3.getKey());
288
289	<	Map.Entry e4 = map.floorEntry(zero);
289	>	Map.Entry<Item,String> e4 = map.floorEntry(zero);
290		assertNull(e4);
291		}
292
#	Line 294 | Line 294 | public class TreeSubMapTest extends JSR1
294		* ceilingEntry returns next entry.
295		*/
296		public void testCeilingEntry() {
297	<	NavigableMap map = map5();
298	<	Map.Entry e1 = map.ceilingEntry(three);
299	<	assertEquals(three, e1.getKey());
297	>	NavigableMap<Item,String> map = map5();
298	>	Map.Entry<Item,String> e1 = map.ceilingEntry(three);
299	>	mustEqual(three, e1.getKey());
300
301	<	Map.Entry e2 = map.ceilingEntry(zero);
302	<	assertEquals(one, e2.getKey());
301	>	Map.Entry<Item,String> e2 = map.ceilingEntry(zero);
302	>	mustEqual(one, e2.getKey());
303
304	<	Map.Entry e3 = map.ceilingEntry(five);
305	<	assertEquals(five, e3.getKey());
304	>	Map.Entry<Item,String> e3 = map.ceilingEntry(five);
305	>	mustEqual(five, e3.getKey());
306
307	<	Map.Entry e4 = map.ceilingEntry(six);
307	>	Map.Entry<Item,String> e4 = map.ceilingEntry(six);
308		assertNull(e4);
309		}
310
#	Line 312 | Line 312 | public class TreeSubMapTest extends JSR1
312		* pollFirstEntry returns entries in order
313		*/
314		public void testPollFirstEntry() {
315	<	NavigableMap map = map5();
316	<	Map.Entry e = map.pollFirstEntry();
317	<	assertEquals(one, e.getKey());
318	<	assertEquals("A", e.getValue());
315	>	NavigableMap<Item,String> map = map5();
316	>	Map.Entry<Item,String> e = map.pollFirstEntry();
317	>	mustEqual(one, e.getKey());
318	>	mustEqual("A", e.getValue());
319		e = map.pollFirstEntry();
320	<	assertEquals(two, e.getKey());
320	>	mustEqual(two, e.getKey());
321		map.put(one, "A");
322		e = map.pollFirstEntry();
323	<	assertEquals(one, e.getKey());
324	<	assertEquals("A", e.getValue());
323	>	mustEqual(one, e.getKey());
324	>	mustEqual("A", e.getValue());
325		e = map.pollFirstEntry();
326	<	assertEquals(three, e.getKey());
326	>	mustEqual(three, e.getKey());
327		map.remove(four);
328		e = map.pollFirstEntry();
329	<	assertEquals(five, e.getKey());
329	>	mustEqual(five, e.getKey());
330		try {
331		e.setValue("A");
332		shouldThrow();
333		} catch (UnsupportedOperationException success) {}
334		assertTrue(map.isEmpty());
335	<	Map.Entry f = map.firstEntry();
335	>	Map.Entry<Item,String> f = map.firstEntry();
336		assertNull(f);
337		e = map.pollFirstEntry();
338		assertNull(e);
#	Line 342 | Line 342 | public class TreeSubMapTest extends JSR1
342		* pollLastEntry returns entries in order
343		*/
344		public void testPollLastEntry() {
345	<	NavigableMap map = map5();
346	<	Map.Entry e = map.pollLastEntry();
347	<	assertEquals(five, e.getKey());
348	<	assertEquals("E", e.getValue());
345	>	NavigableMap<Item,String> map = map5();
346	>	Map.Entry<Item,String> e = map.pollLastEntry();
347	>	mustEqual(five, e.getKey());
348	>	mustEqual("E", e.getValue());
349		e = map.pollLastEntry();
350	<	assertEquals(four, e.getKey());
350	>	mustEqual(four, e.getKey());
351		map.put(five, "E");
352		e = map.pollLastEntry();
353	<	assertEquals(five, e.getKey());
354	<	assertEquals("E", e.getValue());
353	>	mustEqual(five, e.getKey());
354	>	mustEqual("E", e.getValue());
355		e = map.pollLastEntry();
356	<	assertEquals(three, e.getKey());
356	>	mustEqual(three, e.getKey());
357		map.remove(two);
358		e = map.pollLastEntry();
359	<	assertEquals(one, e.getKey());
359	>	mustEqual(one, e.getKey());
360		try {
361		e.setValue("E");
362		shouldThrow();
#	Line 369 | Line 369 | public class TreeSubMapTest extends JSR1
369		* size returns the correct values
370		*/
371		public void testSize() {
372	<	NavigableMap map = map5();
373	<	NavigableMap empty = map0();
374	<	assertEquals(0, empty.size());
375	<	assertEquals(5, map.size());
372	>	NavigableMap<Item,String> map = map5();
373	>	NavigableMap<Item,String> empty = map0();
374	>	mustEqual(0, empty.size());
375	>	mustEqual(5, map.size());
376		}
377
378		/**
379		* toString contains toString of elements
380		*/
381		public void testToString() {
382	<	NavigableMap map = map5();
382	>	NavigableMap<Item,String> map = map5();
383		String s = map.toString();
384		for (int i = 1; i <= 5; ++i) {
385		assertTrue(s.contains(String.valueOf(i)));
#	Line 392 | Line 392 | public class TreeSubMapTest extends JSR1
392		* get(null) of nonempty map throws NPE
393		*/
394		public void testGet_NullPointerException() {
395	<	NavigableMap c = map5();
395	>	NavigableMap<Item,String> c = map5();
396		try {
397		c.get(null);
398		shouldThrow();
#	Line 403 | Line 403 | public class TreeSubMapTest extends JSR1
403		* containsKey(null) of nonempty map throws NPE
404		*/
405		public void testContainsKey_NullPointerException() {
406	<	NavigableMap c = map5();
406	>	NavigableMap<Item,String> c = map5();
407		try {
408		c.containsKey(null);
409		shouldThrow();
#	Line 414 | Line 414 | public class TreeSubMapTest extends JSR1
414		* put(null,x) throws NPE
415		*/
416		public void testPut1_NullPointerException() {
417	<	NavigableMap c = map5();
417	>	NavigableMap<Item,String> c = map5();
418		try {
419		c.put(null, "whatever");
420		shouldThrow();
#	Line 425 | Line 425 | public class TreeSubMapTest extends JSR1
425		* remove(null) throws NPE
426		*/
427		public void testRemove1_NullPointerException() {
428	<	NavigableMap c = map5();
428	>	NavigableMap<Item,String> c = map5();
429		try {
430		c.remove(null);
431		shouldThrow();
#	Line 436 | Line 436 | public class TreeSubMapTest extends JSR1
436		* A deserialized/reserialized map equals original
437		*/
438		public void testSerialization() throws Exception {
439	<	NavigableMap x = map5();
440	<	NavigableMap y = serialClone(x);
439	>	NavigableMap<Item,String> x = map5();
440	>	NavigableMap<Item,String> y = serialClone(x);
441
442		assertNotSame(x, y);
443	<	assertEquals(x.size(), y.size());
444	<	assertEquals(x.toString(), y.toString());
445	<	assertEquals(x, y);
446	<	assertEquals(y, x);
443	>	mustEqual(x.size(), y.size());
444	>	mustEqual(x.toString(), y.toString());
445	>	mustEqual(x, y);
446	>	mustEqual(y, x);
447		}
448
449		/**
450		* subMap returns map with keys in requested range
451		*/
452		public void testSubMapContents() {
453	<	NavigableMap map = map5();
454	<	SortedMap sm = map.subMap(two, four);
455	<	assertEquals(two, sm.firstKey());
456	<	assertEquals(three, sm.lastKey());
457	<	assertEquals(2, sm.size());
453	>	NavigableMap<Item,String> map = map5();
454	>	SortedMap<Item,String> sm = map.subMap(two, four);
455	>	mustEqual(two, sm.firstKey());
456	>	mustEqual(three, sm.lastKey());
457	>	mustEqual(2, sm.size());
458		assertFalse(sm.containsKey(one));
459		assertTrue(sm.containsKey(two));
460		assertTrue(sm.containsKey(three));
461		assertFalse(sm.containsKey(four));
462		assertFalse(sm.containsKey(five));
463	<	Iterator i = sm.keySet().iterator();
464	<	Object k;
465	<	k = (Integer)(i.next());
466	<	assertEquals(two, k);
467	<	k = (Integer)(i.next());
468	<	assertEquals(three, k);
463	>	Iterator<? extends Item> i = sm.keySet().iterator();
464	>	Item k;
465	>	k = (Item)(i.next());
466	>	mustEqual(two, k);
467	>	k = (Item)(i.next());
468	>	mustEqual(three, k);
469		assertFalse(i.hasNext());
470	<	Iterator j = sm.keySet().iterator();
470	>	Iterator<? extends Item> j = sm.keySet().iterator();
471		j.next();
472		j.remove();
473		assertFalse(map.containsKey(two));
474	<	assertEquals(4, map.size());
475	<	assertEquals(1, sm.size());
476	<	assertEquals(three, sm.firstKey());
477	<	assertEquals(three, sm.lastKey());
478	<	assertEquals("C", sm.remove(three));
474	>	mustEqual(4, map.size());
475	>	mustEqual(1, sm.size());
476	>	mustEqual(three, sm.firstKey());
477	>	mustEqual(three, sm.lastKey());
478	>	mustEqual("C", sm.remove(three));
479		assertTrue(sm.isEmpty());
480	<	assertEquals(3, map.size());
480	>	mustEqual(3, map.size());
481		}
482
483		public void testSubMapContents2() {
484	<	NavigableMap map = map5();
485	<	SortedMap sm = map.subMap(two, three);
486	<	assertEquals(1, sm.size());
487	<	assertEquals(two, sm.firstKey());
488	<	assertEquals(two, sm.lastKey());
484	>	NavigableMap<Item,String> map = map5();
485	>	SortedMap<Item,String> sm = map.subMap(two, three);
486	>	mustEqual(1, sm.size());
487	>	mustEqual(two, sm.firstKey());
488	>	mustEqual(two, sm.lastKey());
489		assertFalse(sm.containsKey(one));
490		assertTrue(sm.containsKey(two));
491		assertFalse(sm.containsKey(three));
492		assertFalse(sm.containsKey(four));
493		assertFalse(sm.containsKey(five));
494	<	Iterator i = sm.keySet().iterator();
494	>	Iterator<? extends Item> i = sm.keySet().iterator();
495		Object k;
496	<	k = (Integer)(i.next());
497	<	assertEquals(two, k);
496	>	k = (Item)(i.next());
497	>	mustEqual(two, k);
498		assertFalse(i.hasNext());
499	<	Iterator j = sm.keySet().iterator();
499	>	Iterator<? extends Item> j = sm.keySet().iterator();
500		j.next();
501		j.remove();
502		assertFalse(map.containsKey(two));
503	<	assertEquals(4, map.size());
504	<	assertEquals(0, sm.size());
503	>	mustEqual(4, map.size());
504	>	mustEqual(0, sm.size());
505		assertTrue(sm.isEmpty());
506	<	assertSame(sm.remove(three), null);
507	<	assertEquals(4, map.size());
506	>	assertNull(sm.remove(three));
507	>	mustEqual(4, map.size());
508		}
509
510		/**
511		* headMap returns map with keys in requested range
512		*/
513		public void testHeadMapContents() {
514	<	NavigableMap map = map5();
515	<	SortedMap sm = map.headMap(four);
514	>	NavigableMap<Item,String> map = map5();
515	>	SortedMap<Item,String> sm = map.headMap(four);
516		assertTrue(sm.containsKey(one));
517		assertTrue(sm.containsKey(two));
518		assertTrue(sm.containsKey(three));
519		assertFalse(sm.containsKey(four));
520		assertFalse(sm.containsKey(five));
521	<	Iterator i = sm.keySet().iterator();
522	<	Object k;
523	<	k = (Integer)(i.next());
524	<	assertEquals(one, k);
525	<	k = (Integer)(i.next());
526	<	assertEquals(two, k);
527	<	k = (Integer)(i.next());
528	<	assertEquals(three, k);
521	>	Iterator<? extends Item> i = sm.keySet().iterator();
522	>	Item k;
523	>	k = (Item)(i.next());
524	>	mustEqual(one, k);
525	>	k = (Item)(i.next());
526	>	mustEqual(two, k);
527	>	k = (Item)(i.next());
528	>	mustEqual(three, k);
529		assertFalse(i.hasNext());
530		sm.clear();
531		assertTrue(sm.isEmpty());
532	<	assertEquals(2, map.size());
533	<	assertEquals(four, map.firstKey());
532	>	mustEqual(2, map.size());
533	>	mustEqual(four, map.firstKey());
534		}
535
536		/**
537		* headMap returns map with keys in requested range
538		*/
539		public void testTailMapContents() {
540	<	NavigableMap map = map5();
541	<	SortedMap sm = map.tailMap(two);
540	>	NavigableMap<Item,String> map = map5();
541	>	SortedMap<Item,String> sm = map.tailMap(two);
542		assertFalse(sm.containsKey(one));
543		assertTrue(sm.containsKey(two));
544		assertTrue(sm.containsKey(three));
545		assertTrue(sm.containsKey(four));
546		assertTrue(sm.containsKey(five));
547	<	Iterator i = sm.keySet().iterator();
547	>	Iterator<? extends Item> i = sm.keySet().iterator();
548		Object k;
549	<	k = (Integer)(i.next());
550	<	assertEquals(two, k);
551	<	k = (Integer)(i.next());
552	<	assertEquals(three, k);
553	<	k = (Integer)(i.next());
554	<	assertEquals(four, k);
555	<	k = (Integer)(i.next());
556	<	assertEquals(five, k);
549	>	k = (Item)(i.next());
550	>	mustEqual(two, k);
551	>	k = (Item)(i.next());
552	>	mustEqual(three, k);
553	>	k = (Item)(i.next());
554	>	mustEqual(four, k);
555	>	k = (Item)(i.next());
556	>	mustEqual(five, k);
557		assertFalse(i.hasNext());
558
559	<	Iterator ei = sm.entrySet().iterator();
560	<	Map.Entry e;
561	<	e = (Map.Entry)(ei.next());
562	<	assertEquals(two, e.getKey());
563	<	assertEquals("B", e.getValue());
564	<	e = (Map.Entry)(ei.next());
565	<	assertEquals(three, e.getKey());
566	<	assertEquals("C", e.getValue());
567	<	e = (Map.Entry)(ei.next());
568	<	assertEquals(four, e.getKey());
569	<	assertEquals("D", e.getValue());
570	<	e = (Map.Entry)(ei.next());
571	<	assertEquals(five, e.getKey());
572	<	assertEquals("E", e.getValue());
559	>	Iterator<Map.Entry<Item,String>> ei = sm.entrySet().iterator();
560	>	Map.Entry<Item,String> e;
561	>	e = ei.next();
562	>	mustEqual(two, e.getKey());
563	>	mustEqual("B", e.getValue());
564	>	e = (ei.next());
565	>	mustEqual(three, e.getKey());
566	>	mustEqual("C", e.getValue());
567	>	e = (ei.next());
568	>	mustEqual(four, e.getKey());
569	>	mustEqual("D", e.getValue());
570	>	e = (ei.next());
571	>	mustEqual(five, e.getKey());
572	>	mustEqual("E", e.getValue());
573		assertFalse(i.hasNext());
574
575	<	SortedMap ssm = sm.tailMap(four);
576	<	assertEquals(four, ssm.firstKey());
577	<	assertEquals(five, ssm.lastKey());
578	<	assertEquals("D", ssm.remove(four));
579	<	assertEquals(1, ssm.size());
580	<	assertEquals(3, sm.size());
581	<	assertEquals(4, map.size());
575	>	SortedMap<Item,String> ssm = sm.tailMap(four);
576	>	mustEqual(four, ssm.firstKey());
577	>	mustEqual(five, ssm.lastKey());
578	>	mustEqual("D", ssm.remove(four));
579	>	mustEqual(1, ssm.size());
580	>	mustEqual(3, sm.size());
581	>	mustEqual(4, map.size());
582		}
583
584		/**
585		* clear removes all pairs
586		*/
587		public void testDescendingClear() {
588	<	NavigableMap map = dmap5();
588	>	NavigableMap<Item,String> map = dmap5();
589		map.clear();
590	<	assertEquals(0, map.size());
590	>	mustEqual(0, map.size());
591		}
592
593		/**
594		* Maps with same contents are equal
595		*/
596		public void testDescendingEquals() {
597	<	NavigableMap map1 = dmap5();
598	<	NavigableMap map2 = dmap5();
599	<	assertEquals(map1, map2);
600	<	assertEquals(map2, map1);
597	>	NavigableMap<Item,String> map1 = dmap5();
598	>	NavigableMap<Item,String> map2 = dmap5();
599	>	mustEqual(map1, map2);
600	>	mustEqual(map2, map1);
601		map1.clear();
602		assertFalse(map1.equals(map2));
603		assertFalse(map2.equals(map1));
#	Line 607 | Line 607 | public class TreeSubMapTest extends JSR1
607		* containsKey returns true for contained key
608		*/
609		public void testDescendingContainsKey() {
610	<	NavigableMap map = dmap5();
611	<	assertTrue(map.containsKey(m1));
610	>	NavigableMap<Item,String> map = dmap5();
611	>	assertTrue(map.containsKey(minusOne));
612		assertFalse(map.containsKey(zero));
613		}
614
#	Line 616 | Line 616 | public class TreeSubMapTest extends JSR1
616		* containsValue returns true for held values
617		*/
618		public void testDescendingContainsValue() {
619	<	NavigableMap map = dmap5();
619	>	NavigableMap<Item,String> map = dmap5();
620		assertTrue(map.containsValue("A"));
621		assertFalse(map.containsValue("Z"));
622		}
#	Line 626 | Line 626 | public class TreeSubMapTest extends JSR1
626		* or null if not present
627		*/
628		public void testDescendingGet() {
629	<	NavigableMap map = dmap5();
630	<	assertEquals("A", (String)map.get(m1));
631	<	NavigableMap empty = dmap0();
632	<	assertNull(empty.get(m1));
629	>	NavigableMap<Item,String> map = dmap5();
630	>	mustEqual("A", map.get(minusOne));
631	>	NavigableMap<Item,String> empty = dmap0();
632	>	assertNull(empty.get(minusOne));
633		}
634
635		/**
636		* isEmpty is true of empty map and false for non-empty
637		*/
638		public void testDescendingIsEmpty() {
639	<	NavigableMap empty = dmap0();
640	<	NavigableMap map = dmap5();
639	>	NavigableMap<Item,String> empty = dmap0();
640	>	NavigableMap<Item,String> map = dmap5();
641		assertTrue(empty.isEmpty());
642		assertFalse(map.isEmpty());
643		}
#	Line 646 | Line 646 | public class TreeSubMapTest extends JSR1
646		* firstKey returns first key
647		*/
648		public void testDescendingFirstKey() {
649	<	NavigableMap map = dmap5();
650	<	assertEquals(m1, map.firstKey());
649	>	NavigableMap<Item,String> map = dmap5();
650	>	mustEqual(minusOne, map.firstKey());
651		}
652
653		/**
654		* lastKey returns last key
655		*/
656		public void testDescendingLastKey() {
657	<	NavigableMap map = dmap5();
658	<	assertEquals(m5, map.lastKey());
657	>	NavigableMap<Item,String> map = dmap5();
658	>	mustEqual(minusFive, map.lastKey());
659		}
660
661		/**
662		* keySet returns a Set containing all the keys
663		*/
664		public void testDescendingKeySet() {
665	<	NavigableMap map = dmap5();
666	<	Set s = map.keySet();
667	<	assertEquals(5, s.size());
668	<	assertTrue(s.contains(m1));
669	<	assertTrue(s.contains(m2));
670	<	assertTrue(s.contains(m3));
671	<	assertTrue(s.contains(m4));
672	<	assertTrue(s.contains(m5));
665	>	NavigableMap<Item,String> map = dmap5();
666	>	Set<Item> s = map.keySet();
667	>	mustEqual(5, s.size());
668	>	mustContain(s, minusOne);
669	>	mustContain(s, minusTwo);
670	>	mustContain(s, minusThree);
671	>	mustContain(s, minusFour);
672	>	mustContain(s, minusFive);
673		}
674
675		/**
676		* keySet is ordered
677		*/
678		public void testDescendingKeySetOrder() {
679	<	NavigableMap map = dmap5();
680	<	Set s = map.keySet();
681	<	Iterator i = s.iterator();
682	<	Integer last = (Integer)i.next();
683	<	assertEquals(last, m1);
679	>	NavigableMap<Item,String> map = dmap5();
680	>	Set<Item> s = map.keySet();
681	>	Iterator<? extends Item> i = s.iterator();
682	>	Item last = (Item)i.next();
683	>	mustEqual(last, minusOne);
684		while (i.hasNext()) {
685	<	Integer k = (Integer)i.next();
685	>	Item k = (Item)i.next();
686		assertTrue(last.compareTo(k) > 0);
687		last = k;
688		}
#	Line 692 | Line 692 | public class TreeSubMapTest extends JSR1
692		* values collection contains all values
693		*/
694		public void testDescendingValues() {
695	<	NavigableMap map = dmap5();
696	<	Collection s = map.values();
697	<	assertEquals(5, s.size());
695	>	NavigableMap<Item,String> map = dmap5();
696	>	Collection<String> s = map.values();
697	>	mustEqual(5, s.size());
698		assertTrue(s.contains("A"));
699		assertTrue(s.contains("B"));
700		assertTrue(s.contains("C"));
#	Line 706 | Line 706 | public class TreeSubMapTest extends JSR1
706		* keySet.toArray returns contains all keys
707		*/
708		public void testDescendingAscendingKeySetToArray() {
709	<	NavigableMap map = dmap5();
710	<	Set s = map.keySet();
711	<	Object[] ar = s.toArray();
709	>	NavigableMap<Item,String> map = dmap5();
710	>	Set<Item> s = map.keySet();
711	>	Item[] ar = s.toArray(new Item[0]);
712		assertTrue(s.containsAll(Arrays.asList(ar)));
713	<	assertEquals(5, ar.length);
714	<	ar[0] = m10;
713	>	mustEqual(5, ar.length);
714	>	ar[0] = minusTen;
715		assertFalse(s.containsAll(Arrays.asList(ar)));
716		}
717
#	Line 719 | Line 719 | public class TreeSubMapTest extends JSR1
719		* descendingkeySet.toArray returns contains all keys
720		*/
721		public void testDescendingDescendingKeySetToArray() {
722	<	NavigableMap map = dmap5();
723	<	Set s = map.descendingKeySet();
724	<	Object[] ar = s.toArray();
725	<	assertEquals(5, ar.length);
722	>	NavigableMap<Item,String> map = dmap5();
723	>	Set<Item> s = map.descendingKeySet();
724	>	Item[] ar = s.toArray(new Item[0]);
725	>	mustEqual(5, ar.length);
726		assertTrue(s.containsAll(Arrays.asList(ar)));
727	<	ar[0] = m10;
727	>	ar[0] = minusTen;
728		assertFalse(s.containsAll(Arrays.asList(ar)));
729		}
730
#	Line 732 | Line 732 | public class TreeSubMapTest extends JSR1
732		* Values.toArray contains all values
733		*/
734		public void testDescendingValuesToArray() {
735	<	NavigableMap map = dmap5();
736	<	Collection v = map.values();
737	<	Object[] ar = v.toArray();
738	<	ArrayList s = new ArrayList(Arrays.asList(ar));
739	<	assertEquals(5, ar.length);
735	>	NavigableMap<Item,String> map = dmap5();
736	>	Collection<String> v = map.values();
737	>	String[] ar = v.toArray(new String[0]);
738	>	ArrayList<String> s = new ArrayList<String>(Arrays.asList(ar));
739	>	mustEqual(5, ar.length);
740		assertTrue(s.contains("A"));
741		assertTrue(s.contains("B"));
742		assertTrue(s.contains("C"));
#	Line 748 | Line 748 | public class TreeSubMapTest extends JSR1
748		* entrySet contains all pairs
749		*/
750		public void testDescendingEntrySet() {
751	<	NavigableMap map = dmap5();
752	<	Set s = map.entrySet();
753	<	assertEquals(5, s.size());
754	<	Iterator it = s.iterator();
751	>	NavigableMap<Item,String> map = dmap5();
752	>	Set<Map.Entry<Item,String>> s = map.entrySet();
753	>	mustEqual(5, s.size());
754	>	Iterator<Map.Entry<Item,String>> it = s.iterator();
755		while (it.hasNext()) {
756	<	Map.Entry e = (Map.Entry) it.next();
756	>	Map.Entry<Item,String> e = it.next();
757		assertTrue(
758	<	(e.getKey().equals(m1) && e.getValue().equals("A")) ||
759	<	(e.getKey().equals(m2) && e.getValue().equals("B")) ||
760	<	(e.getKey().equals(m3) && e.getValue().equals("C")) ||
761	<	(e.getKey().equals(m4) && e.getValue().equals("D")) ||
762	<	(e.getKey().equals(m5) && e.getValue().equals("E")));
758	>	(e.getKey().equals(minusOne) && e.getValue().equals("A")) ||
759	>	(e.getKey().equals(minusTwo) && e.getValue().equals("B")) ||
760	>	(e.getKey().equals(minusThree) && e.getValue().equals("C")) ||
761	>	(e.getKey().equals(minusFour) && e.getValue().equals("D")) ||
762	>	(e.getKey().equals(minusFive) && e.getValue().equals("E")));
763		}
764		}
765
#	Line 767 | Line 767 | public class TreeSubMapTest extends JSR1
767		* putAll adds all key-value pairs from the given map
768		*/
769		public void testDescendingPutAll() {
770	<	NavigableMap empty = dmap0();
771	<	NavigableMap map = dmap5();
770	>	NavigableMap<Item,String> empty = dmap0();
771	>	NavigableMap<Item,String> map = dmap5();
772		empty.putAll(map);
773	<	assertEquals(5, empty.size());
774	<	assertTrue(empty.containsKey(m1));
775	<	assertTrue(empty.containsKey(m2));
776	<	assertTrue(empty.containsKey(m3));
777	<	assertTrue(empty.containsKey(m4));
778	<	assertTrue(empty.containsKey(m5));
773	>	mustEqual(5, empty.size());
774	>	assertTrue(empty.containsKey(minusOne));
775	>	assertTrue(empty.containsKey(minusTwo));
776	>	assertTrue(empty.containsKey(minusThree));
777	>	assertTrue(empty.containsKey(minusFour));
778	>	assertTrue(empty.containsKey(minusFive));
779		}
780
781		/**
782		* remove removes the correct key-value pair from the map
783		*/
784		public void testDescendingRemove() {
785	<	NavigableMap map = dmap5();
786	<	map.remove(m5);
787	<	assertEquals(4, map.size());
788	<	assertFalse(map.containsKey(m5));
785	>	NavigableMap<Item,String> map = dmap5();
786	>	map.remove(minusFive);
787	>	mustEqual(4, map.size());
788	>	assertFalse(map.containsKey(minusFive));
789		}
790
791		/**
792		* lowerEntry returns preceding entry.
793		*/
794		public void testDescendingLowerEntry() {
795	<	NavigableMap map = dmap5();
796	<	Map.Entry e1 = map.lowerEntry(m3);
797	<	assertEquals(m2, e1.getKey());
795	>	NavigableMap<Item,String> map = dmap5();
796	>	Map.Entry<Item,String> e1 = map.lowerEntry(minusThree);
797	>	mustEqual(minusTwo, e1.getKey());
798
799	<	Map.Entry e2 = map.lowerEntry(m6);
800	<	assertEquals(m5, e2.getKey());
799	>	Map.Entry<Item,String> e2 = map.lowerEntry(minusSix);
800	>	mustEqual(minusFive, e2.getKey());
801
802	<	Map.Entry e3 = map.lowerEntry(m1);
802	>	Map.Entry<Item,String> e3 = map.lowerEntry(minusOne);
803		assertNull(e3);
804
805	<	Map.Entry e4 = map.lowerEntry(zero);
805	>	Map.Entry<Item,String> e4 = map.lowerEntry(zero);
806		assertNull(e4);
807		}
808
#	Line 810 | Line 810 | public class TreeSubMapTest extends JSR1
810		* higherEntry returns next entry.
811		*/
812		public void testDescendingHigherEntry() {
813	<	NavigableMap map = dmap5();
814	<	Map.Entry e1 = map.higherEntry(m3);
815	<	assertEquals(m4, e1.getKey());
813	>	NavigableMap<Item,String> map = dmap5();
814	>	Map.Entry<Item,String> e1 = map.higherEntry(minusThree);
815	>	mustEqual(minusFour, e1.getKey());
816
817	<	Map.Entry e2 = map.higherEntry(zero);
818	<	assertEquals(m1, e2.getKey());
817	>	Map.Entry<Item,String> e2 = map.higherEntry(zero);
818	>	mustEqual(minusOne, e2.getKey());
819
820	<	Map.Entry e3 = map.higherEntry(m5);
820	>	Map.Entry<Item,String> e3 = map.higherEntry(minusFive);
821		assertNull(e3);
822
823	<	Map.Entry e4 = map.higherEntry(m6);
823	>	Map.Entry<Item,String> e4 = map.higherEntry(minusSix);
824		assertNull(e4);
825		}
826
#	Line 828 | Line 828 | public class TreeSubMapTest extends JSR1
828		* floorEntry returns preceding entry.
829		*/
830		public void testDescendingFloorEntry() {
831	<	NavigableMap map = dmap5();
832	<	Map.Entry e1 = map.floorEntry(m3);
833	<	assertEquals(m3, e1.getKey());
831	>	NavigableMap<Item,String> map = dmap5();
832	>	Map.Entry<Item,String> e1 = map.floorEntry(minusThree);
833	>	mustEqual(minusThree, e1.getKey());
834
835	<	Map.Entry e2 = map.floorEntry(m6);
836	<	assertEquals(m5, e2.getKey());
835	>	Map.Entry<Item,String> e2 = map.floorEntry(minusSix);
836	>	mustEqual(minusFive, e2.getKey());
837
838	<	Map.Entry e3 = map.floorEntry(m1);
839	<	assertEquals(m1, e3.getKey());
838	>	Map.Entry<Item,String> e3 = map.floorEntry(minusOne);
839	>	mustEqual(minusOne, e3.getKey());
840
841	<	Map.Entry e4 = map.floorEntry(zero);
841	>	Map.Entry<Item,String> e4 = map.floorEntry(zero);
842		assertNull(e4);
843		}
844
#	Line 846 | Line 846 | public class TreeSubMapTest extends JSR1
846		* ceilingEntry returns next entry.
847		*/
848		public void testDescendingCeilingEntry() {
849	<	NavigableMap map = dmap5();
850	<	Map.Entry e1 = map.ceilingEntry(m3);
851	<	assertEquals(m3, e1.getKey());
849	>	NavigableMap<Item,String> map = dmap5();
850	>	Map.Entry<Item,String> e1 = map.ceilingEntry(minusThree);
851	>	mustEqual(minusThree, e1.getKey());
852
853	<	Map.Entry e2 = map.ceilingEntry(zero);
854	<	assertEquals(m1, e2.getKey());
853	>	Map.Entry<Item,String> e2 = map.ceilingEntry(zero);
854	>	mustEqual(minusOne, e2.getKey());
855
856	<	Map.Entry e3 = map.ceilingEntry(m5);
857	<	assertEquals(m5, e3.getKey());
856	>	Map.Entry<Item,String> e3 = map.ceilingEntry(minusFive);
857	>	mustEqual(minusFive, e3.getKey());
858
859	<	Map.Entry e4 = map.ceilingEntry(m6);
859	>	Map.Entry<Item,String> e4 = map.ceilingEntry(minusSix);
860		assertNull(e4);
861		}
862
#	Line 864 | Line 864 | public class TreeSubMapTest extends JSR1
864		* pollFirstEntry returns entries in order
865		*/
866		public void testDescendingPollFirstEntry() {
867	<	NavigableMap map = dmap5();
868	<	Map.Entry e = map.pollFirstEntry();
869	<	assertEquals(m1, e.getKey());
870	<	assertEquals("A", e.getValue());
867	>	NavigableMap<Item,String> map = dmap5();
868	>	Map.Entry<Item,String> e = map.pollFirstEntry();
869	>	mustEqual(minusOne, e.getKey());
870	>	mustEqual("A", e.getValue());
871		e = map.pollFirstEntry();
872	<	assertEquals(m2, e.getKey());
873	<	map.put(m1, "A");
872	>	mustEqual(minusTwo, e.getKey());
873	>	map.put(minusOne, "A");
874		e = map.pollFirstEntry();
875	<	assertEquals(m1, e.getKey());
876	<	assertEquals("A", e.getValue());
875	>	mustEqual(minusOne, e.getKey());
876	>	mustEqual("A", e.getValue());
877		e = map.pollFirstEntry();
878	<	assertEquals(m3, e.getKey());
879	<	map.remove(m4);
878	>	mustEqual(minusThree, e.getKey());
879	>	map.remove(minusFour);
880		e = map.pollFirstEntry();
881	<	assertEquals(m5, e.getKey());
881	>	mustEqual(minusFive, e.getKey());
882		try {
883		e.setValue("A");
884		shouldThrow();
#	Line 891 | Line 891 | public class TreeSubMapTest extends JSR1
891		* pollLastEntry returns entries in order
892		*/
893		public void testDescendingPollLastEntry() {
894	<	NavigableMap map = dmap5();
895	<	Map.Entry e = map.pollLastEntry();
896	<	assertEquals(m5, e.getKey());
897	<	assertEquals("E", e.getValue());
894	>	NavigableMap<Item,String> map = dmap5();
895	>	Map.Entry<Item,String> e = map.pollLastEntry();
896	>	mustEqual(minusFive, e.getKey());
897	>	mustEqual("E", e.getValue());
898		e = map.pollLastEntry();
899	<	assertEquals(m4, e.getKey());
900	<	map.put(m5, "E");
899	>	mustEqual(minusFour, e.getKey());
900	>	map.put(minusFive, "E");
901		e = map.pollLastEntry();
902	<	assertEquals(m5, e.getKey());
903	<	assertEquals("E", e.getValue());
902	>	mustEqual(minusFive, e.getKey());
903	>	mustEqual("E", e.getValue());
904		e = map.pollLastEntry();
905	<	assertEquals(m3, e.getKey());
906	<	map.remove(m2);
905	>	mustEqual(minusThree, e.getKey());
906	>	map.remove(minusTwo);
907		e = map.pollLastEntry();
908	<	assertEquals(m1, e.getKey());
908	>	mustEqual(minusOne, e.getKey());
909		try {
910		e.setValue("E");
911		shouldThrow();
#	Line 918 | Line 918 | public class TreeSubMapTest extends JSR1
918		* size returns the correct values
919		*/
920		public void testDescendingSize() {
921	<	NavigableMap map = dmap5();
922	<	NavigableMap empty = dmap0();
923	<	assertEquals(0, empty.size());
924	<	assertEquals(5, map.size());
921	>	NavigableMap<Item,String> map = dmap5();
922	>	NavigableMap<Item,String> empty = dmap0();
923	>	mustEqual(0, empty.size());
924	>	mustEqual(5, map.size());
925		}
926
927		/**
928		* toString contains toString of elements
929		*/
930		public void testDescendingToString() {
931	<	NavigableMap map = dmap5();
931	>	NavigableMap<Item,String> map = dmap5();
932		String s = map.toString();
933		for (int i = 1; i <= 5; ++i) {
934		assertTrue(s.contains(String.valueOf(i)));
#	Line 941 | Line 941 | public class TreeSubMapTest extends JSR1
941		* get(null) of nonempty map throws NPE
942		*/
943		public void testDescendingGet_NullPointerException() {
944	<	NavigableMap c = dmap5();
944	>	NavigableMap<Item,String> c = dmap5();
945		try {
946		c.get(null);
947		shouldThrow();
#	Line 952 | Line 952 | public class TreeSubMapTest extends JSR1
952		* put(null,x) throws NPE
953		*/
954		public void testDescendingPut1_NullPointerException() {
955	<	NavigableMap c = dmap5();
955	>	NavigableMap<Item,String> c = dmap5();
956		try {
957		c.put(null, "whatever");
958		shouldThrow();
#	Line 963 | Line 963 | public class TreeSubMapTest extends JSR1
963		* A deserialized/reserialized map equals original
964		*/
965		public void testDescendingSerialization() throws Exception {
966	<	NavigableMap x = dmap5();
967	<	NavigableMap y = serialClone(x);
966	>	NavigableMap<Item,String> x = dmap5();
967	>	NavigableMap<Item,String> y = serialClone(x);
968
969		assertNotSame(x, y);
970	<	assertEquals(x.size(), y.size());
971	<	assertEquals(x.toString(), y.toString());
972	<	assertEquals(x, y);
973	<	assertEquals(y, x);
970	>	mustEqual(x.size(), y.size());
971	>	mustEqual(x.toString(), y.toString());
972	>	mustEqual(x, y);
973	>	mustEqual(y, x);
974		}
975
976		/**
977		* subMap returns map with keys in requested range
978		*/
979		public void testDescendingSubMapContents() {
980	<	NavigableMap map = dmap5();
981	<	SortedMap sm = map.subMap(m2, m4);
982	<	assertEquals(m2, sm.firstKey());
983	<	assertEquals(m3, sm.lastKey());
984	<	assertEquals(2, sm.size());
985	<	assertFalse(sm.containsKey(m1));
986	<	assertTrue(sm.containsKey(m2));
987	<	assertTrue(sm.containsKey(m3));
988	<	assertFalse(sm.containsKey(m4));
989	<	assertFalse(sm.containsKey(m5));
990	<	Iterator i = sm.keySet().iterator();
991	<	Object k;
992	<	k = (Integer)(i.next());
993	<	assertEquals(m2, k);
994	<	k = (Integer)(i.next());
995	<	assertEquals(m3, k);
980	>	NavigableMap<Item,String> map = dmap5();
981	>	SortedMap<Item,String> sm = map.subMap(minusTwo, minusFour);
982	>	mustEqual(minusTwo, sm.firstKey());
983	>	mustEqual(minusThree, sm.lastKey());
984	>	mustEqual(2, sm.size());
985	>	assertFalse(sm.containsKey(minusOne));
986	>	assertTrue(sm.containsKey(minusTwo));
987	>	assertTrue(sm.containsKey(minusThree));
988	>	assertFalse(sm.containsKey(minusFour));
989	>	assertFalse(sm.containsKey(minusFive));
990	>	Iterator<? extends Item> i = sm.keySet().iterator();
991	>	Item k;
992	>	k = (Item)(i.next());
993	>	mustEqual(minusTwo, k);
994	>	k = (Item)(i.next());
995	>	mustEqual(minusThree, k);
996		assertFalse(i.hasNext());
997	<	Iterator j = sm.keySet().iterator();
997	>	Iterator<? extends Item> j = sm.keySet().iterator();
998		j.next();
999		j.remove();
1000	<	assertFalse(map.containsKey(m2));
1001	<	assertEquals(4, map.size());
1002	<	assertEquals(1, sm.size());
1003	<	assertEquals(m3, sm.firstKey());
1004	<	assertEquals(m3, sm.lastKey());
1005	<	assertEquals("C", sm.remove(m3));
1000	>	assertFalse(map.containsKey(minusTwo));
1001	>	mustEqual(4, map.size());
1002	>	mustEqual(1, sm.size());
1003	>	mustEqual(minusThree, sm.firstKey());
1004	>	mustEqual(minusThree, sm.lastKey());
1005	>	mustEqual("C", sm.remove(minusThree));
1006		assertTrue(sm.isEmpty());
1007	<	assertEquals(3, map.size());
1007	>	mustEqual(3, map.size());
1008		}
1009
1010		public void testDescendingSubMapContents2() {
1011	<	NavigableMap map = dmap5();
1012	<	SortedMap sm = map.subMap(m2, m3);
1013	<	assertEquals(1, sm.size());
1014	<	assertEquals(m2, sm.firstKey());
1015	<	assertEquals(m2, sm.lastKey());
1016	<	assertFalse(sm.containsKey(m1));
1017	<	assertTrue(sm.containsKey(m2));
1018	<	assertFalse(sm.containsKey(m3));
1019	<	assertFalse(sm.containsKey(m4));
1020	<	assertFalse(sm.containsKey(m5));
1021	<	Iterator i = sm.keySet().iterator();
1022	<	Object k;
1023	<	k = (Integer)(i.next());
1024	<	assertEquals(m2, k);
1011	>	NavigableMap<Item,String> map = dmap5();
1012	>	SortedMap<Item,String> sm = map.subMap(minusTwo, minusThree);
1013	>	mustEqual(1, sm.size());
1014	>	mustEqual(minusTwo, sm.firstKey());
1015	>	mustEqual(minusTwo, sm.lastKey());
1016	>	assertFalse(sm.containsKey(minusOne));
1017	>	assertTrue(sm.containsKey(minusTwo));
1018	>	assertFalse(sm.containsKey(minusThree));
1019	>	assertFalse(sm.containsKey(minusFour));
1020	>	assertFalse(sm.containsKey(minusFive));
1021	>	Iterator<? extends Item> i = sm.keySet().iterator();
1022	>	Item k;
1023	>	k = (Item)(i.next());
1024	>	mustEqual(minusTwo, k);
1025		assertFalse(i.hasNext());
1026	<	Iterator j = sm.keySet().iterator();
1026	>	Iterator<? extends Item> j = sm.keySet().iterator();
1027		j.next();
1028		j.remove();
1029	<	assertFalse(map.containsKey(m2));
1030	<	assertEquals(4, map.size());
1031	<	assertEquals(0, sm.size());
1029	>	assertFalse(map.containsKey(minusTwo));
1030	>	mustEqual(4, map.size());
1031	>	mustEqual(0, sm.size());
1032		assertTrue(sm.isEmpty());
1033	<	assertSame(sm.remove(m3), null);
1034	<	assertEquals(4, map.size());
1033	>	assertNull(sm.remove(minusThree));
1034	>	mustEqual(4, map.size());
1035		}
1036
1037		/**
1038		* headMap returns map with keys in requested range
1039		*/
1040		public void testDescendingHeadMapContents() {
1041	<	NavigableMap map = dmap5();
1042	<	SortedMap sm = map.headMap(m4);
1043	<	assertTrue(sm.containsKey(m1));
1044	<	assertTrue(sm.containsKey(m2));
1045	<	assertTrue(sm.containsKey(m3));
1046	<	assertFalse(sm.containsKey(m4));
1047	<	assertFalse(sm.containsKey(m5));
1048	<	Iterator i = sm.keySet().iterator();
1049	<	Object k;
1050	<	k = (Integer)(i.next());
1051	<	assertEquals(m1, k);
1052	<	k = (Integer)(i.next());
1053	<	assertEquals(m2, k);
1054	<	k = (Integer)(i.next());
1055	<	assertEquals(m3, k);
1041	>	NavigableMap<Item,String> map = dmap5();
1042	>	SortedMap<Item,String> sm = map.headMap(minusFour);
1043	>	assertTrue(sm.containsKey(minusOne));
1044	>	assertTrue(sm.containsKey(minusTwo));
1045	>	assertTrue(sm.containsKey(minusThree));
1046	>	assertFalse(sm.containsKey(minusFour));
1047	>	assertFalse(sm.containsKey(minusFive));
1048	>	Iterator<? extends Item> i = sm.keySet().iterator();
1049	>	Item k;
1050	>	k = (Item)(i.next());
1051	>	mustEqual(minusOne, k);
1052	>	k = (Item)(i.next());
1053	>	mustEqual(minusTwo, k);
1054	>	k = (Item)(i.next());
1055	>	mustEqual(minusThree, k);
1056		assertFalse(i.hasNext());
1057		sm.clear();
1058		assertTrue(sm.isEmpty());
1059	<	assertEquals(2, map.size());
1060	<	assertEquals(m4, map.firstKey());
1059	>	mustEqual(2, map.size());
1060	>	mustEqual(minusFour, map.firstKey());
1061		}
1062
1063		/**
1064		* headMap returns map with keys in requested range
1065		*/
1066		public void testDescendingTailMapContents() {
1067	<	NavigableMap map = dmap5();
1068	<	SortedMap sm = map.tailMap(m2);
1069	<	assertFalse(sm.containsKey(m1));
1070	<	assertTrue(sm.containsKey(m2));
1071	<	assertTrue(sm.containsKey(m3));
1072	<	assertTrue(sm.containsKey(m4));
1073	<	assertTrue(sm.containsKey(m5));
1074	<	Iterator i = sm.keySet().iterator();
1075	<	Object k;
1076	<	k = (Integer)(i.next());
1077	<	assertEquals(m2, k);
1078	<	k = (Integer)(i.next());
1079	<	assertEquals(m3, k);
1080	<	k = (Integer)(i.next());
1081	<	assertEquals(m4, k);
1082	<	k = (Integer)(i.next());
1083	<	assertEquals(m5, k);
1067	>	NavigableMap<Item,String> map = dmap5();
1068	>	SortedMap<Item,String> sm = map.tailMap(minusTwo);
1069	>	assertFalse(sm.containsKey(minusOne));
1070	>	assertTrue(sm.containsKey(minusTwo));
1071	>	assertTrue(sm.containsKey(minusThree));
1072	>	assertTrue(sm.containsKey(minusFour));
1073	>	assertTrue(sm.containsKey(minusFive));
1074	>	Iterator<? extends Item> i = sm.keySet().iterator();
1075	>	Item k;
1076	>	k = (Item)(i.next());
1077	>	mustEqual(minusTwo, k);
1078	>	k = (Item)(i.next());
1079	>	mustEqual(minusThree, k);
1080	>	k = (Item)(i.next());
1081	>	mustEqual(minusFour, k);
1082	>	k = (Item)(i.next());
1083	>	mustEqual(minusFive, k);
1084		assertFalse(i.hasNext());
1085
1086	<	Iterator ei = sm.entrySet().iterator();
1087	<	Map.Entry e;
1088	<	e = (Map.Entry)(ei.next());
1089	<	assertEquals(m2, e.getKey());
1090	<	assertEquals("B", e.getValue());
1091	<	e = (Map.Entry)(ei.next());
1092	<	assertEquals(m3, e.getKey());
1093	<	assertEquals("C", e.getValue());
1094	<	e = (Map.Entry)(ei.next());
1095	<	assertEquals(m4, e.getKey());
1096	<	assertEquals("D", e.getValue());
1097	<	e = (Map.Entry)(ei.next());
1098	<	assertEquals(m5, e.getKey());
1099	<	assertEquals("E", e.getValue());
1086	>	Iterator<Map.Entry<Item,String>> ei = sm.entrySet().iterator();
1087	>	Map.Entry<Item,String> e;
1088	>	e = (ei.next());
1089	>	mustEqual(minusTwo, e.getKey());
1090	>	mustEqual("B", e.getValue());
1091	>	e = (ei.next());
1092	>	mustEqual(minusThree, e.getKey());
1093	>	mustEqual("C", e.getValue());
1094	>	e = (ei.next());
1095	>	mustEqual(minusFour, e.getKey());
1096	>	mustEqual("D", e.getValue());
1097	>	e = (ei.next());
1098	>	mustEqual(minusFive, e.getKey());
1099	>	mustEqual("E", e.getValue());
1100		assertFalse(i.hasNext());
1101
1102	<	SortedMap ssm = sm.tailMap(m4);
1103	<	assertEquals(m4, ssm.firstKey());
1104	<	assertEquals(m5, ssm.lastKey());
1105	<	assertEquals("D", ssm.remove(m4));
1106	<	assertEquals(1, ssm.size());
1107	<	assertEquals(3, sm.size());
1108	<	assertEquals(4, map.size());
1102	>	SortedMap<Item,String> ssm = sm.tailMap(minusFour);
1103	>	mustEqual(minusFour, ssm.firstKey());
1104	>	mustEqual(minusFive, ssm.lastKey());
1105	>	mustEqual("D", ssm.remove(minusFour));
1106	>	mustEqual(1, ssm.size());
1107	>	mustEqual(3, sm.size());
1108	>	mustEqual(4, map.size());
1109		}
1110
1111		}

Diff Legend

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