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.5 by jsr166, Mon Nov 16 04:57:10 2009 UTC vs.
Revision 1.20 by jsr166, Thu May 30 03:28:55 2013 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".
19	>	* Returns a new map from Integers 1-5 to Strings "A"-"E".
20		*/
21		private static NavigableMap map5() {
22	<	TreeMap map = new TreeMap();
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.subMap(one, true, seven, false);
34		}
35
36		private static NavigableMap map0() {
37	<	TreeMap map = new TreeMap();
37	>	TreeMap map = new TreeMap();
38		assertTrue(map.isEmpty());
39		return map.tailMap(one, true);
40		}
41
42		/**
43	<	* Create a map from Integers -5 to -1 to Strings "A"-"E".
43	>	* Returns a new map from Integers -5 to -1 to Strings "A"-"E".
44		*/
45		private static NavigableMap dmap5() {
46	<	TreeMap map = new TreeMap();
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");
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();
55	>	return map.descendingMap();
56		}
57
58		private static NavigableMap dmap0() {
59	<	TreeMap map = new TreeMap();
59	>	TreeMap map = new TreeMap();
60		assertTrue(map.isEmpty());
61		return map;
62		}
63
64		/**
65	<	*  clear removes all pairs
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(0, map.size());
71		}
72
75	–
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
144	–
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 177 | 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 191 | 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();
#	Line 206 | 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 246 | Line 242 | public class TreeSubMapTest extends JSR1
242
243		Map.Entry e4 = map.lowerEntry(zero);
244		assertNull(e4);
249	–
245		}
246
247		/**
#	Line 265 | Line 260 | public class TreeSubMapTest extends JSR1
260
261		Map.Entry e4 = map.higherEntry(six);
262		assertNull(e4);
268	–
263		}
264
265		/**
#	Line 284 | Line 278 | public class TreeSubMapTest extends JSR1
278
279		Map.Entry e4 = map.floorEntry(zero);
280		assertNull(e4);
287	–
281		}
282
283		/**
#	Line 303 | Line 296 | public class TreeSubMapTest extends JSR1
296
297		Map.Entry e4 = map.ceilingEntry(six);
298		assertNull(e4);
306	–
299		}
300
301		/**
#	Line 328 | Line 320 | public class TreeSubMapTest extends JSR1
320		try {
321		e.setValue("A");
322		shouldThrow();
323	<	} catch (Exception ok) {
332	<	}
323	>	} catch (UnsupportedOperationException success) {}
324		assertTrue(map.isEmpty());
325		Map.Entry f = map.firstEntry();
326		assertNull(f);
#	Line 359 | Line 350 | public class TreeSubMapTest extends JSR1
350		try {
351		e.setValue("E");
352		shouldThrow();
353	<	} catch (Exception ok) {
363	<	}
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 382 | 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		}
378
#	Line 396 | 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 407 | 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 418 | 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 429 | 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	<
447	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
448	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
449	<	NavigableMap r = (NavigableMap)in.readObject();
450	<	assertFalse(r.isEmpty());
451	<	assertEquals(q.size(), r.size());
452	<	assertTrue(q.equals(r));
453	<	assertTrue(r.equals(q));
454	<	} catch (Exception e){
455	<	e.printStackTrace();
456	<	unexpectedException();
457	<	}
428	>	public void testSerialization() throws Exception {
429	>	NavigableMap x = map5();
430	>	NavigableMap y = serialClone(x);
431	>
432	>	assertNotSame(x, y);
433	>	assertEquals(x.size(), y.size());
434	>	assertEquals(x.toString(), y.toString());
435	>	assertEquals(x, y);
436	>	assertEquals(y, x);
437		}
438
460	–
461	–
439		/**
440		* subMap returns map with keys in requested range
441		*/
#	Line 488 | 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 516 | 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 588 | 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
574		/**
575	<	*  clear removes all pairs
575	>	* clear removes all pairs
576		*/
577		public void testDescendingClear() {
578		NavigableMap map = dmap5();
579	<	map.clear();
580	<	assertEquals(map.size(), 0);
579	>	map.clear();
580	>	assertEquals(0, map.size());
581		}
582
606	–
583		/**
584	<	*  Maps with same contents are equal
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();
591	>	map1.clear();
592		assertFalse(map1.equals(map2));
593		assertFalse(map2.equals(map1));
594		}
595
596		/**
597	<	*  containsKey returns true for contained key
597	>	* containsKey returns true for contained key
598		*/
599		public void testDescendingContainsKey() {
600		NavigableMap map = dmap5();
601	<	assertTrue(map.containsKey(m1));
601	>	assertTrue(map.containsKey(m1));
602		assertFalse(map.containsKey(zero));
603		}
604
605		/**
606	<	*  containsValue returns true for held values
606	>	* containsValue returns true for held values
607		*/
608		public void testDescendingContainsValue() {
609		NavigableMap map = dmap5();
610	<	assertTrue(map.containsValue("A"));
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
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));
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
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());
631	>	assertTrue(empty.isEmpty());
632		assertFalse(map.isEmpty());
633		}
634
635		/**
636	<	*   firstKey returns first key
636	>	* firstKey returns first key
637		*/
638		public void testDescendingFirstKey() {
639		NavigableMap map = dmap5();
640	<	assertEquals(m1, map.firstKey());
640	>	assertEquals(m1, map.firstKey());
641		}
642
643		/**
644	<	*   lastKey returns last key
644	>	* lastKey returns last key
645		*/
646		public void testDescendingLastKey() {
647		NavigableMap map = dmap5();
648	<	assertEquals(m5, map.lastKey());
648	>	assertEquals(m5, map.lastKey());
649		}
650
675	–
651		/**
652	<	*   keySet returns a Set containing all the keys
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));
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
666	>	* keySet is ordered
667		*/
668		public void testDescendingKeySetOrder() {
669		NavigableMap map = dmap5();
670	<	Set s = map.keySet();
670	>	Set s = map.keySet();
671		Iterator i = s.iterator();
672		Integer last = (Integer)i.next();
673		assertEquals(last, m1);
#	Line 708 | Line 683 | public class TreeSubMapTest extends JSR1
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"));
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
696	>	* keySet.toArray returns contains all keys
697		*/
698		public void testDescendingAscendingKeySetToArray() {
699		NavigableMap map = dmap5();
700	<	Set s = map.keySet();
700	>	Set s = map.keySet();
701		Object[] ar = s.toArray();
702		assertTrue(s.containsAll(Arrays.asList(ar)));
703	<	assertEquals(5, ar.length);
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
709	>	* descendingkeySet.toArray returns contains all keys
710		*/
711		public void testDescendingDescendingKeySetToArray() {
712		NavigableMap map = dmap5();
713	<	Set s = map.descendingKeySet();
713	>	Set s = map.descendingKeySet();
714		Object[] ar = s.toArray();
715	<	assertEquals(5, ar.length);
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
722	>	* Values.toArray contains all values
723		*/
724		public void testDescendingValuesToArray() {
725		NavigableMap map = dmap5();
726	<	Collection v = map.values();
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"));
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
762	–
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());
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();
#	Line 780 | Line 754 | public class TreeSubMapTest extends JSR1
754		}
755
756		/**
757	<	*   putAll  adds all key-value pairs from the given map
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));
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
797	–
771		/**
772	<	*   remove removes the correct key-value pair from the map
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));
776	>	map.remove(m5);
777	>	assertEquals(4, map.size());
778	>	assertFalse(map.containsKey(m5));
779		}
780
781		/**
#	Line 821 | Line 794 | public class TreeSubMapTest extends JSR1
794
795		Map.Entry e4 = map.lowerEntry(zero);
796		assertNull(e4);
824	–
797		}
798
799		/**
#	Line 840 | Line 812 | public class TreeSubMapTest extends JSR1
812
813		Map.Entry e4 = map.higherEntry(m6);
814		assertNull(e4);
843	–
815		}
816
817		/**
#	Line 859 | Line 830 | public class TreeSubMapTest extends JSR1
830
831		Map.Entry e4 = map.floorEntry(zero);
832		assertNull(e4);
862	–
833		}
834
835		/**
#	Line 878 | Line 848 | public class TreeSubMapTest extends JSR1
848
849		Map.Entry e4 = map.ceilingEntry(m6);
850		assertNull(e4);
881	–
851		}
852
853		/**
#	Line 903 | Line 872 | public class TreeSubMapTest extends JSR1
872		try {
873		e.setValue("A");
874		shouldThrow();
875	<	} catch (Exception ok) {
907	<	}
875	>	} catch (UnsupportedOperationException success) {}
876		e = map.pollFirstEntry();
877		assertNull(e);
878		}
#	Line 931 | Line 899 | public class TreeSubMapTest extends JSR1
899		try {
900		e.setValue("E");
901		shouldThrow();
902	<	} catch (Exception ok) {
935	<	}
902	>	} catch (UnsupportedOperationException success) {}
903		e = map.pollLastEntry();
904		assertNull(e);
905		}
906
907		/**
908	<	*   size returns the correct values
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());
913	>	assertEquals(0, empty.size());
914	>	assertEquals(5, map.size());
915		}
916
917		/**
#	Line 954 | Line 921 | public class TreeSubMapTest extends JSR1
921		NavigableMap map = dmap5();
922		String s = map.toString();
923		for (int i = 1; i <= 5; ++i) {
924	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
924	>	assertTrue(s.contains(String.valueOf(i)));
925		}
926		}
927
#	Line 968 | Line 935 | public class TreeSubMapTest extends JSR1
935		NavigableMap c = dmap5();
936		c.get(null);
937		shouldThrow();
938	<	} catch (NullPointerException e){}
938	>	} catch (NullPointerException success) {}
939		}
940
941		/**
#	Line 979 | Line 946 | public class TreeSubMapTest extends JSR1
946		NavigableMap c = dmap5();
947		c.put(null, "whatever");
948		shouldThrow();
949	<	} catch (NullPointerException e){}
949	>	} catch (NullPointerException success) {}
950		}
951
952		/**
953		* A deserialized map equals original
954		*/
955	<	public void testDescendingSerialization() {
956	<	NavigableMap q = dmap5();
957	<
958	<	try {
959	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
960	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
961	<	out.writeObject(q);
962	<	out.close();
963	<
997	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
998	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
999	<	NavigableMap r = (NavigableMap)in.readObject();
1000	<	assertEquals(q.size(), r.size());
1001	<	assertTrue(q.equals(r));
1002	<	assertTrue(r.equals(q));
1003	<	} catch (Exception e){
1004	<	e.printStackTrace();
1005	<	unexpectedException();
1006	<	}
955	>	public void testDescendingSerialization() throws Exception {
956	>	NavigableMap x = dmap5();
957	>	NavigableMap y = serialClone(x);
958	>
959	>	assertNotSame(x, y);
960	>	assertEquals(x.size(), y.size());
961	>	assertEquals(x.toString(), y.toString());
962	>	assertEquals(x, y);
963	>	assertEquals(y, x);
964		}
965
1009	–
1010	–
966		/**
967		* subMap returns map with keys in requested range
968		*/
#	Line 1037 | Line 992 | public class TreeSubMapTest extends JSR1
992		assertEquals(1, sm.size());
993		assertEquals(m3, sm.firstKey());
994		assertEquals(m3, sm.lastKey());
995	<	assertTrue(sm.remove(m3) != null);
995	>	assertEquals("C", sm.remove(m3));
996		assertTrue(sm.isEmpty());
997		assertEquals(3, map.size());
998		}
#	Line 1065 | Line 1020 | public class TreeSubMapTest extends JSR1
1020		assertEquals(4, map.size());
1021		assertEquals(0, sm.size());
1022		assertTrue(sm.isEmpty());
1023	<	assertTrue(sm.remove(m3) == null);
1023	>	assertSame(sm.remove(m3), null);
1024		assertEquals(4, map.size());
1025		}
1026
#	Line 1137 | Line 1092 | public class TreeSubMapTest extends JSR1
1092		SortedMap ssm = sm.tailMap(m4);
1093		assertEquals(m4, ssm.firstKey());
1094		assertEquals(m5, ssm.lastKey());
1095	<	assertTrue(ssm.remove(m4) != null);
1095	>	assertEquals("D", ssm.remove(m4));
1096		assertEquals(1, ssm.size());
1097		assertEquals(3, sm.size());
1098		assertEquals(4, map.size());

Diff Legend

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