ViewVC Help

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

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

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

#	Line 27 | Line 27 | public class ConcurrentSkipListSubMapTes
27		}
28
29		/**
30	<	* Returns a new map from Integers 1-5 to Strings "A"-"E".
30	>	* Returns a new map from Items 1-5 to Strings "A"-"E".
31		*/
32	<	private static ConcurrentNavigableMap map5() {
33	<	ConcurrentSkipListMap map = new ConcurrentSkipListMap();
32	>	private static ConcurrentNavigableMap<Item,String> map5() {
33	>	ConcurrentSkipListMap<Item,String>map = new ConcurrentSkipListMap<Item,String>();
34		assertTrue(map.isEmpty());
35		map.put(zero, "Z");
36		map.put(one, "A");
#	Line 40 | Line 40 | public class ConcurrentSkipListSubMapTes
40		map.put(four, "D");
41		map.put(seven, "F");
42		assertFalse(map.isEmpty());
43	<	assertEquals(7, map.size());
43	>	mustEqual(7, map.size());
44		return map.subMap(one, true, seven, false);
45		}
46
47		/**
48	<	* Returns a new map from Integers -5 to -1 to Strings "A"-"E".
48	>	* Returns a new map from Items -5 to -1 to Strings "A"-"E".
49		*/
50	<	private static ConcurrentNavigableMap dmap5() {
51	<	ConcurrentSkipListMap map = new ConcurrentSkipListMap();
50	>	private static ConcurrentNavigableMap<Item,String> dmap5() {
51	>	ConcurrentSkipListMap<Item,String>map = new ConcurrentSkipListMap<Item,String>();
52		assertTrue(map.isEmpty());
53	<	map.put(m1, "A");
54	<	map.put(m5, "E");
55	<	map.put(m3, "C");
56	<	map.put(m2, "B");
57	<	map.put(m4, "D");
53	>	map.put(minusOne, "A");
54	>	map.put(minusFive, "E");
55	>	map.put(minusThree, "C");
56	>	map.put(minusTwo, "B");
57	>	map.put(minusFour, "D");
58		assertFalse(map.isEmpty());
59	<	assertEquals(5, map.size());
59	>	mustEqual(5, map.size());
60		return map.descendingMap();
61		}
62
63	<	private static ConcurrentNavigableMap map0() {
64	<	ConcurrentSkipListMap map = new ConcurrentSkipListMap();
63	>	private static ConcurrentNavigableMap<Item,String> map0() {
64	>	ConcurrentSkipListMap<Item,String>map = new ConcurrentSkipListMap<Item,String>();
65		assertTrue(map.isEmpty());
66		return map.tailMap(one, true);
67		}
68
69	<	private static ConcurrentNavigableMap dmap0() {
70	<	ConcurrentSkipListMap map = new ConcurrentSkipListMap();
69	>	private static ConcurrentNavigableMap<Item,String> dmap0() {
70	>	ConcurrentSkipListMap<Item,String>map = new ConcurrentSkipListMap<Item,String>();
71		assertTrue(map.isEmpty());
72		return map;
73		}
#	Line 76 | Line 76 | public class ConcurrentSkipListSubMapTes
76		* clear removes all pairs
77		*/
78		public void testClear() {
79	<	ConcurrentNavigableMap map = map5();
79	>	ConcurrentNavigableMap<Item,String> map = map5();
80		map.clear();
81	<	assertEquals(0, map.size());
81	>	mustEqual(0, map.size());
82		}
83
84		/**
85		* Maps with same contents are equal
86		*/
87		public void testEquals() {
88	<	ConcurrentNavigableMap map1 = map5();
89	<	ConcurrentNavigableMap map2 = map5();
90	<	assertEquals(map1, map2);
91	<	assertEquals(map2, map1);
88	>	ConcurrentNavigableMap<Item,String> map1 = map5();
89	>	ConcurrentNavigableMap<Item,String> map2 = map5();
90	>	mustEqual(map1, map2);
91	>	mustEqual(map2, map1);
92		map1.clear();
93		assertFalse(map1.equals(map2));
94		assertFalse(map2.equals(map1));
#	Line 98 | Line 98 | public class ConcurrentSkipListSubMapTes
98		* containsKey returns true for contained key
99		*/
100		public void testContainsKey() {
101	<	ConcurrentNavigableMap map = map5();
101	>	ConcurrentNavigableMap<Item,String> map = map5();
102		assertTrue(map.containsKey(one));
103		assertFalse(map.containsKey(zero));
104		}
#	Line 107 | Line 107 | public class ConcurrentSkipListSubMapTes
107		* containsValue returns true for held values
108		*/
109		public void testContainsValue() {
110	<	ConcurrentNavigableMap map = map5();
110	>	ConcurrentNavigableMap<Item,String> map = map5();
111		assertTrue(map.containsValue("A"));
112		assertFalse(map.containsValue("Z"));
113		}
#	Line 117 | Line 117 | public class ConcurrentSkipListSubMapTes
117		* or null if not present
118		*/
119		public void testGet() {
120	<	ConcurrentNavigableMap map = map5();
121	<	assertEquals("A", (String)map.get(one));
122	<	ConcurrentNavigableMap empty = map0();
120	>	ConcurrentNavigableMap<Item,String> map = map5();
121	>	mustEqual("A", map.get(one));
122	>	ConcurrentNavigableMap<Item,String> empty = map0();
123		assertNull(empty.get(one));
124		}
125
#	Line 127 | Line 127 | public class ConcurrentSkipListSubMapTes
127		* isEmpty is true of empty map and false for non-empty
128		*/
129		public void testIsEmpty() {
130	<	ConcurrentNavigableMap empty = map0();
131	<	ConcurrentNavigableMap map = map5();
130	>	ConcurrentNavigableMap<Item,String> empty = map0();
131	>	ConcurrentNavigableMap<Item,String> map = map5();
132		assertTrue(empty.isEmpty());
133		assertFalse(map.isEmpty());
134		}
#	Line 137 | Line 137 | public class ConcurrentSkipListSubMapTes
137		* firstKey returns first key
138		*/
139		public void testFirstKey() {
140	<	ConcurrentNavigableMap map = map5();
141	<	assertEquals(one, map.firstKey());
140	>	ConcurrentNavigableMap<Item,String> map = map5();
141	>	mustEqual(one, map.firstKey());
142		}
143
144		/**
145		* lastKey returns last key
146		*/
147		public void testLastKey() {
148	<	ConcurrentNavigableMap map = map5();
149	<	assertEquals(five, map.lastKey());
148	>	ConcurrentNavigableMap<Item,String> map = map5();
149	>	mustEqual(five, map.lastKey());
150		}
151
152		/**
153		* keySet returns a Set containing all the keys
154		*/
155		public void testKeySet() {
156	<	ConcurrentNavigableMap map = map5();
157	<	Set s = map.keySet();
158	<	assertEquals(5, s.size());
159	<	assertTrue(s.contains(one));
160	<	assertTrue(s.contains(two));
161	<	assertTrue(s.contains(three));
162	<	assertTrue(s.contains(four));
163	<	assertTrue(s.contains(five));
156	>	ConcurrentNavigableMap<Item,String> map = map5();
157	>	Set<Item> s = map.keySet();
158	>	mustEqual(5, s.size());
159	>	mustContain(s, one);
160	>	mustContain(s, two);
161	>	mustContain(s, three);
162	>	mustContain(s, four);
163	>	mustContain(s, five);
164		}
165
166		/**
167		* keySet is ordered
168		*/
169		public void testKeySetOrder() {
170	<	ConcurrentNavigableMap map = map5();
171	<	Set s = map.keySet();
172	<	Iterator i = s.iterator();
173	<	Integer last = (Integer)i.next();
174	<	assertEquals(last, one);
170	>	ConcurrentNavigableMap<Item,String> map = map5();
171	>	Set<Item> s = map.keySet();
172	>	Iterator<? extends Item> i = s.iterator();
173	>	Item last = i.next();
174	>	mustEqual(last, one);
175		while (i.hasNext()) {
176	<	Integer k = (Integer)i.next();
176	>	Item k = i.next();
177		assertTrue(last.compareTo(k) < 0);
178		last = k;
179		}
#	Line 183 | Line 183 | public class ConcurrentSkipListSubMapTes
183		* values collection contains all values
184		*/
185		public void testValues() {
186	<	ConcurrentNavigableMap map = map5();
187	<	Collection s = map.values();
188	<	assertEquals(5, s.size());
186	>	ConcurrentNavigableMap<Item,String> map = map5();
187	>	Collection<String> s = map.values();
188	>	mustEqual(5, s.size());
189		assertTrue(s.contains("A"));
190		assertTrue(s.contains("B"));
191		assertTrue(s.contains("C"));
#	Line 197 | Line 197 | public class ConcurrentSkipListSubMapTes
197		* keySet.toArray returns contains all keys
198		*/
199		public void testKeySetToArray() {
200	<	ConcurrentNavigableMap map = map5();
201	<	Set s = map.keySet();
200	>	ConcurrentNavigableMap<Item,String> map = map5();
201	>	Set<Item> s = map.keySet();
202		Object[] ar = s.toArray();
203		assertTrue(s.containsAll(Arrays.asList(ar)));
204	<	assertEquals(5, ar.length);
205	<	ar[0] = m10;
204	>	mustEqual(5, ar.length);
205	>	ar[0] = minusTen;
206		assertFalse(s.containsAll(Arrays.asList(ar)));
207		}
208
#	Line 210 | Line 210 | public class ConcurrentSkipListSubMapTes
210		* descendingkeySet.toArray returns contains all keys
211		*/
212		public void testDescendingKeySetToArray() {
213	<	ConcurrentNavigableMap map = map5();
214	<	Set s = map.descendingKeySet();
215	<	Object[] ar = s.toArray();
216	<	assertEquals(5, ar.length);
213	>	ConcurrentNavigableMap<Item,String> map = map5();
214	>	Set<Item> s = map.descendingKeySet();
215	>	Item[] ar = s.toArray(new Item[0]);
216	>	mustEqual(5, ar.length);
217		assertTrue(s.containsAll(Arrays.asList(ar)));
218	<	ar[0] = m10;
218	>	ar[0] = minusTen;
219		assertFalse(s.containsAll(Arrays.asList(ar)));
220		}
221
#	Line 223 | Line 223 | public class ConcurrentSkipListSubMapTes
223		* Values.toArray contains all values
224		*/
225		public void testValuesToArray() {
226	<	ConcurrentNavigableMap map = map5();
227	<	Collection v = map.values();
228	<	Object[] ar = v.toArray();
229	<	ArrayList s = new ArrayList(Arrays.asList(ar));
230	<	assertEquals(5, ar.length);
226	>	ConcurrentNavigableMap<Item,String> map = map5();
227	>	Collection<String> v = map.values();
228	>	String[] ar = v.toArray(new String[0]);
229	>	ArrayList<String> s = new ArrayList<String>(Arrays.asList(ar));
230	>	mustEqual(5, ar.length);
231		assertTrue(s.contains("A"));
232		assertTrue(s.contains("B"));
233		assertTrue(s.contains("C"));
#	Line 239 | Line 239 | public class ConcurrentSkipListSubMapTes
239		* entrySet contains all pairs
240		*/
241		public void testEntrySet() {
242	<	ConcurrentNavigableMap map = map5();
243	<	Set s = map.entrySet();
244	<	assertEquals(5, s.size());
245	<	Iterator it = s.iterator();
242	>	ConcurrentNavigableMap<Item,String> map = map5();
243	>	Set<Map.Entry<Item,String>> s = map.entrySet();
244	>	mustEqual(5, s.size());
245	>	Iterator<Map.Entry<Item,String>> it = s.iterator();
246		while (it.hasNext()) {
247	<	Map.Entry e = (Map.Entry) it.next();
247	>	Map.Entry<Item,String> e = it.next();
248		assertTrue(
249		(e.getKey().equals(one) && e.getValue().equals("A")) ||
250		(e.getKey().equals(two) && e.getValue().equals("B")) ||
#	Line 258 | Line 258 | public class ConcurrentSkipListSubMapTes
258		* putAll adds all key-value pairs from the given map
259		*/
260		public void testPutAll() {
261	<	ConcurrentNavigableMap empty = map0();
262	<	ConcurrentNavigableMap map = map5();
261	>	ConcurrentNavigableMap<Item,String> empty = map0();
262	>	ConcurrentNavigableMap<Item,String> map = map5();
263		empty.putAll(map);
264	<	assertEquals(5, empty.size());
264	>	mustEqual(5, empty.size());
265		assertTrue(empty.containsKey(one));
266		assertTrue(empty.containsKey(two));
267		assertTrue(empty.containsKey(three));
#	Line 273 | Line 273 | public class ConcurrentSkipListSubMapTes
273		* putIfAbsent works when the given key is not present
274		*/
275		public void testPutIfAbsent() {
276	<	ConcurrentNavigableMap map = map5();
276	>	ConcurrentNavigableMap<Item,String> map = map5();
277		map.putIfAbsent(six, "Z");
278		assertTrue(map.containsKey(six));
279		}
#	Line 282 | Line 282 | public class ConcurrentSkipListSubMapTes
282		* putIfAbsent does not add the pair if the key is already present
283		*/
284		public void testPutIfAbsent2() {
285	<	ConcurrentNavigableMap map = map5();
286	<	assertEquals("A", map.putIfAbsent(one, "Z"));
285	>	ConcurrentNavigableMap<Item,String> map = map5();
286	>	mustEqual("A", map.putIfAbsent(one, "Z"));
287		}
288
289		/**
290		* replace fails when the given key is not present
291		*/
292		public void testReplace() {
293	<	ConcurrentNavigableMap map = map5();
293	>	ConcurrentNavigableMap<Item,String> map = map5();
294		assertNull(map.replace(six, "Z"));
295		assertFalse(map.containsKey(six));
296		}
#	Line 299 | Line 299 | public class ConcurrentSkipListSubMapTes
299		* replace succeeds if the key is already present
300		*/
301		public void testReplace2() {
302	<	ConcurrentNavigableMap map = map5();
302	>	ConcurrentNavigableMap<Item,String> map = map5();
303		assertNotNull(map.replace(one, "Z"));
304	<	assertEquals("Z", map.get(one));
304	>	mustEqual("Z", map.get(one));
305		}
306
307		/**
308		* replace value fails when the given key not mapped to expected value
309		*/
310		public void testReplaceValue() {
311	<	ConcurrentNavigableMap map = map5();
312	<	assertEquals("A", map.get(one));
311	>	ConcurrentNavigableMap<Item,String> map = map5();
312	>	mustEqual("A", map.get(one));
313		assertFalse(map.replace(one, "Z", "Z"));
314	<	assertEquals("A", map.get(one));
314	>	mustEqual("A", map.get(one));
315		}
316
317		/**
318		* replace value succeeds when the given key mapped to expected value
319		*/
320		public void testReplaceValue2() {
321	<	ConcurrentNavigableMap map = map5();
322	<	assertEquals("A", map.get(one));
321	>	ConcurrentNavigableMap<Item,String> map = map5();
322	>	mustEqual("A", map.get(one));
323		assertTrue(map.replace(one, "A", "Z"));
324	<	assertEquals("Z", map.get(one));
324	>	mustEqual("Z", map.get(one));
325		}
326
327		/**
328		* remove removes the correct key-value pair from the map
329		*/
330		public void testRemove() {
331	<	ConcurrentNavigableMap map = map5();
331	>	ConcurrentNavigableMap<Item,String> map = map5();
332		map.remove(five);
333	<	assertEquals(4, map.size());
333	>	mustEqual(4, map.size());
334		assertFalse(map.containsKey(five));
335		}
336
#	Line 338 | Line 338 | public class ConcurrentSkipListSubMapTes
338		* remove(key,value) removes only if pair present
339		*/
340		public void testRemove2() {
341	<	ConcurrentNavigableMap map = map5();
341	>	ConcurrentNavigableMap<Item,String> map = map5();
342		assertTrue(map.containsKey(five));
343	<	assertEquals("E", map.get(five));
343	>	mustEqual("E", map.get(five));
344		map.remove(five, "E");
345	<	assertEquals(4, map.size());
345	>	mustEqual(4, map.size());
346		assertFalse(map.containsKey(five));
347		map.remove(four, "A");
348	<	assertEquals(4, map.size());
348	>	mustEqual(4, map.size());
349		assertTrue(map.containsKey(four));
350		}
351
#	Line 353 | Line 353 | public class ConcurrentSkipListSubMapTes
353		* lowerEntry returns preceding entry.
354		*/
355		public void testLowerEntry() {
356	<	ConcurrentNavigableMap map = map5();
357	<	Map.Entry e1 = map.lowerEntry(three);
358	<	assertEquals(two, e1.getKey());
356	>	ConcurrentNavigableMap<Item,String> map = map5();
357	>	Map.Entry<Item,String> e1 = map.lowerEntry(three);
358	>	mustEqual(two, e1.getKey());
359
360	<	Map.Entry e2 = map.lowerEntry(six);
361	<	assertEquals(five, e2.getKey());
360	>	Map.Entry<Item,String> e2 = map.lowerEntry(six);
361	>	mustEqual(five, e2.getKey());
362
363	<	Map.Entry e3 = map.lowerEntry(one);
363	>	Map.Entry<Item,String> e3 = map.lowerEntry(one);
364		assertNull(e3);
365
366	<	Map.Entry e4 = map.lowerEntry(zero);
366	>	Map.Entry<Item,String> e4 = map.lowerEntry(zero);
367		assertNull(e4);
368		}
369
#	Line 371 | Line 371 | public class ConcurrentSkipListSubMapTes
371		* higherEntry returns next entry.
372		*/
373		public void testHigherEntry() {
374	<	ConcurrentNavigableMap map = map5();
375	<	Map.Entry e1 = map.higherEntry(three);
376	<	assertEquals(four, e1.getKey());
374	>	ConcurrentNavigableMap<Item,String> map = map5();
375	>	Map.Entry<Item,String> e1 = map.higherEntry(three);
376	>	mustEqual(four, e1.getKey());
377
378	<	Map.Entry e2 = map.higherEntry(zero);
379	<	assertEquals(one, e2.getKey());
378	>	Map.Entry<Item,String> e2 = map.higherEntry(zero);
379	>	mustEqual(one, e2.getKey());
380
381	<	Map.Entry e3 = map.higherEntry(five);
381	>	Map.Entry<Item,String> e3 = map.higherEntry(five);
382		assertNull(e3);
383
384	<	Map.Entry e4 = map.higherEntry(six);
384	>	Map.Entry<Item,String> e4 = map.higherEntry(six);
385		assertNull(e4);
386		}
387
#	Line 389 | Line 389 | public class ConcurrentSkipListSubMapTes
389		* floorEntry returns preceding entry.
390		*/
391		public void testFloorEntry() {
392	<	ConcurrentNavigableMap map = map5();
393	<	Map.Entry e1 = map.floorEntry(three);
394	<	assertEquals(three, e1.getKey());
392	>	ConcurrentNavigableMap<Item,String> map = map5();
393	>	Map.Entry<Item,String> e1 = map.floorEntry(three);
394	>	mustEqual(three, e1.getKey());
395
396	<	Map.Entry e2 = map.floorEntry(six);
397	<	assertEquals(five, e2.getKey());
396	>	Map.Entry<Item,String> e2 = map.floorEntry(six);
397	>	mustEqual(five, e2.getKey());
398
399	<	Map.Entry e3 = map.floorEntry(one);
400	<	assertEquals(one, e3.getKey());
399	>	Map.Entry<Item,String> e3 = map.floorEntry(one);
400	>	mustEqual(one, e3.getKey());
401
402	<	Map.Entry e4 = map.floorEntry(zero);
402	>	Map.Entry<Item,String> e4 = map.floorEntry(zero);
403		assertNull(e4);
404		}
405
#	Line 407 | Line 407 | public class ConcurrentSkipListSubMapTes
407		* ceilingEntry returns next entry.
408		*/
409		public void testCeilingEntry() {
410	<	ConcurrentNavigableMap map = map5();
411	<	Map.Entry e1 = map.ceilingEntry(three);
412	<	assertEquals(three, e1.getKey());
410	>	ConcurrentNavigableMap<Item,String> map = map5();
411	>	Map.Entry<Item,String> e1 = map.ceilingEntry(three);
412	>	mustEqual(three, e1.getKey());
413
414	<	Map.Entry e2 = map.ceilingEntry(zero);
415	<	assertEquals(one, e2.getKey());
414	>	Map.Entry<Item,String> e2 = map.ceilingEntry(zero);
415	>	mustEqual(one, e2.getKey());
416
417	<	Map.Entry e3 = map.ceilingEntry(five);
418	<	assertEquals(five, e3.getKey());
417	>	Map.Entry<Item,String> e3 = map.ceilingEntry(five);
418	>	mustEqual(five, e3.getKey());
419
420	<	Map.Entry e4 = map.ceilingEntry(six);
420	>	Map.Entry<Item,String> e4 = map.ceilingEntry(six);
421		assertNull(e4);
422		}
423
#	Line 425 | Line 425 | public class ConcurrentSkipListSubMapTes
425		* pollFirstEntry returns entries in order
426		*/
427		public void testPollFirstEntry() {
428	<	ConcurrentNavigableMap map = map5();
429	<	Map.Entry e = map.pollFirstEntry();
430	<	assertEquals(one, e.getKey());
431	<	assertEquals("A", e.getValue());
428	>	ConcurrentNavigableMap<Item,String> map = map5();
429	>	Map.Entry<Item,String> e = map.pollFirstEntry();
430	>	mustEqual(one, e.getKey());
431	>	mustEqual("A", e.getValue());
432		e = map.pollFirstEntry();
433	<	assertEquals(two, e.getKey());
433	>	mustEqual(two, e.getKey());
434		map.put(one, "A");
435		e = map.pollFirstEntry();
436	<	assertEquals(one, e.getKey());
437	<	assertEquals("A", e.getValue());
436	>	mustEqual(one, e.getKey());
437	>	mustEqual("A", e.getValue());
438		e = map.pollFirstEntry();
439	<	assertEquals(three, e.getKey());
439	>	mustEqual(three, e.getKey());
440		map.remove(four);
441		e = map.pollFirstEntry();
442	<	assertEquals(five, e.getKey());
442	>	mustEqual(five, e.getKey());
443		try {
444		e.setValue("A");
445		shouldThrow();
#	Line 452 | Line 452 | public class ConcurrentSkipListSubMapTes
452		* pollLastEntry returns entries in order
453		*/
454		public void testPollLastEntry() {
455	<	ConcurrentNavigableMap map = map5();
456	<	Map.Entry e = map.pollLastEntry();
457	<	assertEquals(five, e.getKey());
458	<	assertEquals("E", e.getValue());
455	>	ConcurrentNavigableMap<Item,String> map = map5();
456	>	Map.Entry<Item,String> e = map.pollLastEntry();
457	>	mustEqual(five, e.getKey());
458	>	mustEqual("E", e.getValue());
459		e = map.pollLastEntry();
460	<	assertEquals(four, e.getKey());
460	>	mustEqual(four, e.getKey());
461		map.put(five, "E");
462		e = map.pollLastEntry();
463	<	assertEquals(five, e.getKey());
464	<	assertEquals("E", e.getValue());
463	>	mustEqual(five, e.getKey());
464	>	mustEqual("E", e.getValue());
465		e = map.pollLastEntry();
466	<	assertEquals(three, e.getKey());
466	>	mustEqual(three, e.getKey());
467		map.remove(two);
468		e = map.pollLastEntry();
469	<	assertEquals(one, e.getKey());
469	>	mustEqual(one, e.getKey());
470		try {
471		e.setValue("E");
472		shouldThrow();
#	Line 479 | Line 479 | public class ConcurrentSkipListSubMapTes
479		* size returns the correct values
480		*/
481		public void testSize() {
482	<	ConcurrentNavigableMap map = map5();
483	<	ConcurrentNavigableMap empty = map0();
484	<	assertEquals(0, empty.size());
485	<	assertEquals(5, map.size());
482	>	ConcurrentNavigableMap<Item,String> map = map5();
483	>	ConcurrentNavigableMap<Item,String> empty = map0();
484	>	mustEqual(0, empty.size());
485	>	mustEqual(5, map.size());
486		}
487
488		/**
489		* toString contains toString of elements
490		*/
491		public void testToString() {
492	<	ConcurrentNavigableMap map = map5();
492	>	ConcurrentNavigableMap<Item,String> map = map5();
493		String s = map.toString();
494		for (int i = 1; i <= 5; ++i) {
495		assertTrue(s.contains(String.valueOf(i)));
#	Line 503 | Line 503 | public class ConcurrentSkipListSubMapTes
503		*/
504		public void testGet_NullPointerException() {
505		try {
506	<	ConcurrentNavigableMap c = map5();
506	>	ConcurrentNavigableMap<Item,String> c = map5();
507		c.get(null);
508		shouldThrow();
509		} catch (NullPointerException success) {}
#	Line 514 | Line 514 | public class ConcurrentSkipListSubMapTes
514		*/
515		public void testContainsKey_NullPointerException() {
516		try {
517	<	ConcurrentNavigableMap c = map5();
517	>	ConcurrentNavigableMap<Item,String> c = map5();
518		c.containsKey(null);
519		shouldThrow();
520		} catch (NullPointerException success) {}
#	Line 525 | Line 525 | public class ConcurrentSkipListSubMapTes
525		*/
526		public void testContainsValue_NullPointerException() {
527		try {
528	<	ConcurrentNavigableMap c = map0();
528	>	ConcurrentNavigableMap<Item,String> c = map0();
529		c.containsValue(null);
530		shouldThrow();
531		} catch (NullPointerException success) {}
#	Line 536 | Line 536 | public class ConcurrentSkipListSubMapTes
536		*/
537		public void testPut1_NullPointerException() {
538		try {
539	<	ConcurrentNavigableMap c = map5();
539	>	ConcurrentNavigableMap<Item,String> c = map5();
540		c.put(null, "whatever");
541		shouldThrow();
542		} catch (NullPointerException success) {}
#	Line 547 | Line 547 | public class ConcurrentSkipListSubMapTes
547		*/
548		public void testPutIfAbsent1_NullPointerException() {
549		try {
550	<	ConcurrentNavigableMap c = map5();
550	>	ConcurrentNavigableMap<Item,String> c = map5();
551		c.putIfAbsent(null, "whatever");
552		shouldThrow();
553		} catch (NullPointerException success) {}
#	Line 558 | Line 558 | public class ConcurrentSkipListSubMapTes
558		*/
559		public void testReplace_NullPointerException() {
560		try {
561	<	ConcurrentNavigableMap c = map5();
562	<	c.replace(null, "whatever");
561	>	ConcurrentNavigableMap<Item,String> c = map5();
562	>	c.replace(null, "A");
563		shouldThrow();
564		} catch (NullPointerException success) {}
565		}
#	Line 569 | Line 569 | public class ConcurrentSkipListSubMapTes
569		*/
570		public void testReplaceValue_NullPointerException() {
571		try {
572	<	ConcurrentNavigableMap c = map5();
573	<	c.replace(null, one, "whatever");
572	>	ConcurrentNavigableMap<Item,String> c = map5();
573	>	c.replace(null, "A", "B");
574		shouldThrow();
575		} catch (NullPointerException success) {}
576		}
#	Line 580 | Line 580 | public class ConcurrentSkipListSubMapTes
580		*/
581		public void testRemove1_NullPointerException() {
582		try {
583	<	ConcurrentNavigableMap c = map5();
583	>	ConcurrentNavigableMap<Item,String> c = map5();
584		c.remove(null);
585		shouldThrow();
586		} catch (NullPointerException success) {}
#	Line 591 | Line 591 | public class ConcurrentSkipListSubMapTes
591		*/
592		public void testRemove2_NullPointerException() {
593		try {
594	<	ConcurrentNavigableMap c = map5();
594	>	ConcurrentNavigableMap<Item,String> c = map5();
595		c.remove(null, "whatever");
596		shouldThrow();
597		} catch (NullPointerException success) {}
#	Line 601 | Line 601 | public class ConcurrentSkipListSubMapTes
601		* A deserialized/reserialized map equals original
602		*/
603		public void testSerialization() throws Exception {
604	<	NavigableMap x = map5();
605	<	NavigableMap y = serialClone(x);
604	>	NavigableMap<Item,String> x = map5();
605	>	NavigableMap<Item,String> y = serialClone(x);
606
607		assertNotSame(x, y);
608	<	assertEquals(x.size(), y.size());
609	<	assertEquals(x.toString(), y.toString());
610	<	assertEquals(x, y);
611	<	assertEquals(y, x);
608	>	mustEqual(x.size(), y.size());
609	>	mustEqual(x.toString(), y.toString());
610	>	mustEqual(x, y);
611	>	mustEqual(y, x);
612		}
613
614		/**
615		* subMap returns map with keys in requested range
616		*/
617		public void testSubMapContents() {
618	<	ConcurrentNavigableMap map = map5();
619	<	SortedMap sm = map.subMap(two, four);
620	<	assertEquals(two, sm.firstKey());
621	<	assertEquals(three, sm.lastKey());
622	<	assertEquals(2, sm.size());
618	>	ConcurrentNavigableMap<Item,String> map = map5();
619	>	SortedMap<Item,String> sm = map.subMap(two, four);
620	>	mustEqual(two, sm.firstKey());
621	>	mustEqual(three, sm.lastKey());
622	>	mustEqual(2, sm.size());
623		assertFalse(sm.containsKey(one));
624		assertTrue(sm.containsKey(two));
625		assertTrue(sm.containsKey(three));
626		assertFalse(sm.containsKey(four));
627		assertFalse(sm.containsKey(five));
628	<	Iterator i = sm.keySet().iterator();
629	<	Object k;
630	<	k = (Integer)(i.next());
631	<	assertEquals(two, k);
632	<	k = (Integer)(i.next());
633	<	assertEquals(three, k);
628	>	Iterator<? extends Item> i = sm.keySet().iterator();
629	>	Item k;
630	>	k = (Item)(i.next());
631	>	mustEqual(two, k);
632	>	k = (Item)(i.next());
633	>	mustEqual(three, k);
634		assertFalse(i.hasNext());
635	<	Iterator j = sm.keySet().iterator();
635	>	Iterator<? extends Item> j = sm.keySet().iterator();
636		j.next();
637		j.remove();
638		assertFalse(map.containsKey(two));
639	<	assertEquals(4, map.size());
640	<	assertEquals(1, sm.size());
641	<	assertEquals(three, sm.firstKey());
642	<	assertEquals(three, sm.lastKey());
643	<	assertEquals("C", sm.remove(three));
639	>	mustEqual(4, map.size());
640	>	mustEqual(1, sm.size());
641	>	mustEqual(three, sm.firstKey());
642	>	mustEqual(three, sm.lastKey());
643	>	mustEqual("C", sm.remove(three));
644		assertTrue(sm.isEmpty());
645	<	assertEquals(3, map.size());
645	>	mustEqual(3, map.size());
646		}
647
648		public void testSubMapContents2() {
649	<	ConcurrentNavigableMap map = map5();
650	<	SortedMap sm = map.subMap(two, three);
651	<	assertEquals(1, sm.size());
652	<	assertEquals(two, sm.firstKey());
653	<	assertEquals(two, sm.lastKey());
649	>	ConcurrentNavigableMap<Item,String> map = map5();
650	>	SortedMap<Item,String> sm = map.subMap(two, three);
651	>	mustEqual(1, sm.size());
652	>	mustEqual(two, sm.firstKey());
653	>	mustEqual(two, sm.lastKey());
654		assertFalse(sm.containsKey(one));
655		assertTrue(sm.containsKey(two));
656		assertFalse(sm.containsKey(three));
657		assertFalse(sm.containsKey(four));
658		assertFalse(sm.containsKey(five));
659	<	Iterator i = sm.keySet().iterator();
660	<	Object k;
661	<	k = (Integer)(i.next());
662	<	assertEquals(two, k);
659	>	Iterator<? extends Item> i = sm.keySet().iterator();
660	>	Item k;
661	>	k = (Item)(i.next());
662	>	mustEqual(two, k);
663		assertFalse(i.hasNext());
664	<	Iterator j = sm.keySet().iterator();
664	>	Iterator<? extends Item> j = sm.keySet().iterator();
665		j.next();
666		j.remove();
667		assertFalse(map.containsKey(two));
668	<	assertEquals(4, map.size());
669	<	assertEquals(0, sm.size());
668	>	mustEqual(4, map.size());
669	>	mustEqual(0, sm.size());
670		assertTrue(sm.isEmpty());
671		assertSame(sm.remove(three), null);
672	<	assertEquals(4, map.size());
672	>	mustEqual(4, map.size());
673		}
674
675		/**
676		* headMap returns map with keys in requested range
677		*/
678		public void testHeadMapContents() {
679	<	ConcurrentNavigableMap map = map5();
680	<	SortedMap sm = map.headMap(four);
679	>	ConcurrentNavigableMap<Item,String> map = map5();
680	>	SortedMap<Item,String> sm = map.headMap(four);
681		assertTrue(sm.containsKey(one));
682		assertTrue(sm.containsKey(two));
683		assertTrue(sm.containsKey(three));
684		assertFalse(sm.containsKey(four));
685		assertFalse(sm.containsKey(five));
686	<	Iterator i = sm.keySet().iterator();
686	>	Iterator<? extends Item> i = sm.keySet().iterator();
687		Object k;
688	<	k = (Integer)(i.next());
689	<	assertEquals(one, k);
690	<	k = (Integer)(i.next());
691	<	assertEquals(two, k);
692	<	k = (Integer)(i.next());
693	<	assertEquals(three, k);
688	>	k = (Item)(i.next());
689	>	mustEqual(one, k);
690	>	k = (Item)(i.next());
691	>	mustEqual(two, k);
692	>	k = (Item)(i.next());
693	>	mustEqual(three, k);
694		assertFalse(i.hasNext());
695		sm.clear();
696		assertTrue(sm.isEmpty());
697	<	assertEquals(2, map.size());
698	<	assertEquals(four, map.firstKey());
697	>	mustEqual(2, map.size());
698	>	mustEqual(four, map.firstKey());
699		}
700
701		/**
702		* headMap returns map with keys in requested range
703		*/
704		public void testTailMapContents() {
705	<	ConcurrentNavigableMap map = map5();
706	<	SortedMap sm = map.tailMap(two);
705	>	ConcurrentNavigableMap<Item,String> map = map5();
706	>	SortedMap<Item,String> sm = map.tailMap(two);
707		assertFalse(sm.containsKey(one));
708		assertTrue(sm.containsKey(two));
709		assertTrue(sm.containsKey(three));
710		assertTrue(sm.containsKey(four));
711		assertTrue(sm.containsKey(five));
712	<	Iterator i = sm.keySet().iterator();
713	<	Object k;
714	<	k = (Integer)(i.next());
715	<	assertEquals(two, k);
716	<	k = (Integer)(i.next());
717	<	assertEquals(three, k);
718	<	k = (Integer)(i.next());
719	<	assertEquals(four, k);
720	<	k = (Integer)(i.next());
721	<	assertEquals(five, k);
712	>	Iterator<Item> i = sm.keySet().iterator();
713	>	Item k = i.next();
714	>	mustEqual(two, k);
715	>	k = i.next();
716	>	mustEqual(three, k);
717	>	k = i.next();
718	>	mustEqual(four, k);
719	>	k = i.next();
720	>	mustEqual(five, k);
721		assertFalse(i.hasNext());
722
723	<	Iterator ei = sm.entrySet().iterator();
724	<	Map.Entry e;
725	<	e = (Map.Entry)(ei.next());
726	<	assertEquals(two, e.getKey());
727	<	assertEquals("B", e.getValue());
728	<	e = (Map.Entry)(ei.next());
729	<	assertEquals(three, e.getKey());
730	<	assertEquals("C", e.getValue());
731	<	e = (Map.Entry)(ei.next());
732	<	assertEquals(four, e.getKey());
733	<	assertEquals("D", e.getValue());
734	<	e = (Map.Entry)(ei.next());
735	<	assertEquals(five, e.getKey());
736	<	assertEquals("E", e.getValue());
723	>	Iterator<Map.Entry<Item,String>> ei = sm.entrySet().iterator();
724	>	Map.Entry<Item,String> e;
725	>	e = (ei.next());
726	>	mustEqual(two, e.getKey());
727	>	mustEqual("B", e.getValue());
728	>	e = (ei.next());
729	>	mustEqual(three, e.getKey());
730	>	mustEqual("C", e.getValue());
731	>	e = (ei.next());
732	>	mustEqual(four, e.getKey());
733	>	mustEqual("D", e.getValue());
734	>	e = (ei.next());
735	>	mustEqual(five, e.getKey());
736	>	mustEqual("E", e.getValue());
737		assertFalse(i.hasNext());
738
739	<	SortedMap ssm = sm.tailMap(four);
740	<	assertEquals(four, ssm.firstKey());
741	<	assertEquals(five, ssm.lastKey());
742	<	assertEquals("D", ssm.remove(four));
743	<	assertEquals(1, ssm.size());
744	<	assertEquals(3, sm.size());
745	<	assertEquals(4, map.size());
739	>	SortedMap<Item,String> ssm = sm.tailMap(four);
740	>	mustEqual(four, ssm.firstKey());
741	>	mustEqual(five, ssm.lastKey());
742	>	mustEqual("D", ssm.remove(four));
743	>	mustEqual(1, ssm.size());
744	>	mustEqual(3, sm.size());
745	>	mustEqual(4, map.size());
746		}
747
748		/**
749		* clear removes all pairs
750		*/
751		public void testDescendingClear() {
752	<	ConcurrentNavigableMap map = dmap5();
752	>	ConcurrentNavigableMap<Item,String> map = dmap5();
753		map.clear();
754	<	assertEquals(0, map.size());
754	>	mustEqual(0, map.size());
755		}
756
757		/**
758		* Maps with same contents are equal
759		*/
760		public void testDescendingEquals() {
761	<	ConcurrentNavigableMap map1 = dmap5();
762	<	ConcurrentNavigableMap map2 = dmap5();
763	<	assertEquals(map1, map2);
764	<	assertEquals(map2, map1);
761	>	ConcurrentNavigableMap<Item,String> map1 = dmap5();
762	>	ConcurrentNavigableMap<Item,String> map2 = dmap5();
763	>	mustEqual(map1, map2);
764	>	mustEqual(map2, map1);
765		map1.clear();
766		assertFalse(map1.equals(map2));
767		assertFalse(map2.equals(map1));
#	Line 772 | Line 771 | public class ConcurrentSkipListSubMapTes
771		* containsKey returns true for contained key
772		*/
773		public void testDescendingContainsKey() {
774	<	ConcurrentNavigableMap map = dmap5();
775	<	assertTrue(map.containsKey(m1));
774	>	ConcurrentNavigableMap<Item,String> map = dmap5();
775	>	assertTrue(map.containsKey(minusOne));
776		assertFalse(map.containsKey(zero));
777		}
778
#	Line 781 | Line 780 | public class ConcurrentSkipListSubMapTes
780		* containsValue returns true for held values
781		*/
782		public void testDescendingContainsValue() {
783	<	ConcurrentNavigableMap map = dmap5();
783	>	ConcurrentNavigableMap<Item,String> map = dmap5();
784		assertTrue(map.containsValue("A"));
785		assertFalse(map.containsValue("Z"));
786		}
#	Line 791 | Line 790 | public class ConcurrentSkipListSubMapTes
790		* or null if not present
791		*/
792		public void testDescendingGet() {
793	<	ConcurrentNavigableMap map = dmap5();
794	<	assertEquals("A", (String)map.get(m1));
795	<	ConcurrentNavigableMap empty = dmap0();
796	<	assertNull(empty.get(m1));
793	>	ConcurrentNavigableMap<Item,String> map = dmap5();
794	>	mustEqual("A", map.get(minusOne));
795	>	ConcurrentNavigableMap<Item,String> empty = dmap0();
796	>	assertNull(empty.get(minusOne));
797		}
798
799		/**
800		* isEmpty is true of empty map and false for non-empty
801		*/
802		public void testDescendingIsEmpty() {
803	<	ConcurrentNavigableMap empty = dmap0();
804	<	ConcurrentNavigableMap map = dmap5();
803	>	ConcurrentNavigableMap<Item,String> empty = dmap0();
804	>	ConcurrentNavigableMap<Item,String> map = dmap5();
805		assertTrue(empty.isEmpty());
806		assertFalse(map.isEmpty());
807		}
#	Line 811 | Line 810 | public class ConcurrentSkipListSubMapTes
810		* firstKey returns first key
811		*/
812		public void testDescendingFirstKey() {
813	<	ConcurrentNavigableMap map = dmap5();
814	<	assertEquals(m1, map.firstKey());
813	>	ConcurrentNavigableMap<Item,String> map = dmap5();
814	>	mustEqual(minusOne, map.firstKey());
815		}
816
817		/**
818		* lastKey returns last key
819		*/
820		public void testDescendingLastKey() {
821	<	ConcurrentNavigableMap map = dmap5();
822	<	assertEquals(m5, map.lastKey());
821	>	ConcurrentNavigableMap<Item,String> map = dmap5();
822	>	mustEqual(minusFive, map.lastKey());
823		}
824
825		/**
826		* keySet returns a Set containing all the keys
827		*/
828		public void testDescendingKeySet() {
829	<	ConcurrentNavigableMap map = dmap5();
830	<	Set s = map.keySet();
831	<	assertEquals(5, s.size());
832	<	assertTrue(s.contains(m1));
833	<	assertTrue(s.contains(m2));
834	<	assertTrue(s.contains(m3));
835	<	assertTrue(s.contains(m4));
836	<	assertTrue(s.contains(m5));
829	>	ConcurrentNavigableMap<Item,String> map = dmap5();
830	>	Set<Item> s = map.keySet();
831	>	mustEqual(5, s.size());
832	>	mustContain(s, minusOne);
833	>	mustContain(s, minusTwo);
834	>	mustContain(s, minusThree);
835	>	mustContain(s, minusFour);
836	>	mustContain(s, minusFive);
837		}
838
839		/**
840		* keySet is ordered
841		*/
842		public void testDescendingKeySetOrder() {
843	<	ConcurrentNavigableMap map = dmap5();
844	<	Set s = map.keySet();
845	<	Iterator i = s.iterator();
846	<	Integer last = (Integer)i.next();
847	<	assertEquals(last, m1);
843	>	ConcurrentNavigableMap<Item,String> map = dmap5();
844	>	Set<Item> s = map.keySet();
845	>	Iterator<? extends Item> i = s.iterator();
846	>	Item last = i.next();
847	>	mustEqual(last, minusOne);
848		while (i.hasNext()) {
849	<	Integer k = (Integer)i.next();
849	>	Item k = i.next();
850		assertTrue(last.compareTo(k) > 0);
851		last = k;
852		}
#	Line 857 | Line 856 | public class ConcurrentSkipListSubMapTes
856		* values collection contains all values
857		*/
858		public void testDescendingValues() {
859	<	ConcurrentNavigableMap map = dmap5();
860	<	Collection s = map.values();
861	<	assertEquals(5, s.size());
859	>	ConcurrentNavigableMap<Item,String> map = dmap5();
860	>	Collection<String> s = map.values();
861	>	mustEqual(5, s.size());
862		assertTrue(s.contains("A"));
863		assertTrue(s.contains("B"));
864		assertTrue(s.contains("C"));
#	Line 871 | Line 870 | public class ConcurrentSkipListSubMapTes
870		* keySet.toArray returns contains all keys
871		*/
872		public void testDescendingAscendingKeySetToArray() {
873	<	ConcurrentNavigableMap map = dmap5();
874	<	Set s = map.keySet();
875	<	Object[] ar = s.toArray();
873	>	ConcurrentNavigableMap<Item,String> map = dmap5();
874	>	Set<Item> s = map.keySet();
875	>	Item[] ar = s.toArray(new Item[0]);
876		assertTrue(s.containsAll(Arrays.asList(ar)));
877	<	assertEquals(5, ar.length);
878	<	ar[0] = m10;
877	>	mustEqual(5, ar.length);
878	>	ar[0] = minusTen;
879		assertFalse(s.containsAll(Arrays.asList(ar)));
880		}
881
#	Line 884 | Line 883 | public class ConcurrentSkipListSubMapTes
883		* descendingkeySet.toArray returns contains all keys
884		*/
885		public void testDescendingDescendingKeySetToArray() {
886	<	ConcurrentNavigableMap map = dmap5();
887	<	Set s = map.descendingKeySet();
888	<	Object[] ar = s.toArray();
889	<	assertEquals(5, ar.length);
886	>	ConcurrentNavigableMap<Item,String> map = dmap5();
887	>	Set<Item> s = map.descendingKeySet();
888	>	Item[] ar = s.toArray(new Item[0]);
889	>	mustEqual(5, ar.length);
890		assertTrue(s.containsAll(Arrays.asList(ar)));
891	<	ar[0] = m10;
891	>	ar[0] = minusTen;
892		assertFalse(s.containsAll(Arrays.asList(ar)));
893		}
894
#	Line 897 | Line 896 | public class ConcurrentSkipListSubMapTes
896		* Values.toArray contains all values
897		*/
898		public void testDescendingValuesToArray() {
899	<	ConcurrentNavigableMap map = dmap5();
900	<	Collection v = map.values();
901	<	Object[] ar = v.toArray();
902	<	ArrayList s = new ArrayList(Arrays.asList(ar));
903	<	assertEquals(5, ar.length);
899	>	ConcurrentNavigableMap<Item,String> map = dmap5();
900	>	Collection<String> v = map.values();
901	>	String[] ar = v.toArray(new String[0]);
902	>	ArrayList<String> s = new ArrayList<String>(Arrays.asList(ar));
903	>	mustEqual(5, ar.length);
904		assertTrue(s.contains("A"));
905		assertTrue(s.contains("B"));
906		assertTrue(s.contains("C"));
#	Line 913 | Line 912 | public class ConcurrentSkipListSubMapTes
912		* entrySet contains all pairs
913		*/
914		public void testDescendingEntrySet() {
915	<	ConcurrentNavigableMap map = dmap5();
916	<	Set s = map.entrySet();
917	<	assertEquals(5, s.size());
918	<	Iterator it = s.iterator();
915	>	ConcurrentNavigableMap<Item,String> map = dmap5();
916	>	Set<Map.Entry<Item,String>> s = map.entrySet();
917	>	mustEqual(5, s.size());
918	>	Iterator<Map.Entry<Item,String>> it = s.iterator();
919		while (it.hasNext()) {
920	<	Map.Entry e = (Map.Entry) it.next();
920	>	Map.Entry<Item,String> e = it.next();
921		assertTrue(
922	<	(e.getKey().equals(m1) && e.getValue().equals("A")) ||
923	<	(e.getKey().equals(m2) && e.getValue().equals("B")) ||
924	<	(e.getKey().equals(m3) && e.getValue().equals("C")) ||
925	<	(e.getKey().equals(m4) && e.getValue().equals("D")) ||
926	<	(e.getKey().equals(m5) && e.getValue().equals("E")));
922	>	(e.getKey().equals(minusOne) && e.getValue().equals("A")) ||
923	>	(e.getKey().equals(minusTwo) && e.getValue().equals("B")) ||
924	>	(e.getKey().equals(minusThree) && e.getValue().equals("C")) ||
925	>	(e.getKey().equals(minusFour) && e.getValue().equals("D")) ||
926	>	(e.getKey().equals(minusFive) && e.getValue().equals("E")));
927		}
928		}
929
#	Line 932 | Line 931 | public class ConcurrentSkipListSubMapTes
931		* putAll adds all key-value pairs from the given map
932		*/
933		public void testDescendingPutAll() {
934	<	ConcurrentNavigableMap empty = dmap0();
935	<	ConcurrentNavigableMap map = dmap5();
934	>	ConcurrentNavigableMap<Item,String> empty = dmap0();
935	>	ConcurrentNavigableMap<Item,String> map = dmap5();
936		empty.putAll(map);
937	<	assertEquals(5, empty.size());
938	<	assertTrue(empty.containsKey(m1));
939	<	assertTrue(empty.containsKey(m2));
940	<	assertTrue(empty.containsKey(m3));
941	<	assertTrue(empty.containsKey(m4));
942	<	assertTrue(empty.containsKey(m5));
937	>	mustEqual(5, empty.size());
938	>	assertTrue(empty.containsKey(minusOne));
939	>	assertTrue(empty.containsKey(minusTwo));
940	>	assertTrue(empty.containsKey(minusThree));
941	>	assertTrue(empty.containsKey(minusFour));
942	>	assertTrue(empty.containsKey(minusFive));
943		}
944
945		/**
946		* putIfAbsent works when the given key is not present
947		*/
948		public void testDescendingPutIfAbsent() {
949	<	ConcurrentNavigableMap map = dmap5();
949	>	ConcurrentNavigableMap<Item,String> map = dmap5();
950		map.putIfAbsent(six, "Z");
951		assertTrue(map.containsKey(six));
952		}
#	Line 956 | Line 955 | public class ConcurrentSkipListSubMapTes
955		* putIfAbsent does not add the pair if the key is already present
956		*/
957		public void testDescendingPutIfAbsent2() {
958	<	ConcurrentNavigableMap map = dmap5();
959	<	assertEquals("A", map.putIfAbsent(m1, "Z"));
958	>	ConcurrentNavigableMap<Item,String> map = dmap5();
959	>	mustEqual("A", map.putIfAbsent(minusOne, "Z"));
960		}
961
962		/**
963		* replace fails when the given key is not present
964		*/
965		public void testDescendingReplace() {
966	<	ConcurrentNavigableMap map = dmap5();
966	>	ConcurrentNavigableMap<Item,String> map = dmap5();
967		assertNull(map.replace(six, "Z"));
968		assertFalse(map.containsKey(six));
969		}
#	Line 973 | Line 972 | public class ConcurrentSkipListSubMapTes
972		* replace succeeds if the key is already present
973		*/
974		public void testDescendingReplace2() {
975	<	ConcurrentNavigableMap map = dmap5();
976	<	assertNotNull(map.replace(m1, "Z"));
977	<	assertEquals("Z", map.get(m1));
975	>	ConcurrentNavigableMap<Item,String> map = dmap5();
976	>	assertNotNull(map.replace(minusOne, "Z"));
977	>	mustEqual("Z", map.get(minusOne));
978		}
979
980		/**
981		* replace value fails when the given key not mapped to expected value
982		*/
983		public void testDescendingReplaceValue() {
984	<	ConcurrentNavigableMap map = dmap5();
985	<	assertEquals("A", map.get(m1));
986	<	assertFalse(map.replace(m1, "Z", "Z"));
987	<	assertEquals("A", map.get(m1));
984	>	ConcurrentNavigableMap<Item,String> map = dmap5();
985	>	mustEqual("A", map.get(minusOne));
986	>	assertFalse(map.replace(minusOne, "Z", "Z"));
987	>	mustEqual("A", map.get(minusOne));
988		}
989
990		/**
991		* replace value succeeds when the given key mapped to expected value
992		*/
993		public void testDescendingReplaceValue2() {
994	<	ConcurrentNavigableMap map = dmap5();
995	<	assertEquals("A", map.get(m1));
996	<	assertTrue(map.replace(m1, "A", "Z"));
997	<	assertEquals("Z", map.get(m1));
994	>	ConcurrentNavigableMap<Item,String> map = dmap5();
995	>	mustEqual("A", map.get(minusOne));
996	>	assertTrue(map.replace(minusOne, "A", "Z"));
997	>	mustEqual("Z", map.get(minusOne));
998		}
999
1000		/**
1001		* remove removes the correct key-value pair from the map
1002		*/
1003		public void testDescendingRemove() {
1004	<	ConcurrentNavigableMap map = dmap5();
1005	<	map.remove(m5);
1006	<	assertEquals(4, map.size());
1007	<	assertFalse(map.containsKey(m5));
1004	>	ConcurrentNavigableMap<Item,String> map = dmap5();
1005	>	map.remove(minusFive);
1006	>	mustEqual(4, map.size());
1007	>	assertFalse(map.containsKey(minusFive));
1008		}
1009
1010		/**
1011		* remove(key,value) removes only if pair present
1012		*/
1013		public void testDescendingRemove2() {
1014	<	ConcurrentNavigableMap map = dmap5();
1015	<	assertTrue(map.containsKey(m5));
1016	<	assertEquals("E", map.get(m5));
1017	<	map.remove(m5, "E");
1018	<	assertEquals(4, map.size());
1019	<	assertFalse(map.containsKey(m5));
1020	<	map.remove(m4, "A");
1021	<	assertEquals(4, map.size());
1022	<	assertTrue(map.containsKey(m4));
1014	>	ConcurrentNavigableMap<Item,String> map = dmap5();
1015	>	assertTrue(map.containsKey(minusFive));
1016	>	mustEqual("E", map.get(minusFive));
1017	>	map.remove(minusFive, "E");
1018	>	mustEqual(4, map.size());
1019	>	assertFalse(map.containsKey(minusFive));
1020	>	map.remove(minusFour, "A");
1021	>	mustEqual(4, map.size());
1022	>	assertTrue(map.containsKey(minusFour));
1023		}
1024
1025		/**
1026		* lowerEntry returns preceding entry.
1027		*/
1028		public void testDescendingLowerEntry() {
1029	<	ConcurrentNavigableMap map = dmap5();
1030	<	Map.Entry e1 = map.lowerEntry(m3);
1031	<	assertEquals(m2, e1.getKey());
1029	>	ConcurrentNavigableMap<Item,String> map = dmap5();
1030	>	Map.Entry<Item,String> e1 = map.lowerEntry(minusThree);
1031	>	mustEqual(minusTwo, e1.getKey());
1032
1033	<	Map.Entry e2 = map.lowerEntry(m6);
1034	<	assertEquals(m5, e2.getKey());
1033	>	Map.Entry<Item,String> e2 = map.lowerEntry(minusSix);
1034	>	mustEqual(minusFive, e2.getKey());
1035
1036	<	Map.Entry e3 = map.lowerEntry(m1);
1036	>	Map.Entry<Item,String> e3 = map.lowerEntry(minusOne);
1037		assertNull(e3);
1038
1039	<	Map.Entry e4 = map.lowerEntry(zero);
1039	>	Map.Entry<Item,String> e4 = map.lowerEntry(zero);
1040		assertNull(e4);
1041		}
1042
#	Line 1045 | Line 1044 | public class ConcurrentSkipListSubMapTes
1044		* higherEntry returns next entry.
1045		*/
1046		public void testDescendingHigherEntry() {
1047	<	ConcurrentNavigableMap map = dmap5();
1048	<	Map.Entry e1 = map.higherEntry(m3);
1049	<	assertEquals(m4, e1.getKey());
1047	>	ConcurrentNavigableMap<Item,String> map = dmap5();
1048	>	Map.Entry<Item,String> e1 = map.higherEntry(minusThree);
1049	>	mustEqual(minusFour, e1.getKey());
1050
1051	<	Map.Entry e2 = map.higherEntry(zero);
1052	<	assertEquals(m1, e2.getKey());
1051	>	Map.Entry<Item,String> e2 = map.higherEntry(zero);
1052	>	mustEqual(minusOne, e2.getKey());
1053
1054	<	Map.Entry e3 = map.higherEntry(m5);
1054	>	Map.Entry<Item,String> e3 = map.higherEntry(minusFive);
1055		assertNull(e3);
1056
1057	<	Map.Entry e4 = map.higherEntry(m6);
1057	>	Map.Entry<Item,String> e4 = map.higherEntry(minusSix);
1058		assertNull(e4);
1059		}
1060
#	Line 1063 | Line 1062 | public class ConcurrentSkipListSubMapTes
1062		* floorEntry returns preceding entry.
1063		*/
1064		public void testDescendingFloorEntry() {
1065	<	ConcurrentNavigableMap map = dmap5();
1066	<	Map.Entry e1 = map.floorEntry(m3);
1067	<	assertEquals(m3, e1.getKey());
1065	>	ConcurrentNavigableMap<Item,String> map = dmap5();
1066	>	Map.Entry<Item,String> e1 = map.floorEntry(minusThree);
1067	>	mustEqual(minusThree, e1.getKey());
1068
1069	<	Map.Entry e2 = map.floorEntry(m6);
1070	<	assertEquals(m5, e2.getKey());
1069	>	Map.Entry<Item,String> e2 = map.floorEntry(minusSix);
1070	>	mustEqual(minusFive, e2.getKey());
1071
1072	<	Map.Entry e3 = map.floorEntry(m1);
1073	<	assertEquals(m1, e3.getKey());
1072	>	Map.Entry<Item,String> e3 = map.floorEntry(minusOne);
1073	>	mustEqual(minusOne, e3.getKey());
1074
1075	<	Map.Entry e4 = map.floorEntry(zero);
1075	>	Map.Entry<Item,String> e4 = map.floorEntry(zero);
1076		assertNull(e4);
1077		}
1078
#	Line 1081 | Line 1080 | public class ConcurrentSkipListSubMapTes
1080		* ceilingEntry returns next entry.
1081		*/
1082		public void testDescendingCeilingEntry() {
1083	<	ConcurrentNavigableMap map = dmap5();
1084	<	Map.Entry e1 = map.ceilingEntry(m3);
1085	<	assertEquals(m3, e1.getKey());
1083	>	ConcurrentNavigableMap<Item,String> map = dmap5();
1084	>	Map.Entry<Item,String> e1 = map.ceilingEntry(minusThree);
1085	>	mustEqual(minusThree, e1.getKey());
1086
1087	<	Map.Entry e2 = map.ceilingEntry(zero);
1088	<	assertEquals(m1, e2.getKey());
1087	>	Map.Entry<Item,String> e2 = map.ceilingEntry(zero);
1088	>	mustEqual(minusOne, e2.getKey());
1089
1090	<	Map.Entry e3 = map.ceilingEntry(m5);
1091	<	assertEquals(m5, e3.getKey());
1090	>	Map.Entry<Item,String> e3 = map.ceilingEntry(minusFive);
1091	>	mustEqual(minusFive, e3.getKey());
1092
1093	<	Map.Entry e4 = map.ceilingEntry(m6);
1093	>	Map.Entry<Item,String> e4 = map.ceilingEntry(minusSix);
1094		assertNull(e4);
1095		}
1096
#	Line 1099 | Line 1098 | public class ConcurrentSkipListSubMapTes
1098		* pollFirstEntry returns entries in order
1099		*/
1100		public void testDescendingPollFirstEntry() {
1101	<	ConcurrentNavigableMap map = dmap5();
1102	<	Map.Entry e = map.pollFirstEntry();
1103	<	assertEquals(m1, e.getKey());
1104	<	assertEquals("A", e.getValue());
1101	>	ConcurrentNavigableMap<Item,String> map = dmap5();
1102	>	Map.Entry<Item,String> e = map.pollFirstEntry();
1103	>	mustEqual(minusOne, e.getKey());
1104	>	mustEqual("A", e.getValue());
1105		e = map.pollFirstEntry();
1106	<	assertEquals(m2, e.getKey());
1107	<	map.put(m1, "A");
1106	>	mustEqual(minusTwo, e.getKey());
1107	>	map.put(minusOne, "A");
1108		e = map.pollFirstEntry();
1109	<	assertEquals(m1, e.getKey());
1110	<	assertEquals("A", e.getValue());
1109	>	mustEqual(minusOne, e.getKey());
1110	>	mustEqual("A", e.getValue());
1111		e = map.pollFirstEntry();
1112	<	assertEquals(m3, e.getKey());
1113	<	map.remove(m4);
1112	>	mustEqual(minusThree, e.getKey());
1113	>	map.remove(minusFour);
1114		e = map.pollFirstEntry();
1115	<	assertEquals(m5, e.getKey());
1115	>	mustEqual(minusFive, e.getKey());
1116		try {
1117		e.setValue("A");
1118		shouldThrow();
#	Line 1126 | Line 1125 | public class ConcurrentSkipListSubMapTes
1125		* pollLastEntry returns entries in order
1126		*/
1127		public void testDescendingPollLastEntry() {
1128	<	ConcurrentNavigableMap map = dmap5();
1129	<	Map.Entry e = map.pollLastEntry();
1130	<	assertEquals(m5, e.getKey());
1131	<	assertEquals("E", e.getValue());
1128	>	ConcurrentNavigableMap<Item,String> map = dmap5();
1129	>	Map.Entry<Item,String> e = map.pollLastEntry();
1130	>	mustEqual(minusFive, e.getKey());
1131	>	mustEqual("E", e.getValue());
1132		e = map.pollLastEntry();
1133	<	assertEquals(m4, e.getKey());
1134	<	map.put(m5, "E");
1133	>	mustEqual(minusFour, e.getKey());
1134	>	map.put(minusFive, "E");
1135		e = map.pollLastEntry();
1136	<	assertEquals(m5, e.getKey());
1137	<	assertEquals("E", e.getValue());
1136	>	mustEqual(minusFive, e.getKey());
1137	>	mustEqual("E", e.getValue());
1138		e = map.pollLastEntry();
1139	<	assertEquals(m3, e.getKey());
1140	<	map.remove(m2);
1139	>	mustEqual(minusThree, e.getKey());
1140	>	map.remove(minusTwo);
1141		e = map.pollLastEntry();
1142	<	assertEquals(m1, e.getKey());
1142	>	mustEqual(minusOne, e.getKey());
1143		try {
1144		e.setValue("E");
1145		shouldThrow();
#	Line 1153 | Line 1152 | public class ConcurrentSkipListSubMapTes
1152		* size returns the correct values
1153		*/
1154		public void testDescendingSize() {
1155	<	ConcurrentNavigableMap map = dmap5();
1156	<	ConcurrentNavigableMap empty = dmap0();
1157	<	assertEquals(0, empty.size());
1158	<	assertEquals(5, map.size());
1155	>	ConcurrentNavigableMap<Item,String> map = dmap5();
1156	>	ConcurrentNavigableMap<Item,String> empty = dmap0();
1157	>	mustEqual(0, empty.size());
1158	>	mustEqual(5, map.size());
1159		}
1160
1161		/**
1162		* toString contains toString of elements
1163		*/
1164		public void testDescendingToString() {
1165	<	ConcurrentNavigableMap map = dmap5();
1165	>	ConcurrentNavigableMap<Item,String> map = dmap5();
1166		String s = map.toString();
1167		for (int i = 1; i <= 5; ++i) {
1168		assertTrue(s.contains(String.valueOf(i)));
#	Line 1177 | Line 1176 | public class ConcurrentSkipListSubMapTes
1176		*/
1177		public void testDescendingGet_NullPointerException() {
1178		try {
1179	<	ConcurrentNavigableMap c = dmap5();
1179	>	ConcurrentNavigableMap<Item,String> c = dmap5();
1180		c.get(null);
1181		shouldThrow();
1182		} catch (NullPointerException success) {}
#	Line 1188 | Line 1187 | public class ConcurrentSkipListSubMapTes
1187		*/
1188		public void testDescendingContainsKey_NullPointerException() {
1189		try {
1190	<	ConcurrentNavigableMap c = dmap5();
1190	>	ConcurrentNavigableMap<Item,String> c = dmap5();
1191		c.containsKey(null);
1192		shouldThrow();
1193		} catch (NullPointerException success) {}
#	Line 1199 | Line 1198 | public class ConcurrentSkipListSubMapTes
1198		*/
1199		public void testDescendingContainsValue_NullPointerException() {
1200		try {
1201	<	ConcurrentNavigableMap c = dmap0();
1201	>	ConcurrentNavigableMap<Item,String> c = dmap0();
1202		c.containsValue(null);
1203		shouldThrow();
1204		} catch (NullPointerException success) {}
#	Line 1210 | Line 1209 | public class ConcurrentSkipListSubMapTes
1209		*/
1210		public void testDescendingPut1_NullPointerException() {
1211		try {
1212	<	ConcurrentNavigableMap c = dmap5();
1212	>	ConcurrentNavigableMap<Item,String> c = dmap5();
1213		c.put(null, "whatever");
1214		shouldThrow();
1215		} catch (NullPointerException success) {}
#	Line 1221 | Line 1220 | public class ConcurrentSkipListSubMapTes
1220		*/
1221		public void testDescendingPutIfAbsent1_NullPointerException() {
1222		try {
1223	<	ConcurrentNavigableMap c = dmap5();
1223	>	ConcurrentNavigableMap<Item,String> c = dmap5();
1224		c.putIfAbsent(null, "whatever");
1225		shouldThrow();
1226		} catch (NullPointerException success) {}
#	Line 1232 | Line 1231 | public class ConcurrentSkipListSubMapTes
1231		*/
1232		public void testDescendingReplace_NullPointerException() {
1233		try {
1234	<	ConcurrentNavigableMap c = dmap5();
1234	>	ConcurrentNavigableMap<Item,String> c = dmap5();
1235		c.replace(null, "whatever");
1236		shouldThrow();
1237		} catch (NullPointerException success) {}
#	Line 1243 | Line 1242 | public class ConcurrentSkipListSubMapTes
1242		*/
1243		public void testDescendingReplaceValue_NullPointerException() {
1244		try {
1245	<	ConcurrentNavigableMap c = dmap5();
1246	<	c.replace(null, m1, "whatever");
1245	>	ConcurrentNavigableMap<Item,String> c = dmap5();
1246	>	c.replace(null, "A", "B");
1247		shouldThrow();
1248		} catch (NullPointerException success) {}
1249		}
#	Line 1254 | Line 1253 | public class ConcurrentSkipListSubMapTes
1253		*/
1254		public void testDescendingRemove1_NullPointerException() {
1255		try {
1256	<	ConcurrentNavigableMap c = dmap5();
1256	>	ConcurrentNavigableMap<Item,String> c = dmap5();
1257		c.remove(null);
1258		shouldThrow();
1259		} catch (NullPointerException success) {}
#	Line 1265 | Line 1264 | public class ConcurrentSkipListSubMapTes
1264		*/
1265		public void testDescendingRemove2_NullPointerException() {
1266		try {
1267	<	ConcurrentNavigableMap c = dmap5();
1267	>	ConcurrentNavigableMap<Item,String> c = dmap5();
1268		c.remove(null, "whatever");
1269		shouldThrow();
1270		} catch (NullPointerException success) {}
#	Line 1275 | Line 1274 | public class ConcurrentSkipListSubMapTes
1274		* A deserialized/reserialized map equals original
1275		*/
1276		public void testDescendingSerialization() throws Exception {
1277	<	NavigableMap x = dmap5();
1278	<	NavigableMap y = serialClone(x);
1277	>	NavigableMap<Item,String> x = dmap5();
1278	>	NavigableMap<Item,String> y = serialClone(x);
1279
1280		assertNotSame(x, y);
1281	<	assertEquals(x.size(), y.size());
1282	<	assertEquals(x.toString(), y.toString());
1283	<	assertEquals(x, y);
1284	<	assertEquals(y, x);
1281	>	mustEqual(x.size(), y.size());
1282	>	mustEqual(x.toString(), y.toString());
1283	>	mustEqual(x, y);
1284	>	mustEqual(y, x);
1285		}
1286
1287		/**
1288		* subMap returns map with keys in requested range
1289		*/
1290		public void testDescendingSubMapContents() {
1291	<	ConcurrentNavigableMap map = dmap5();
1292	<	SortedMap sm = map.subMap(m2, m4);
1293	<	assertEquals(m2, sm.firstKey());
1294	<	assertEquals(m3, sm.lastKey());
1295	<	assertEquals(2, sm.size());
1296	<	assertFalse(sm.containsKey(m1));
1297	<	assertTrue(sm.containsKey(m2));
1298	<	assertTrue(sm.containsKey(m3));
1299	<	assertFalse(sm.containsKey(m4));
1300	<	assertFalse(sm.containsKey(m5));
1301	<	Iterator i = sm.keySet().iterator();
1302	<	Object k;
1303	<	k = (Integer)(i.next());
1304	<	assertEquals(m2, k);
1305	<	k = (Integer)(i.next());
1306	<	assertEquals(m3, k);
1291	>	ConcurrentNavigableMap<Item,String> map = dmap5();
1292	>	SortedMap<Item,String> sm = map.subMap(minusTwo, minusFour);
1293	>	mustEqual(minusTwo, sm.firstKey());
1294	>	mustEqual(minusThree, sm.lastKey());
1295	>	mustEqual(2, sm.size());
1296	>	assertFalse(sm.containsKey(minusOne));
1297	>	assertTrue(sm.containsKey(minusTwo));
1298	>	assertTrue(sm.containsKey(minusThree));
1299	>	assertFalse(sm.containsKey(minusFour));
1300	>	assertFalse(sm.containsKey(minusFive));
1301	>	Iterator<? extends Item> i = sm.keySet().iterator();
1302	>	Item k;
1303	>	k = (Item)(i.next());
1304	>	mustEqual(minusTwo, k);
1305	>	k = (Item)(i.next());
1306	>	mustEqual(minusThree, k);
1307		assertFalse(i.hasNext());
1308	<	Iterator j = sm.keySet().iterator();
1308	>	Iterator<? extends Item> j = sm.keySet().iterator();
1309		j.next();
1310		j.remove();
1311	<	assertFalse(map.containsKey(m2));
1312	<	assertEquals(4, map.size());
1313	<	assertEquals(1, sm.size());
1314	<	assertEquals(m3, sm.firstKey());
1315	<	assertEquals(m3, sm.lastKey());
1316	<	assertEquals("C", sm.remove(m3));
1311	>	assertFalse(map.containsKey(minusTwo));
1312	>	mustEqual(4, map.size());
1313	>	mustEqual(1, sm.size());
1314	>	mustEqual(minusThree, sm.firstKey());
1315	>	mustEqual(minusThree, sm.lastKey());
1316	>	mustEqual("C", sm.remove(minusThree));
1317		assertTrue(sm.isEmpty());
1318	<	assertEquals(3, map.size());
1318	>	mustEqual(3, map.size());
1319		}
1320
1321		public void testDescendingSubMapContents2() {
1322	<	ConcurrentNavigableMap map = dmap5();
1323	<	SortedMap sm = map.subMap(m2, m3);
1324	<	assertEquals(1, sm.size());
1325	<	assertEquals(m2, sm.firstKey());
1326	<	assertEquals(m2, sm.lastKey());
1327	<	assertFalse(sm.containsKey(m1));
1328	<	assertTrue(sm.containsKey(m2));
1329	<	assertFalse(sm.containsKey(m3));
1330	<	assertFalse(sm.containsKey(m4));
1331	<	assertFalse(sm.containsKey(m5));
1332	<	Iterator i = sm.keySet().iterator();
1333	<	Object k;
1334	<	k = (Integer)(i.next());
1335	<	assertEquals(m2, k);
1322	>	ConcurrentNavigableMap<Item,String> map = dmap5();
1323	>	SortedMap<Item,String> sm = map.subMap(minusTwo, minusThree);
1324	>	mustEqual(1, sm.size());
1325	>	mustEqual(minusTwo, sm.firstKey());
1326	>	mustEqual(minusTwo, sm.lastKey());
1327	>	assertFalse(sm.containsKey(minusOne));
1328	>	assertTrue(sm.containsKey(minusTwo));
1329	>	assertFalse(sm.containsKey(minusThree));
1330	>	assertFalse(sm.containsKey(minusFour));
1331	>	assertFalse(sm.containsKey(minusFive));
1332	>	Iterator<? extends Item> i = sm.keySet().iterator();
1333	>	Item k;
1334	>	k = (Item)(i.next());
1335	>	mustEqual(minusTwo, k);
1336		assertFalse(i.hasNext());
1337	<	Iterator j = sm.keySet().iterator();
1337	>	Iterator<? extends Item> j = sm.keySet().iterator();
1338		j.next();
1339		j.remove();
1340	<	assertFalse(map.containsKey(m2));
1341	<	assertEquals(4, map.size());
1342	<	assertEquals(0, sm.size());
1340	>	assertFalse(map.containsKey(minusTwo));
1341	>	mustEqual(4, map.size());
1342	>	mustEqual(0, sm.size());
1343		assertTrue(sm.isEmpty());
1344	<	assertSame(sm.remove(m3), null);
1345	<	assertEquals(4, map.size());
1344	>	assertSame(sm.remove(minusThree), null);
1345	>	mustEqual(4, map.size());
1346		}
1347
1348		/**
1349		* headMap returns map with keys in requested range
1350		*/
1351		public void testDescendingHeadMapContents() {
1352	<	ConcurrentNavigableMap map = dmap5();
1353	<	SortedMap sm = map.headMap(m4);
1354	<	assertTrue(sm.containsKey(m1));
1355	<	assertTrue(sm.containsKey(m2));
1356	<	assertTrue(sm.containsKey(m3));
1357	<	assertFalse(sm.containsKey(m4));
1358	<	assertFalse(sm.containsKey(m5));
1359	<	Iterator i = sm.keySet().iterator();
1360	<	Object k;
1361	<	k = (Integer)(i.next());
1362	<	assertEquals(m1, k);
1363	<	k = (Integer)(i.next());
1364	<	assertEquals(m2, k);
1365	<	k = (Integer)(i.next());
1366	<	assertEquals(m3, k);
1352	>	ConcurrentNavigableMap<Item,String> map = dmap5();
1353	>	SortedMap<Item,String> sm = map.headMap(minusFour);
1354	>	assertTrue(sm.containsKey(minusOne));
1355	>	assertTrue(sm.containsKey(minusTwo));
1356	>	assertTrue(sm.containsKey(minusThree));
1357	>	assertFalse(sm.containsKey(minusFour));
1358	>	assertFalse(sm.containsKey(minusFive));
1359	>	Iterator<? extends Item> i = sm.keySet().iterator();
1360	>	Item k;
1361	>	k = (Item)(i.next());
1362	>	mustEqual(minusOne, k);
1363	>	k = (Item)(i.next());
1364	>	mustEqual(minusTwo, k);
1365	>	k = (Item)(i.next());
1366	>	mustEqual(minusThree, k);
1367		assertFalse(i.hasNext());
1368		sm.clear();
1369		assertTrue(sm.isEmpty());
1370	<	assertEquals(2, map.size());
1371	<	assertEquals(m4, map.firstKey());
1370	>	mustEqual(2, map.size());
1371	>	mustEqual(minusFour, map.firstKey());
1372		}
1373
1374		/**
1375		* headMap returns map with keys in requested range
1376		*/
1377		public void testDescendingTailMapContents() {
1378	<	ConcurrentNavigableMap map = dmap5();
1379	<	SortedMap sm = map.tailMap(m2);
1380	<	assertFalse(sm.containsKey(m1));
1381	<	assertTrue(sm.containsKey(m2));
1382	<	assertTrue(sm.containsKey(m3));
1383	<	assertTrue(sm.containsKey(m4));
1384	<	assertTrue(sm.containsKey(m5));
1385	<	Iterator i = sm.keySet().iterator();
1386	<	Object k;
1387	<	k = (Integer)(i.next());
1388	<	assertEquals(m2, k);
1389	<	k = (Integer)(i.next());
1390	<	assertEquals(m3, k);
1391	<	k = (Integer)(i.next());
1392	<	assertEquals(m4, k);
1393	<	k = (Integer)(i.next());
1395	<	assertEquals(m5, k);
1378	>	ConcurrentNavigableMap<Item,String> map = dmap5();
1379	>	SortedMap<Item,String> sm = map.tailMap(minusTwo);
1380	>	assertFalse(sm.containsKey(minusOne));
1381	>	assertTrue(sm.containsKey(minusTwo));
1382	>	assertTrue(sm.containsKey(minusThree));
1383	>	assertTrue(sm.containsKey(minusFour));
1384	>	assertTrue(sm.containsKey(minusFive));
1385	>	Iterator<? extends Item> i = sm.keySet().iterator();
1386	>	Item k = i.next();
1387	>	mustEqual(minusTwo, k);
1388	>	k = (i.next());
1389	>	mustEqual(minusThree, k);
1390	>	k = (i.next());
1391	>	mustEqual(minusFour, k);
1392	>	k = (i.next());
1393	>	mustEqual(minusFive, k);
1394		assertFalse(i.hasNext());
1395
1396	<	Iterator ei = sm.entrySet().iterator();
1397	<	Map.Entry e;
1398	<	e = (Map.Entry)(ei.next());
1399	<	assertEquals(m2, e.getKey());
1400	<	assertEquals("B", e.getValue());
1401	<	e = (Map.Entry)(ei.next());
1402	<	assertEquals(m3, e.getKey());
1403	<	assertEquals("C", e.getValue());
1404	<	e = (Map.Entry)(ei.next());
1405	<	assertEquals(m4, e.getKey());
1406	<	assertEquals("D", e.getValue());
1407	<	e = (Map.Entry)(ei.next());
1408	<	assertEquals(m5, e.getKey());
1409	<	assertEquals("E", e.getValue());
1396	>	Iterator<Map.Entry<Item,String>> ei = sm.entrySet().iterator();
1397	>	Map.Entry<Item,String> e;
1398	>	e = (ei.next());
1399	>	mustEqual(minusTwo, e.getKey());
1400	>	mustEqual("B", e.getValue());
1401	>	e = (ei.next());
1402	>	mustEqual(minusThree, e.getKey());
1403	>	mustEqual("C", e.getValue());
1404	>	e = (ei.next());
1405	>	mustEqual(minusFour, e.getKey());
1406	>	mustEqual("D", e.getValue());
1407	>	e = (ei.next());
1408	>	mustEqual(minusFive, e.getKey());
1409	>	mustEqual("E", e.getValue());
1410		assertFalse(i.hasNext());
1411
1412	<	SortedMap ssm = sm.tailMap(m4);
1413	<	assertEquals(m4, ssm.firstKey());
1414	<	assertEquals(m5, ssm.lastKey());
1415	<	assertEquals("D", ssm.remove(m4));
1416	<	assertEquals(1, ssm.size());
1417	<	assertEquals(3, sm.size());
1418	<	assertEquals(4, map.size());
1412	>	SortedMap<Item,String> ssm = sm.tailMap(minusFour);
1413	>	mustEqual(minusFour, ssm.firstKey());
1414	>	mustEqual(minusFive, ssm.lastKey());
1415	>	mustEqual("D", ssm.remove(minusFour));
1416	>	mustEqual(1, ssm.size());
1417	>	mustEqual(3, sm.size());
1418	>	mustEqual(4, map.size());
1419		}
1420
1421		}

Diff Legend

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