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.1 by dl, Thu Mar 31 15:24:29 2005 UTC vs.
Revision 1.23 by jsr166, Sat Apr 25 04:55:31 2015 UTC

#	Line 1 | Line 1
1		/*
2		* Written by Doug Lea with assistance from members of JCP JSR-166
3		* Expert Group and released to the public domain, as explained at
4	<	* http://creativecommons.org/licenses/publicdomain
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6
7	<	import junit.framework.*;
8	<	import java.util.*;
9	<	import java.util.concurrent.*;
10	<	import java.io.*;
7	>	import java.util.ArrayList;
8	>	import java.util.Arrays;
9	>	import java.util.Collection;
10	>	import java.util.Iterator;
11	>	import java.util.Map;
12	>	import java.util.NavigableMap;
13	>	import java.util.Set;
14	>	import java.util.SortedMap;
15	>	import java.util.TreeMap;
16	>
17	>	import junit.framework.Test;
18	>	import junit.framework.TestSuite;
19
20		public class TreeSubMapTest extends JSR166TestCase {
21		public static void main(String[] args) {
22	<	junit.textui.TestRunner.run (suite());
22	>	main(suite(), args);
23		}
24		public static Test suite() {
25	<	return new TestSuite(TreeSubMapTest.class);
25	>	return new TestSuite(TreeSubMapTest.class);
26		}
27
28		/**
29	<	* Create a map from Integers 1-5 to Strings "A"-"E".
29	>	* Returns a new map from Integers 1-5 to Strings "A"-"E".
30		*/
31	<	private static NavigableMap map5() {
32	<	TreeMap map = new TreeMap();
31	>	private static NavigableMap map5() {
32	>	TreeMap map = new TreeMap();
33		assertTrue(map.isEmpty());
34	<	map.put(zero, "Z");
35	<	map.put(one, "A");
36	<	map.put(five, "E");
37	<	map.put(three, "C");
38	<	map.put(two, "B");
39	<	map.put(four, "D");
40	<	map.put(seven, "F");
34	>	map.put(zero, "Z");
35	>	map.put(one, "A");
36	>	map.put(five, "E");
37	>	map.put(three, "C");
38	>	map.put(two, "B");
39	>	map.put(four, "D");
40	>	map.put(seven, "F");
41		assertFalse(map.isEmpty());
42		assertEquals(7, map.size());
43	<	return map.navigableSubMap(one, seven);
43	>	return map.subMap(one, true, seven, false);
44		}
45
46	<	private static NavigableMap map0() {
47	<	TreeMap map = new TreeMap();
46	>	private static NavigableMap map0() {
47	>	TreeMap map = new TreeMap();
48		assertTrue(map.isEmpty());
49	<	return map.navigableTailMap(one);
49	>	return map.tailMap(one, true);
50		}
51
52		/**
53	<	*  clear removes all pairs
53	>	* Returns a new map from Integers -5 to -1 to Strings "A"-"E".
54	>	*/
55	>	private static NavigableMap dmap5() {
56	>	TreeMap map = new TreeMap();
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");
63	>	assertFalse(map.isEmpty());
64	>	assertEquals(5, map.size());
65	>	return map.descendingMap();
66	>	}
67	>
68	>	private static NavigableMap dmap0() {
69	>	TreeMap map = new TreeMap();
70	>	assertTrue(map.isEmpty());
71	>	return map;
72	>	}
73	>
74	>	/**
75	>	* clear removes all pairs
76		*/
77		public void testClear() {
78		NavigableMap map = map5();
79	<	map.clear();
80	<	assertEquals(map.size(), 0);
79	>	map.clear();
80	>	assertEquals(0, map.size());
81		}
82
53	–
83		/**
84	<	*  Maps with same contents are equal
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);
91	<	map1.clear();
91	>	map1.clear();
92		assertFalse(map1.equals(map2));
93		assertFalse(map2.equals(map1));
94		}
95
96		/**
97	<	*  containsKey returns true for contained key
97	>	* containsKey returns true for contained key
98		*/
99		public void testContainsKey() {
100		NavigableMap map = map5();
101	<	assertTrue(map.containsKey(one));
101	>	assertTrue(map.containsKey(one));
102		assertFalse(map.containsKey(zero));
103		}
104
105		/**
106	<	*  containsValue returns true for held values
106	>	* containsValue returns true for held values
107		*/
108		public void testContainsValue() {
109		NavigableMap map = map5();
110	<	assertTrue(map.containsValue("A"));
110	>	assertTrue(map.containsValue("A"));
111		assertFalse(map.containsValue("Z"));
112		}
113
114		/**
115	<	*  get returns the correct element at the given key,
116	<	*  or null if not present
115	>	* get returns the correct element at the given key,
116	>	* or null if not present
117		*/
118		public void testGet() {
119		NavigableMap map = map5();
120	<	assertEquals("A", (String)map.get(one));
120	>	assertEquals("A", (String)map.get(one));
121		NavigableMap empty = map0();
122		assertNull(empty.get(one));
123		}
124
125		/**
126	<	*  isEmpty is true of empty map and false for non-empty
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();
131	<	assertTrue(empty.isEmpty());
131	>	assertTrue(empty.isEmpty());
132		assertFalse(map.isEmpty());
133		}
134
135		/**
136	<	*   firstKey returns first key
136	>	* firstKey returns first key
137		*/
138		public void testFirstKey() {
139		NavigableMap map = map5();
140	<	assertEquals(one, map.firstKey());
140	>	assertEquals(one, map.firstKey());
141		}
142
143		/**
144	<	*   lastKey returns last key
144	>	* lastKey returns last key
145		*/
146		public void testLastKey() {
147		NavigableMap map = map5();
148	<	assertEquals(five, map.lastKey());
148	>	assertEquals(five, map.lastKey());
149		}
150
122	–
151		/**
152	<	*   keySet returns a Set containing all the keys
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));
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));
163		}
164
165		/**
166	<	*   keySet is ordered
166	>	* keySet is ordered
167		*/
168		public void testKeySetOrder() {
169		NavigableMap map = map5();
170	<	Set s = map.keySet();
170	>	Set s = map.keySet();
171		Iterator i = s.iterator();
172		Integer last = (Integer)i.next();
173		assertEquals(last, one);
#	Line 155 | Line 183 | public class TreeSubMapTest extends JSR1
183		*/
184		public void testValues() {
185		NavigableMap map = map5();
186	<	Collection s = map.values();
187	<	assertEquals(5, s.size());
188	<	assertTrue(s.contains("A"));
189	<	assertTrue(s.contains("B"));
190	<	assertTrue(s.contains("C"));
191	<	assertTrue(s.contains("D"));
192	<	assertTrue(s.contains("E"));
186	>	Collection s = map.values();
187	>	assertEquals(5, s.size());
188	>	assertTrue(s.contains("A"));
189	>	assertTrue(s.contains("B"));
190	>	assertTrue(s.contains("C"));
191	>	assertTrue(s.contains("D"));
192	>	assertTrue(s.contains("E"));
193		}
194
195		/**
#	Line 169 | Line 197 | public class TreeSubMapTest extends JSR1
197		*/
198		public void testEntrySet() {
199		NavigableMap map = map5();
200	<	Set s = map.entrySet();
201	<	assertEquals(5, s.size());
200	>	Set s = map.entrySet();
201	>	assertEquals(5, s.size());
202		Iterator it = s.iterator();
203		while (it.hasNext()) {
204		Map.Entry e = (Map.Entry) it.next();
205	<	assertTrue(
205	>	assertTrue(
206		(e.getKey().equals(one) && e.getValue().equals("A")) ||
207		(e.getKey().equals(two) && e.getValue().equals("B")) ||
208		(e.getKey().equals(three) && e.getValue().equals("C")) ||
#	Line 184 | Line 212 | public class TreeSubMapTest extends JSR1
212		}
213
214		/**
215	<	*   putAll  adds all key-value pairs from the given map
215	>	* putAll adds all key-value pairs from the given map
216		*/
217		public void testPutAll() {
218		NavigableMap empty = map0();
219		NavigableMap map = map5();
220	<	empty.putAll(map);
221	<	assertEquals(5, empty.size());
222	<	assertTrue(empty.containsKey(one));
223	<	assertTrue(empty.containsKey(two));
224	<	assertTrue(empty.containsKey(three));
225	<	assertTrue(empty.containsKey(four));
226	<	assertTrue(empty.containsKey(five));
220	>	empty.putAll(map);
221	>	assertEquals(5, empty.size());
222	>	assertTrue(empty.containsKey(one));
223	>	assertTrue(empty.containsKey(two));
224	>	assertTrue(empty.containsKey(three));
225	>	assertTrue(empty.containsKey(four));
226	>	assertTrue(empty.containsKey(five));
227		}
228
229		/**
230	<	*   remove removes the correct key-value pair from the map
230	>	* remove removes the correct key-value pair from the map
231		*/
232		public void testRemove() {
233		NavigableMap map = map5();
234	<	map.remove(five);
235	<	assertEquals(4, map.size());
236	<	assertFalse(map.containsKey(five));
234	>	map.remove(five);
235	>	assertEquals(4, map.size());
236	>	assertFalse(map.containsKey(five));
237		}
238
239		/**
#	Line 224 | Line 252 | public class TreeSubMapTest extends JSR1
252
253		Map.Entry e4 = map.lowerEntry(zero);
254		assertNull(e4);
227	–
255		}
256
257		/**
#	Line 243 | Line 270 | public class TreeSubMapTest extends JSR1
270
271		Map.Entry e4 = map.higherEntry(six);
272		assertNull(e4);
246	–
273		}
274
275		/**
#	Line 262 | Line 288 | public class TreeSubMapTest extends JSR1
288
289		Map.Entry e4 = map.floorEntry(zero);
290		assertNull(e4);
265	–
291		}
292
293		/**
#	Line 281 | Line 306 | public class TreeSubMapTest extends JSR1
306
307		Map.Entry e4 = map.ceilingEntry(six);
308		assertNull(e4);
284	–
309		}
310
311		/**
#	Line 306 | Line 330 | public class TreeSubMapTest extends JSR1
330		try {
331		e.setValue("A");
332		shouldThrow();
333	<	} catch (Exception ok) {
310	<	}
333	>	} catch (UnsupportedOperationException success) {}
334		assertTrue(map.isEmpty());
335		Map.Entry f = map.firstEntry();
336		assertNull(f);
#	Line 337 | Line 360 | public class TreeSubMapTest extends JSR1
360		try {
361		e.setValue("E");
362		shouldThrow();
363	<	} catch (Exception ok) {
341	<	}
363	>	} catch (UnsupportedOperationException success) {}
364		e = map.pollLastEntry();
365		assertNull(e);
366		}
367
368		/**
369	<	*   size returns the correct values
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());
374	>	assertEquals(0, empty.size());
375	>	assertEquals(5, map.size());
376		}
377
378		/**
#	Line 360 | Line 382 | public class TreeSubMapTest extends JSR1
382		NavigableMap map = map5();
383		String s = map.toString();
384		for (int i = 1; i <= 5; ++i) {
385	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
385	>	assertTrue(s.contains(String.valueOf(i)));
386		}
387	<	}
387	>	}
388
389		// Exception tests
390
#	Line 370 | 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();
396		try {
374	–	NavigableMap c = map5();
397		c.get(null);
398		shouldThrow();
399	<	} catch(NullPointerException e){}
399	>	} catch (NullPointerException success) {}
400		}
401
402		/**
403		* containsKey(null) of nonempty map throws NPE
404		*/
405		public void testContainsKey_NullPointerException() {
406	+	NavigableMap c = map5();
407		try {
385	–	NavigableMap c = map5();
408		c.containsKey(null);
409		shouldThrow();
410	<	} catch(NullPointerException e){}
410	>	} catch (NullPointerException success) {}
411		}
412
413		/**
414		* put(null,x) throws NPE
415		*/
416		public void testPut1_NullPointerException() {
417	+	NavigableMap c = map5();
418		try {
396	–	NavigableMap c = map5();
419		c.put(null, "whatever");
420		shouldThrow();
421	<	} catch(NullPointerException e){}
421	>	} catch (NullPointerException success) {}
422		}
423
424		/**
425		* remove(null) throws NPE
426		*/
427		public void testRemove1_NullPointerException() {
428	+	NavigableMap c = map5();
429		try {
407	–	NavigableMap c = map5();
430		c.remove(null);
431		shouldThrow();
432	<	} catch(NullPointerException e){}
432	>	} catch (NullPointerException success) {}
433		}
434
435		/**
436		* A deserialized map equals original
437		*/
438	<	public void testSerialization() {
439	<	NavigableMap q = map5();
440	<
441	<	try {
442	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
443	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
444	<	out.writeObject(q);
445	<	out.close();
446	<
425	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
426	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
427	<	NavigableMap r = (NavigableMap)in.readObject();
428	<	assertFalse(r.isEmpty());
429	<	assertEquals(q.size(), r.size());
430	<	assertTrue(q.equals(r));
431	<	assertTrue(r.equals(q));
432	<	} catch(Exception e){
433	<	e.printStackTrace();
434	<	unexpectedException();
435	<	}
438	>	public void testSerialization() throws Exception {
439	>	NavigableMap x = map5();
440	>	NavigableMap 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);
447		}
448
438	–
439	–
449		/**
450		* subMap returns map with keys in requested range
451		*/
#	Line 466 | Line 475 | public class TreeSubMapTest extends JSR1
475		assertEquals(1, sm.size());
476		assertEquals(three, sm.firstKey());
477		assertEquals(three, sm.lastKey());
478	<	assertTrue(sm.remove(three) != null);
478	>	assertEquals("C", sm.remove(three));
479		assertTrue(sm.isEmpty());
480		assertEquals(3, map.size());
481		}
#	Line 494 | Line 503 | public class TreeSubMapTest extends JSR1
503		assertEquals(4, map.size());
504		assertEquals(0, sm.size());
505		assertTrue(sm.isEmpty());
506	<	assertTrue(sm.remove(three) == null);
506	>	assertSame(sm.remove(three), null);
507		assertEquals(4, map.size());
508		}
509
#	Line 566 | Line 575 | public class TreeSubMapTest extends JSR1
575		SortedMap ssm = sm.tailMap(four);
576		assertEquals(four, ssm.firstKey());
577		assertEquals(five, ssm.lastKey());
578	<	assertTrue(ssm.remove(four) != null);
578	>	assertEquals("D", ssm.remove(four));
579	>	assertEquals(1, ssm.size());
580	>	assertEquals(3, sm.size());
581	>	assertEquals(4, map.size());
582	>	}
583	>
584	>	/**
585	>	* clear removes all pairs
586	>	*/
587	>	public void testDescendingClear() {
588	>	NavigableMap map = dmap5();
589	>	map.clear();
590	>	assertEquals(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);
601	>	map1.clear();
602	>	assertFalse(map1.equals(map2));
603	>	assertFalse(map2.equals(map1));
604	>	}
605	>
606	>	/**
607	>	* containsKey returns true for contained key
608	>	*/
609	>	public void testDescendingContainsKey() {
610	>	NavigableMap map = dmap5();
611	>	assertTrue(map.containsKey(m1));
612	>	assertFalse(map.containsKey(zero));
613	>	}
614	>
615	>	/**
616	>	* containsValue returns true for held values
617	>	*/
618	>	public void testDescendingContainsValue() {
619	>	NavigableMap map = dmap5();
620	>	assertTrue(map.containsValue("A"));
621	>	assertFalse(map.containsValue("Z"));
622	>	}
623	>
624	>	/**
625	>	* get returns the correct element at the given key,
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));
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();
641	>	assertTrue(empty.isEmpty());
642	>	assertFalse(map.isEmpty());
643	>	}
644	>
645	>	/**
646	>	* firstKey returns first key
647	>	*/
648	>	public void testDescendingFirstKey() {
649	>	NavigableMap map = dmap5();
650	>	assertEquals(m1, map.firstKey());
651	>	}
652	>
653	>	/**
654	>	* lastKey returns last key
655	>	*/
656	>	public void testDescendingLastKey() {
657	>	NavigableMap map = dmap5();
658	>	assertEquals(m5, 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));
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);
684	>	while (i.hasNext()) {
685	>	Integer k = (Integer)i.next();
686	>	assertTrue(last.compareTo(k) > 0);
687	>	last = k;
688	>	}
689	>	}
690	>
691	>	/**
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());
698	>	assertTrue(s.contains("A"));
699	>	assertTrue(s.contains("B"));
700	>	assertTrue(s.contains("C"));
701	>	assertTrue(s.contains("D"));
702	>	assertTrue(s.contains("E"));
703	>	}
704	>
705	>	/**
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();
712	>	assertTrue(s.containsAll(Arrays.asList(ar)));
713	>	assertEquals(5, ar.length);
714	>	ar[0] = m10;
715	>	assertFalse(s.containsAll(Arrays.asList(ar)));
716	>	}
717	>
718	>	/**
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);
726	>	assertTrue(s.containsAll(Arrays.asList(ar)));
727	>	ar[0] = m10;
728	>	assertFalse(s.containsAll(Arrays.asList(ar)));
729	>	}
730	>
731	>	/**
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);
740	>	assertTrue(s.contains("A"));
741	>	assertTrue(s.contains("B"));
742	>	assertTrue(s.contains("C"));
743	>	assertTrue(s.contains("D"));
744	>	assertTrue(s.contains("E"));
745	>	}
746	>
747	>	/**
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();
755	>	while (it.hasNext()) {
756	>	Map.Entry e = (Map.Entry) 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")));
763	>	}
764	>	}
765	>
766	>	/**
767	>	* putAll adds all key-value pairs from the given map
768	>	*/
769	>	public void testDescendingPutAll() {
770	>	NavigableMap empty = dmap0();
771	>	NavigableMap 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));
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));
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());
798	>
799	>	Map.Entry e2 = map.lowerEntry(m6);
800	>	assertEquals(m5, e2.getKey());
801	>
802	>	Map.Entry e3 = map.lowerEntry(m1);
803	>	assertNull(e3);
804	>
805	>	Map.Entry e4 = map.lowerEntry(zero);
806	>	assertNull(e4);
807	>	}
808	>
809	>	/**
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());
816	>
817	>	Map.Entry e2 = map.higherEntry(zero);
818	>	assertEquals(m1, e2.getKey());
819	>
820	>	Map.Entry e3 = map.higherEntry(m5);
821	>	assertNull(e3);
822	>
823	>	Map.Entry e4 = map.higherEntry(m6);
824	>	assertNull(e4);
825	>	}
826	>
827	>	/**
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());
834	>
835	>	Map.Entry e2 = map.floorEntry(m6);
836	>	assertEquals(m5, e2.getKey());
837	>
838	>	Map.Entry e3 = map.floorEntry(m1);
839	>	assertEquals(m1, e3.getKey());
840	>
841	>	Map.Entry e4 = map.floorEntry(zero);
842	>	assertNull(e4);
843	>	}
844	>
845	>	/**
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());
852	>
853	>	Map.Entry e2 = map.ceilingEntry(zero);
854	>	assertEquals(m1, e2.getKey());
855	>
856	>	Map.Entry e3 = map.ceilingEntry(m5);
857	>	assertEquals(m5, e3.getKey());
858	>
859	>	Map.Entry e4 = map.ceilingEntry(m6);
860	>	assertNull(e4);
861	>	}
862	>
863	>	/**
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());
871	>	e = map.pollFirstEntry();
872	>	assertEquals(m2, e.getKey());
873	>	map.put(m1, "A");
874	>	e = map.pollFirstEntry();
875	>	assertEquals(m1, e.getKey());
876	>	assertEquals("A", e.getValue());
877	>	e = map.pollFirstEntry();
878	>	assertEquals(m3, e.getKey());
879	>	map.remove(m4);
880	>	e = map.pollFirstEntry();
881	>	assertEquals(m5, e.getKey());
882	>	try {
883	>	e.setValue("A");
884	>	shouldThrow();
885	>	} catch (UnsupportedOperationException success) {}
886	>	e = map.pollFirstEntry();
887	>	assertNull(e);
888	>	}
889	>
890	>	/**
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());
898	>	e = map.pollLastEntry();
899	>	assertEquals(m4, e.getKey());
900	>	map.put(m5, "E");
901	>	e = map.pollLastEntry();
902	>	assertEquals(m5, e.getKey());
903	>	assertEquals("E", e.getValue());
904	>	e = map.pollLastEntry();
905	>	assertEquals(m3, e.getKey());
906	>	map.remove(m2);
907	>	e = map.pollLastEntry();
908	>	assertEquals(m1, e.getKey());
909	>	try {
910	>	e.setValue("E");
911	>	shouldThrow();
912	>	} catch (UnsupportedOperationException success) {}
913	>	e = map.pollLastEntry();
914	>	assertNull(e);
915	>	}
916	>
917	>	/**
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());
925	>	}
926	>
927	>	/**
928	>	* toString contains toString of elements
929	>	*/
930	>	public void testDescendingToString() {
931	>	NavigableMap map = dmap5();
932	>	String s = map.toString();
933	>	for (int i = 1; i <= 5; ++i) {
934	>	assertTrue(s.contains(String.valueOf(i)));
935	>	}
936	>	}
937	>
938	>	// Exception testDescendings
939	>
940	>	/**
941	>	* get(null) of nonempty map throws NPE
942	>	*/
943	>	public void testDescendingGet_NullPointerException() {
944	>	NavigableMap c = dmap5();
945	>	try {
946	>	c.get(null);
947	>	shouldThrow();
948	>	} catch (NullPointerException success) {}
949	>	}
950	>
951	>	/**
952	>	* put(null,x) throws NPE
953	>	*/
954	>	public void testDescendingPut1_NullPointerException() {
955	>	NavigableMap c = dmap5();
956	>	try {
957	>	c.put(null, "whatever");
958	>	shouldThrow();
959	>	} catch (NullPointerException success) {}
960	>	}
961	>
962	>	/**
963	>	* A deserialized map equals original
964	>	*/
965	>	public void testDescendingSerialization() throws Exception {
966	>	NavigableMap x = dmap5();
967	>	NavigableMap 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);
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);
996	>	assertFalse(i.hasNext());
997	>	Iterator 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));
1006	>	assertTrue(sm.isEmpty());
1007	>	assertEquals(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);
1025	>	assertFalse(i.hasNext());
1026	>	Iterator 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());
1032	>	assertTrue(sm.isEmpty());
1033	>	assertSame(sm.remove(m3), null);
1034	>	assertEquals(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);
1056	>	assertFalse(i.hasNext());
1057	>	sm.clear();
1058	>	assertTrue(sm.isEmpty());
1059	>	assertEquals(2, map.size());
1060	>	assertEquals(m4, 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);
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());
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());
1109		}
1110	<
1110	>
1111		}

Diff Legend

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