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.2 by dl, Wed Apr 19 15:10:54 2006 UTC vs.
Revision 1.16 by jsr166, Tue May 31 16:16:24 2011 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.*;
9
10		public class TreeSubMapTest extends JSR166TestCase {
11		public static void main(String[] args) {
12	<	junit.textui.TestRunner.run (suite());
12	>	junit.textui.TestRunner.run(suite());
13		}
14		public static Test suite() {
15	<	return new TestSuite(TreeSubMapTest.class);
15	>	return new TestSuite(TreeSubMapTest.class);
16		}
17
18		/**
19		* Create a map from Integers 1-5 to Strings "A"-"E".
20		*/
21	<	private static NavigableMap map5() {
22	<	TreeMap map = new TreeMap();
21	>	private static NavigableMap map5() {
22	>	TreeMap map = new TreeMap();
23		assertTrue(map.isEmpty());
24	<	map.put(zero, "Z");
25	<	map.put(one, "A");
26	<	map.put(five, "E");
27	<	map.put(three, "C");
28	<	map.put(two, "B");
29	<	map.put(four, "D");
30	<	map.put(seven, "F");
24	>	map.put(zero, "Z");
25	>	map.put(one, "A");
26	>	map.put(five, "E");
27	>	map.put(three, "C");
28	>	map.put(two, "B");
29	>	map.put(four, "D");
30	>	map.put(seven, "F");
31		assertFalse(map.isEmpty());
32		assertEquals(7, map.size());
33	<	return map.navigableSubMap(one, true, seven, false);
33	>	return map.subMap(one, true, seven, false);
34		}
35
36	<	private static NavigableMap map0() {
37	<	TreeMap map = new TreeMap();
36	>	private static NavigableMap map0() {
37	>	TreeMap map = new TreeMap();
38		assertTrue(map.isEmpty());
39	<	return map.navigableTailMap(one, true);
39	>	return map.tailMap(one, true);
40		}
41
42		/**
43	<	*  clear removes all pairs
43	>	* Create a map from Integers -5 to -1 to Strings "A"-"E".
44	>	*/
45	>	private static NavigableMap dmap5() {
46	>	TreeMap map = new TreeMap();
47	>	assertTrue(map.isEmpty());
48	>	map.put(m1, "A");
49	>	map.put(m5, "E");
50	>	map.put(m3, "C");
51	>	map.put(m2, "B");
52	>	map.put(m4, "D");
53	>	assertFalse(map.isEmpty());
54	>	assertEquals(5, map.size());
55	>	return map.descendingMap();
56	>	}
57	>
58	>	private static NavigableMap dmap0() {
59	>	TreeMap map = new TreeMap();
60	>	assertTrue(map.isEmpty());
61	>	return map;
62	>	}
63	>
64	>	/**
65	>	* clear removes all pairs
66		*/
67		public void testClear() {
68		NavigableMap map = map5();
69	<	map.clear();
70	<	assertEquals(map.size(), 0);
69	>	map.clear();
70	>	assertEquals(map.size(), 0);
71		}
72
53	–
73		/**
74	<	*  Maps with same contents are equal
74	>	* Maps with same contents are equal
75		*/
76		public void testEquals() {
77		NavigableMap map1 = map5();
78		NavigableMap map2 = map5();
79		assertEquals(map1, map2);
80		assertEquals(map2, map1);
81	<	map1.clear();
81	>	map1.clear();
82		assertFalse(map1.equals(map2));
83		assertFalse(map2.equals(map1));
84		}
85
86		/**
87	<	*  containsKey returns true for contained key
87	>	* containsKey returns true for contained key
88		*/
89		public void testContainsKey() {
90		NavigableMap map = map5();
91	<	assertTrue(map.containsKey(one));
91	>	assertTrue(map.containsKey(one));
92		assertFalse(map.containsKey(zero));
93		}
94
95		/**
96	<	*  containsValue returns true for held values
96	>	* containsValue returns true for held values
97		*/
98		public void testContainsValue() {
99		NavigableMap map = map5();
100	<	assertTrue(map.containsValue("A"));
100	>	assertTrue(map.containsValue("A"));
101		assertFalse(map.containsValue("Z"));
102		}
103
104		/**
105	<	*  get returns the correct element at the given key,
106	<	*  or null if not present
105	>	* get returns the correct element at the given key,
106	>	* or null if not present
107		*/
108		public void testGet() {
109		NavigableMap map = map5();
110	<	assertEquals("A", (String)map.get(one));
110	>	assertEquals("A", (String)map.get(one));
111		NavigableMap empty = map0();
112		assertNull(empty.get(one));
113		}
114
115		/**
116	<	*  isEmpty is true of empty map and false for non-empty
116	>	* isEmpty is true of empty map and false for non-empty
117		*/
118		public void testIsEmpty() {
119		NavigableMap empty = map0();
120		NavigableMap map = map5();
121	<	assertTrue(empty.isEmpty());
121	>	assertTrue(empty.isEmpty());
122		assertFalse(map.isEmpty());
123		}
124
125		/**
126	<	*   firstKey returns first key
126	>	* firstKey returns first key
127		*/
128		public void testFirstKey() {
129		NavigableMap map = map5();
130	<	assertEquals(one, map.firstKey());
130	>	assertEquals(one, map.firstKey());
131		}
132
133		/**
134	<	*   lastKey returns last key
134	>	* lastKey returns last key
135		*/
136		public void testLastKey() {
137		NavigableMap map = map5();
138	<	assertEquals(five, map.lastKey());
138	>	assertEquals(five, map.lastKey());
139		}
140
122	–
141		/**
142	<	*   keySet returns a Set containing all the keys
142	>	* keySet returns a Set containing all the keys
143		*/
144		public void testKeySet() {
145		NavigableMap map = map5();
146	<	Set s = map.keySet();
147	<	assertEquals(5, s.size());
148	<	assertTrue(s.contains(one));
149	<	assertTrue(s.contains(two));
150	<	assertTrue(s.contains(three));
151	<	assertTrue(s.contains(four));
152	<	assertTrue(s.contains(five));
146	>	Set s = map.keySet();
147	>	assertEquals(5, s.size());
148	>	assertTrue(s.contains(one));
149	>	assertTrue(s.contains(two));
150	>	assertTrue(s.contains(three));
151	>	assertTrue(s.contains(four));
152	>	assertTrue(s.contains(five));
153		}
154
155		/**
156	<	*   keySet is ordered
156	>	* keySet is ordered
157		*/
158		public void testKeySetOrder() {
159		NavigableMap map = map5();
160	<	Set s = map.keySet();
160	>	Set s = map.keySet();
161		Iterator i = s.iterator();
162		Integer last = (Integer)i.next();
163		assertEquals(last, one);
#	Line 155 | Line 173 | public class TreeSubMapTest extends JSR1
173		*/
174		public void testValues() {
175		NavigableMap map = map5();
176	<	Collection s = map.values();
177	<	assertEquals(5, s.size());
178	<	assertTrue(s.contains("A"));
179	<	assertTrue(s.contains("B"));
180	<	assertTrue(s.contains("C"));
181	<	assertTrue(s.contains("D"));
182	<	assertTrue(s.contains("E"));
176	>	Collection s = map.values();
177	>	assertEquals(5, s.size());
178	>	assertTrue(s.contains("A"));
179	>	assertTrue(s.contains("B"));
180	>	assertTrue(s.contains("C"));
181	>	assertTrue(s.contains("D"));
182	>	assertTrue(s.contains("E"));
183		}
184
185		/**
#	Line 169 | Line 187 | public class TreeSubMapTest extends JSR1
187		*/
188		public void testEntrySet() {
189		NavigableMap map = map5();
190	<	Set s = map.entrySet();
191	<	assertEquals(5, s.size());
190	>	Set s = map.entrySet();
191	>	assertEquals(5, s.size());
192		Iterator it = s.iterator();
193		while (it.hasNext()) {
194		Map.Entry e = (Map.Entry) it.next();
195	<	assertTrue(
195	>	assertTrue(
196		(e.getKey().equals(one) && e.getValue().equals("A")) ||
197		(e.getKey().equals(two) && e.getValue().equals("B")) ||
198		(e.getKey().equals(three) && e.getValue().equals("C")) ||
#	Line 184 | Line 202 | public class TreeSubMapTest extends JSR1
202		}
203
204		/**
205	<	*   putAll  adds all key-value pairs from the given map
205	>	* putAll adds all key-value pairs from the given map
206		*/
207		public void testPutAll() {
208		NavigableMap empty = map0();
209		NavigableMap map = map5();
210	<	empty.putAll(map);
211	<	assertEquals(5, empty.size());
212	<	assertTrue(empty.containsKey(one));
213	<	assertTrue(empty.containsKey(two));
214	<	assertTrue(empty.containsKey(three));
215	<	assertTrue(empty.containsKey(four));
216	<	assertTrue(empty.containsKey(five));
210	>	empty.putAll(map);
211	>	assertEquals(5, empty.size());
212	>	assertTrue(empty.containsKey(one));
213	>	assertTrue(empty.containsKey(two));
214	>	assertTrue(empty.containsKey(three));
215	>	assertTrue(empty.containsKey(four));
216	>	assertTrue(empty.containsKey(five));
217		}
218
219		/**
220	<	*   remove removes the correct key-value pair from the map
220	>	* remove removes the correct key-value pair from the map
221		*/
222		public void testRemove() {
223		NavigableMap map = map5();
224	<	map.remove(five);
225	<	assertEquals(4, map.size());
226	<	assertFalse(map.containsKey(five));
224	>	map.remove(five);
225	>	assertEquals(4, map.size());
226	>	assertFalse(map.containsKey(five));
227		}
228
229		/**
#	Line 224 | Line 242 | public class TreeSubMapTest extends JSR1
242
243		Map.Entry e4 = map.lowerEntry(zero);
244		assertNull(e4);
227	–
245		}
246
247		/**
#	Line 243 | Line 260 | public class TreeSubMapTest extends JSR1
260
261		Map.Entry e4 = map.higherEntry(six);
262		assertNull(e4);
246	–
263		}
264
265		/**
#	Line 262 | Line 278 | public class TreeSubMapTest extends JSR1
278
279		Map.Entry e4 = map.floorEntry(zero);
280		assertNull(e4);
265	–
281		}
282
283		/**
#	Line 281 | Line 296 | public class TreeSubMapTest extends JSR1
296
297		Map.Entry e4 = map.ceilingEntry(six);
298		assertNull(e4);
284	–
299		}
300
301		/**
#	Line 306 | Line 320 | public class TreeSubMapTest extends JSR1
320		try {
321		e.setValue("A");
322		shouldThrow();
323	<	} catch (Exception ok) {
310	<	}
323	>	} catch (UnsupportedOperationException success) {}
324		assertTrue(map.isEmpty());
325		Map.Entry f = map.firstEntry();
326		assertNull(f);
#	Line 337 | Line 350 | public class TreeSubMapTest extends JSR1
350		try {
351		e.setValue("E");
352		shouldThrow();
353	<	} catch (Exception ok) {
341	<	}
353	>	} catch (UnsupportedOperationException success) {}
354		e = map.pollLastEntry();
355		assertNull(e);
356		}
357
358		/**
359	<	*   size returns the correct values
359	>	* size returns the correct values
360		*/
361		public void testSize() {
362		NavigableMap map = map5();
363		NavigableMap empty = map0();
364	<	assertEquals(0, empty.size());
365	<	assertEquals(5, map.size());
364	>	assertEquals(0, empty.size());
365	>	assertEquals(5, map.size());
366		}
367
368		/**
#	Line 360 | Line 372 | public class TreeSubMapTest extends JSR1
372		NavigableMap map = map5();
373		String s = map.toString();
374		for (int i = 1; i <= 5; ++i) {
375	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
375	>	assertTrue(s.contains(String.valueOf(i)));
376		}
377	<	}
377	>	}
378
379		// Exception tests
380
#	Line 374 | Line 386 | public class TreeSubMapTest extends JSR1
386		NavigableMap c = map5();
387		c.get(null);
388		shouldThrow();
389	<	} catch(NullPointerException e){}
389	>	} catch (NullPointerException success) {}
390		}
391
392		/**
#	Line 385 | Line 397 | public class TreeSubMapTest extends JSR1
397		NavigableMap c = map5();
398		c.containsKey(null);
399		shouldThrow();
400	<	} catch(NullPointerException e){}
400	>	} catch (NullPointerException success) {}
401		}
402
403		/**
#	Line 396 | Line 408 | public class TreeSubMapTest extends JSR1
408		NavigableMap c = map5();
409		c.put(null, "whatever");
410		shouldThrow();
411	<	} catch(NullPointerException e){}
411	>	} catch (NullPointerException success) {}
412		}
413
414		/**
#	Line 407 | Line 419 | public class TreeSubMapTest extends JSR1
419		NavigableMap c = map5();
420		c.remove(null);
421		shouldThrow();
422	<	} catch(NullPointerException e){}
422	>	} catch (NullPointerException success) {}
423		}
424
425		/**
426		* A deserialized map equals original
427		*/
428	<	public void testSerialization() {
429	<	NavigableMap q = map5();
430	<
431	<	try {
432	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
433	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
434	<	out.writeObject(q);
435	<	out.close();
436	<
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	<	}
428	>	public void testSerialization() throws Exception {
429	>	NavigableMap x = map5();
430	>	NavigableMap y = serialClone(x);
431	>
432	>	assertTrue(x != y);
433	>	assertEquals(x.size(), y.size());
434	>	assertEquals(x.toString(), y.toString());
435	>	assertEquals(x, y);
436	>	assertEquals(y, x);
437		}
438
438	–
439	–
439		/**
440		* subMap returns map with keys in requested range
441		*/
#	Line 466 | Line 465 | public class TreeSubMapTest extends JSR1
465		assertEquals(1, sm.size());
466		assertEquals(three, sm.firstKey());
467		assertEquals(three, sm.lastKey());
468	<	assertTrue(sm.remove(three) != null);
468	>	assertEquals("C", sm.remove(three));
469		assertTrue(sm.isEmpty());
470		assertEquals(3, map.size());
471		}
#	Line 494 | Line 493 | public class TreeSubMapTest extends JSR1
493		assertEquals(4, map.size());
494		assertEquals(0, sm.size());
495		assertTrue(sm.isEmpty());
496	<	assertTrue(sm.remove(three) == null);
496	>	assertSame(sm.remove(three), null);
497		assertEquals(4, map.size());
498		}
499
#	Line 566 | Line 565 | public class TreeSubMapTest extends JSR1
565		SortedMap ssm = sm.tailMap(four);
566		assertEquals(four, ssm.firstKey());
567		assertEquals(five, ssm.lastKey());
568	<	assertTrue(ssm.remove(four) != null);
568	>	assertEquals("D", ssm.remove(four));
569		assertEquals(1, ssm.size());
570		assertEquals(3, sm.size());
571		assertEquals(4, map.size());
572		}
573	<
573	>
574	>	/**
575	>	* clear removes all pairs
576	>	*/
577	>	public void testDescendingClear() {
578	>	NavigableMap map = dmap5();
579	>	map.clear();
580	>	assertEquals(map.size(), 0);
581	>	}
582	>
583	>	/**
584	>	* Maps with same contents are equal
585	>	*/
586	>	public void testDescendingEquals() {
587	>	NavigableMap map1 = dmap5();
588	>	NavigableMap map2 = dmap5();
589	>	assertEquals(map1, map2);
590	>	assertEquals(map2, map1);
591	>	map1.clear();
592	>	assertFalse(map1.equals(map2));
593	>	assertFalse(map2.equals(map1));
594	>	}
595	>
596	>	/**
597	>	* containsKey returns true for contained key
598	>	*/
599	>	public void testDescendingContainsKey() {
600	>	NavigableMap map = dmap5();
601	>	assertTrue(map.containsKey(m1));
602	>	assertFalse(map.containsKey(zero));
603	>	}
604	>
605	>	/**
606	>	* containsValue returns true for held values
607	>	*/
608	>	public void testDescendingContainsValue() {
609	>	NavigableMap map = dmap5();
610	>	assertTrue(map.containsValue("A"));
611	>	assertFalse(map.containsValue("Z"));
612	>	}
613	>
614	>	/**
615	>	* get returns the correct element at the given key,
616	>	* or null if not present
617	>	*/
618	>	public void testDescendingGet() {
619	>	NavigableMap map = dmap5();
620	>	assertEquals("A", (String)map.get(m1));
621	>	NavigableMap empty = dmap0();
622	>	assertNull(empty.get(m1));
623	>	}
624	>
625	>	/**
626	>	* isEmpty is true of empty map and false for non-empty
627	>	*/
628	>	public void testDescendingIsEmpty() {
629	>	NavigableMap empty = dmap0();
630	>	NavigableMap map = dmap5();
631	>	assertTrue(empty.isEmpty());
632	>	assertFalse(map.isEmpty());
633	>	}
634	>
635	>	/**
636	>	* firstKey returns first key
637	>	*/
638	>	public void testDescendingFirstKey() {
639	>	NavigableMap map = dmap5();
640	>	assertEquals(m1, map.firstKey());
641	>	}
642	>
643	>	/**
644	>	* lastKey returns last key
645	>	*/
646	>	public void testDescendingLastKey() {
647	>	NavigableMap map = dmap5();
648	>	assertEquals(m5, map.lastKey());
649	>	}
650	>
651	>	/**
652	>	* keySet returns a Set containing all the keys
653	>	*/
654	>	public void testDescendingKeySet() {
655	>	NavigableMap map = dmap5();
656	>	Set s = map.keySet();
657	>	assertEquals(5, s.size());
658	>	assertTrue(s.contains(m1));
659	>	assertTrue(s.contains(m2));
660	>	assertTrue(s.contains(m3));
661	>	assertTrue(s.contains(m4));
662	>	assertTrue(s.contains(m5));
663	>	}
664	>
665	>	/**
666	>	* keySet is ordered
667	>	*/
668	>	public void testDescendingKeySetOrder() {
669	>	NavigableMap map = dmap5();
670	>	Set s = map.keySet();
671	>	Iterator i = s.iterator();
672	>	Integer last = (Integer)i.next();
673	>	assertEquals(last, m1);
674	>	while (i.hasNext()) {
675	>	Integer k = (Integer)i.next();
676	>	assertTrue(last.compareTo(k) > 0);
677	>	last = k;
678	>	}
679	>	}
680	>
681	>	/**
682	>	* values collection contains all values
683	>	*/
684	>	public void testDescendingValues() {
685	>	NavigableMap map = dmap5();
686	>	Collection s = map.values();
687	>	assertEquals(5, s.size());
688	>	assertTrue(s.contains("A"));
689	>	assertTrue(s.contains("B"));
690	>	assertTrue(s.contains("C"));
691	>	assertTrue(s.contains("D"));
692	>	assertTrue(s.contains("E"));
693	>	}
694	>
695	>	/**
696	>	* keySet.toArray returns contains all keys
697	>	*/
698	>	public void testDescendingAscendingKeySetToArray() {
699	>	NavigableMap map = dmap5();
700	>	Set s = map.keySet();
701	>	Object[] ar = s.toArray();
702	>	assertTrue(s.containsAll(Arrays.asList(ar)));
703	>	assertEquals(5, ar.length);
704	>	ar[0] = m10;
705	>	assertFalse(s.containsAll(Arrays.asList(ar)));
706	>	}
707	>
708	>	/**
709	>	* descendingkeySet.toArray returns contains all keys
710	>	*/
711	>	public void testDescendingDescendingKeySetToArray() {
712	>	NavigableMap map = dmap5();
713	>	Set s = map.descendingKeySet();
714	>	Object[] ar = s.toArray();
715	>	assertEquals(5, ar.length);
716	>	assertTrue(s.containsAll(Arrays.asList(ar)));
717	>	ar[0] = m10;
718	>	assertFalse(s.containsAll(Arrays.asList(ar)));
719	>	}
720	>
721	>	/**
722	>	* Values.toArray contains all values
723	>	*/
724	>	public void testDescendingValuesToArray() {
725	>	NavigableMap map = dmap5();
726	>	Collection v = map.values();
727	>	Object[] ar = v.toArray();
728	>	ArrayList s = new ArrayList(Arrays.asList(ar));
729	>	assertEquals(5, ar.length);
730	>	assertTrue(s.contains("A"));
731	>	assertTrue(s.contains("B"));
732	>	assertTrue(s.contains("C"));
733	>	assertTrue(s.contains("D"));
734	>	assertTrue(s.contains("E"));
735	>	}
736	>
737	>	/**
738	>	* entrySet contains all pairs
739	>	*/
740	>	public void testDescendingEntrySet() {
741	>	NavigableMap map = dmap5();
742	>	Set s = map.entrySet();
743	>	assertEquals(5, s.size());
744	>	Iterator it = s.iterator();
745	>	while (it.hasNext()) {
746	>	Map.Entry e = (Map.Entry) it.next();
747	>	assertTrue(
748	>	(e.getKey().equals(m1) && e.getValue().equals("A")) ||
749	>	(e.getKey().equals(m2) && e.getValue().equals("B")) ||
750	>	(e.getKey().equals(m3) && e.getValue().equals("C")) ||
751	>	(e.getKey().equals(m4) && e.getValue().equals("D")) ||
752	>	(e.getKey().equals(m5) && e.getValue().equals("E")));
753	>	}
754	>	}
755	>
756	>	/**
757	>	* putAll adds all key-value pairs from the given map
758	>	*/
759	>	public void testDescendingPutAll() {
760	>	NavigableMap empty = dmap0();
761	>	NavigableMap map = dmap5();
762	>	empty.putAll(map);
763	>	assertEquals(5, empty.size());
764	>	assertTrue(empty.containsKey(m1));
765	>	assertTrue(empty.containsKey(m2));
766	>	assertTrue(empty.containsKey(m3));
767	>	assertTrue(empty.containsKey(m4));
768	>	assertTrue(empty.containsKey(m5));
769	>	}
770	>
771	>	/**
772	>	* remove removes the correct key-value pair from the map
773	>	*/
774	>	public void testDescendingRemove() {
775	>	NavigableMap map = dmap5();
776	>	map.remove(m5);
777	>	assertEquals(4, map.size());
778	>	assertFalse(map.containsKey(m5));
779	>	}
780	>
781	>	/**
782	>	* lowerEntry returns preceding entry.
783	>	*/
784	>	public void testDescendingLowerEntry() {
785	>	NavigableMap map = dmap5();
786	>	Map.Entry e1 = map.lowerEntry(m3);
787	>	assertEquals(m2, e1.getKey());
788	>
789	>	Map.Entry e2 = map.lowerEntry(m6);
790	>	assertEquals(m5, e2.getKey());
791	>
792	>	Map.Entry e3 = map.lowerEntry(m1);
793	>	assertNull(e3);
794	>
795	>	Map.Entry e4 = map.lowerEntry(zero);
796	>	assertNull(e4);
797	>	}
798	>
799	>	/**
800	>	* higherEntry returns next entry.
801	>	*/
802	>	public void testDescendingHigherEntry() {
803	>	NavigableMap map = dmap5();
804	>	Map.Entry e1 = map.higherEntry(m3);
805	>	assertEquals(m4, e1.getKey());
806	>
807	>	Map.Entry e2 = map.higherEntry(zero);
808	>	assertEquals(m1, e2.getKey());
809	>
810	>	Map.Entry e3 = map.higherEntry(m5);
811	>	assertNull(e3);
812	>
813	>	Map.Entry e4 = map.higherEntry(m6);
814	>	assertNull(e4);
815	>	}
816	>
817	>	/**
818	>	* floorEntry returns preceding entry.
819	>	*/
820	>	public void testDescendingFloorEntry() {
821	>	NavigableMap map = dmap5();
822	>	Map.Entry e1 = map.floorEntry(m3);
823	>	assertEquals(m3, e1.getKey());
824	>
825	>	Map.Entry e2 = map.floorEntry(m6);
826	>	assertEquals(m5, e2.getKey());
827	>
828	>	Map.Entry e3 = map.floorEntry(m1);
829	>	assertEquals(m1, e3.getKey());
830	>
831	>	Map.Entry e4 = map.floorEntry(zero);
832	>	assertNull(e4);
833	>	}
834	>
835	>	/**
836	>	* ceilingEntry returns next entry.
837	>	*/
838	>	public void testDescendingCeilingEntry() {
839	>	NavigableMap map = dmap5();
840	>	Map.Entry e1 = map.ceilingEntry(m3);
841	>	assertEquals(m3, e1.getKey());
842	>
843	>	Map.Entry e2 = map.ceilingEntry(zero);
844	>	assertEquals(m1, e2.getKey());
845	>
846	>	Map.Entry e3 = map.ceilingEntry(m5);
847	>	assertEquals(m5, e3.getKey());
848	>
849	>	Map.Entry e4 = map.ceilingEntry(m6);
850	>	assertNull(e4);
851	>	}
852	>
853	>	/**
854	>	* pollFirstEntry returns entries in order
855	>	*/
856	>	public void testDescendingPollFirstEntry() {
857	>	NavigableMap map = dmap5();
858	>	Map.Entry e = map.pollFirstEntry();
859	>	assertEquals(m1, e.getKey());
860	>	assertEquals("A", e.getValue());
861	>	e = map.pollFirstEntry();
862	>	assertEquals(m2, e.getKey());
863	>	map.put(m1, "A");
864	>	e = map.pollFirstEntry();
865	>	assertEquals(m1, e.getKey());
866	>	assertEquals("A", e.getValue());
867	>	e = map.pollFirstEntry();
868	>	assertEquals(m3, e.getKey());
869	>	map.remove(m4);
870	>	e = map.pollFirstEntry();
871	>	assertEquals(m5, e.getKey());
872	>	try {
873	>	e.setValue("A");
874	>	shouldThrow();
875	>	} catch (UnsupportedOperationException success) {}
876	>	e = map.pollFirstEntry();
877	>	assertNull(e);
878	>	}
879	>
880	>	/**
881	>	* pollLastEntry returns entries in order
882	>	*/
883	>	public void testDescendingPollLastEntry() {
884	>	NavigableMap map = dmap5();
885	>	Map.Entry e = map.pollLastEntry();
886	>	assertEquals(m5, e.getKey());
887	>	assertEquals("E", e.getValue());
888	>	e = map.pollLastEntry();
889	>	assertEquals(m4, e.getKey());
890	>	map.put(m5, "E");
891	>	e = map.pollLastEntry();
892	>	assertEquals(m5, e.getKey());
893	>	assertEquals("E", e.getValue());
894	>	e = map.pollLastEntry();
895	>	assertEquals(m3, e.getKey());
896	>	map.remove(m2);
897	>	e = map.pollLastEntry();
898	>	assertEquals(m1, e.getKey());
899	>	try {
900	>	e.setValue("E");
901	>	shouldThrow();
902	>	} catch (UnsupportedOperationException success) {}
903	>	e = map.pollLastEntry();
904	>	assertNull(e);
905	>	}
906	>
907	>	/**
908	>	* size returns the correct values
909	>	*/
910	>	public void testDescendingSize() {
911	>	NavigableMap map = dmap5();
912	>	NavigableMap empty = dmap0();
913	>	assertEquals(0, empty.size());
914	>	assertEquals(5, map.size());
915	>	}
916	>
917	>	/**
918	>	* toString contains toString of elements
919	>	*/
920	>	public void testDescendingToString() {
921	>	NavigableMap map = dmap5();
922	>	String s = map.toString();
923	>	for (int i = 1; i <= 5; ++i) {
924	>	assertTrue(s.contains(String.valueOf(i)));
925	>	}
926	>	}
927	>
928	>	// Exception testDescendings
929	>
930	>	/**
931	>	* get(null) of nonempty map throws NPE
932	>	*/
933	>	public void testDescendingGet_NullPointerException() {
934	>	try {
935	>	NavigableMap c = dmap5();
936	>	c.get(null);
937	>	shouldThrow();
938	>	} catch (NullPointerException success) {}
939	>	}
940	>
941	>	/**
942	>	* put(null,x) throws NPE
943	>	*/
944	>	public void testDescendingPut1_NullPointerException() {
945	>	try {
946	>	NavigableMap c = dmap5();
947	>	c.put(null, "whatever");
948	>	shouldThrow();
949	>	} catch (NullPointerException success) {}
950	>	}
951	>
952	>	/**
953	>	* A deserialized map equals original
954	>	*/
955	>	public void testDescendingSerialization() throws Exception {
956	>	NavigableMap x = dmap5();
957	>	NavigableMap y = serialClone(x);
958	>
959	>	assertTrue(x != y);
960	>	assertEquals(x.size(), y.size());
961	>	assertEquals(x.toString(), y.toString());
962	>	assertEquals(x, y);
963	>	assertEquals(y, x);
964	>	}
965	>
966	>	/**
967	>	* subMap returns map with keys in requested range
968	>	*/
969	>	public void testDescendingSubMapContents() {
970	>	NavigableMap map = dmap5();
971	>	SortedMap sm = map.subMap(m2, m4);
972	>	assertEquals(m2, sm.firstKey());
973	>	assertEquals(m3, sm.lastKey());
974	>	assertEquals(2, sm.size());
975	>	assertFalse(sm.containsKey(m1));
976	>	assertTrue(sm.containsKey(m2));
977	>	assertTrue(sm.containsKey(m3));
978	>	assertFalse(sm.containsKey(m4));
979	>	assertFalse(sm.containsKey(m5));
980	>	Iterator i = sm.keySet().iterator();
981	>	Object k;
982	>	k = (Integer)(i.next());
983	>	assertEquals(m2, k);
984	>	k = (Integer)(i.next());
985	>	assertEquals(m3, k);
986	>	assertFalse(i.hasNext());
987	>	Iterator j = sm.keySet().iterator();
988	>	j.next();
989	>	j.remove();
990	>	assertFalse(map.containsKey(m2));
991	>	assertEquals(4, map.size());
992	>	assertEquals(1, sm.size());
993	>	assertEquals(m3, sm.firstKey());
994	>	assertEquals(m3, sm.lastKey());
995	>	assertEquals("C", sm.remove(m3));
996	>	assertTrue(sm.isEmpty());
997	>	assertEquals(3, map.size());
998	>	}
999	>
1000	>	public void testDescendingSubMapContents2() {
1001	>	NavigableMap map = dmap5();
1002	>	SortedMap sm = map.subMap(m2, m3);
1003	>	assertEquals(1, sm.size());
1004	>	assertEquals(m2, sm.firstKey());
1005	>	assertEquals(m2, sm.lastKey());
1006	>	assertFalse(sm.containsKey(m1));
1007	>	assertTrue(sm.containsKey(m2));
1008	>	assertFalse(sm.containsKey(m3));
1009	>	assertFalse(sm.containsKey(m4));
1010	>	assertFalse(sm.containsKey(m5));
1011	>	Iterator i = sm.keySet().iterator();
1012	>	Object k;
1013	>	k = (Integer)(i.next());
1014	>	assertEquals(m2, k);
1015	>	assertFalse(i.hasNext());
1016	>	Iterator j = sm.keySet().iterator();
1017	>	j.next();
1018	>	j.remove();
1019	>	assertFalse(map.containsKey(m2));
1020	>	assertEquals(4, map.size());
1021	>	assertEquals(0, sm.size());
1022	>	assertTrue(sm.isEmpty());
1023	>	assertSame(sm.remove(m3), null);
1024	>	assertEquals(4, map.size());
1025	>	}
1026	>
1027	>	/**
1028	>	* headMap returns map with keys in requested range
1029	>	*/
1030	>	public void testDescendingHeadMapContents() {
1031	>	NavigableMap map = dmap5();
1032	>	SortedMap sm = map.headMap(m4);
1033	>	assertTrue(sm.containsKey(m1));
1034	>	assertTrue(sm.containsKey(m2));
1035	>	assertTrue(sm.containsKey(m3));
1036	>	assertFalse(sm.containsKey(m4));
1037	>	assertFalse(sm.containsKey(m5));
1038	>	Iterator i = sm.keySet().iterator();
1039	>	Object k;
1040	>	k = (Integer)(i.next());
1041	>	assertEquals(m1, k);
1042	>	k = (Integer)(i.next());
1043	>	assertEquals(m2, k);
1044	>	k = (Integer)(i.next());
1045	>	assertEquals(m3, k);
1046	>	assertFalse(i.hasNext());
1047	>	sm.clear();
1048	>	assertTrue(sm.isEmpty());
1049	>	assertEquals(2, map.size());
1050	>	assertEquals(m4, map.firstKey());
1051	>	}
1052	>
1053	>	/**
1054	>	* headMap returns map with keys in requested range
1055	>	*/
1056	>	public void testDescendingTailMapContents() {
1057	>	NavigableMap map = dmap5();
1058	>	SortedMap sm = map.tailMap(m2);
1059	>	assertFalse(sm.containsKey(m1));
1060	>	assertTrue(sm.containsKey(m2));
1061	>	assertTrue(sm.containsKey(m3));
1062	>	assertTrue(sm.containsKey(m4));
1063	>	assertTrue(sm.containsKey(m5));
1064	>	Iterator i = sm.keySet().iterator();
1065	>	Object k;
1066	>	k = (Integer)(i.next());
1067	>	assertEquals(m2, k);
1068	>	k = (Integer)(i.next());
1069	>	assertEquals(m3, k);
1070	>	k = (Integer)(i.next());
1071	>	assertEquals(m4, k);
1072	>	k = (Integer)(i.next());
1073	>	assertEquals(m5, k);
1074	>	assertFalse(i.hasNext());
1075	>
1076	>	Iterator ei = sm.entrySet().iterator();
1077	>	Map.Entry e;
1078	>	e = (Map.Entry)(ei.next());
1079	>	assertEquals(m2, e.getKey());
1080	>	assertEquals("B", e.getValue());
1081	>	e = (Map.Entry)(ei.next());
1082	>	assertEquals(m3, e.getKey());
1083	>	assertEquals("C", e.getValue());
1084	>	e = (Map.Entry)(ei.next());
1085	>	assertEquals(m4, e.getKey());
1086	>	assertEquals("D", e.getValue());
1087	>	e = (Map.Entry)(ei.next());
1088	>	assertEquals(m5, e.getKey());
1089	>	assertEquals("E", e.getValue());
1090	>	assertFalse(i.hasNext());
1091	>
1092	>	SortedMap ssm = sm.tailMap(m4);
1093	>	assertEquals(m4, ssm.firstKey());
1094	>	assertEquals(m5, ssm.lastKey());
1095	>	assertEquals("D", ssm.remove(m4));
1096	>	assertEquals(1, ssm.size());
1097	>	assertEquals(3, sm.size());
1098	>	assertEquals(4, map.size());
1099	>	}
1100	>
1101		}

Diff Legend

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