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.10 by jsr166, Tue Dec 1 06:03:49 2009 UTC

#	Line 11 | Line 11 | import java.io.*;
11
12		public class TreeSubMapTest extends JSR166TestCase {
13		public static void main(String[] args) {
14	<	junit.textui.TestRunner.run (suite());
14	>	junit.textui.TestRunner.run (suite());
15		}
16		public static Test suite() {
17	<	return new TestSuite(TreeSubMapTest.class);
17	>	return new TestSuite(TreeSubMapTest.class);
18		}
19
20		/**
21		* Create a map from Integers 1-5 to Strings "A"-"E".
22		*/
23		private static NavigableMap map5() {
24	<	TreeMap map = new TreeMap();
24	>	TreeMap map = new TreeMap();
25		assertTrue(map.isEmpty());
26	<	map.put(zero, "Z");
27	<	map.put(one, "A");
28	<	map.put(five, "E");
29	<	map.put(three, "C");
30	<	map.put(two, "B");
31	<	map.put(four, "D");
32	<	map.put(seven, "F");
26	>	map.put(zero, "Z");
27	>	map.put(one, "A");
28	>	map.put(five, "E");
29	>	map.put(three, "C");
30	>	map.put(two, "B");
31	>	map.put(four, "D");
32	>	map.put(seven, "F");
33		assertFalse(map.isEmpty());
34		assertEquals(7, map.size());
35		return map.subMap(one, true, seven, false);
36		}
37
38		private static NavigableMap map0() {
39	<	TreeMap map = new TreeMap();
39	>	TreeMap map = new TreeMap();
40		assertTrue(map.isEmpty());
41		return map.tailMap(one, true);
42		}
#	Line 45 | Line 45 | public class TreeSubMapTest extends JSR1
45		* Create a map from Integers -5 to -1 to Strings "A"-"E".
46		*/
47		private static NavigableMap dmap5() {
48	<	TreeMap map = new TreeMap();
48	>	TreeMap map = new TreeMap();
49		assertTrue(map.isEmpty());
50	<	map.put(m1, "A");
51	<	map.put(m5, "E");
52	<	map.put(m3, "C");
53	<	map.put(m2, "B");
54	<	map.put(m4, "D");
50	>	map.put(m1, "A");
51	>	map.put(m5, "E");
52	>	map.put(m3, "C");
53	>	map.put(m2, "B");
54	>	map.put(m4, "D");
55		assertFalse(map.isEmpty());
56		assertEquals(5, map.size());
57	<	return map.descendingMap();
57	>	return map.descendingMap();
58		}
59
60		private static NavigableMap dmap0() {
61	<	TreeMap map = new TreeMap();
61	>	TreeMap map = new TreeMap();
62		assertTrue(map.isEmpty());
63		return map;
64		}
#	Line 68 | Line 68 | public class TreeSubMapTest extends JSR1
68		*/
69		public void testClear() {
70		NavigableMap map = map5();
71	<	map.clear();
72	<	assertEquals(map.size(), 0);
71	>	map.clear();
72	>	assertEquals(map.size(), 0);
73		}
74
75
#	Line 81 | Line 81 | public class TreeSubMapTest extends JSR1
81		NavigableMap map2 = map5();
82		assertEquals(map1, map2);
83		assertEquals(map2, map1);
84	<	map1.clear();
84	>	map1.clear();
85		assertFalse(map1.equals(map2));
86		assertFalse(map2.equals(map1));
87		}
#	Line 91 | Line 91 | public class TreeSubMapTest extends JSR1
91		*/
92		public void testContainsKey() {
93		NavigableMap map = map5();
94	<	assertTrue(map.containsKey(one));
94	>	assertTrue(map.containsKey(one));
95		assertFalse(map.containsKey(zero));
96		}
97
#	Line 100 | Line 100 | public class TreeSubMapTest extends JSR1
100		*/
101		public void testContainsValue() {
102		NavigableMap map = map5();
103	<	assertTrue(map.containsValue("A"));
103	>	assertTrue(map.containsValue("A"));
104		assertFalse(map.containsValue("Z"));
105		}
106
#	Line 110 | Line 110 | public class TreeSubMapTest extends JSR1
110		*/
111		public void testGet() {
112		NavigableMap map = map5();
113	<	assertEquals("A", (String)map.get(one));
113	>	assertEquals("A", (String)map.get(one));
114		NavigableMap empty = map0();
115		assertNull(empty.get(one));
116		}
#	Line 121 | Line 121 | public class TreeSubMapTest extends JSR1
121		public void testIsEmpty() {
122		NavigableMap empty = map0();
123		NavigableMap map = map5();
124	<	assertTrue(empty.isEmpty());
124	>	assertTrue(empty.isEmpty());
125		assertFalse(map.isEmpty());
126		}
127
#	Line 130 | Line 130 | public class TreeSubMapTest extends JSR1
130		*/
131		public void testFirstKey() {
132		NavigableMap map = map5();
133	<	assertEquals(one, map.firstKey());
133	>	assertEquals(one, map.firstKey());
134		}
135
136		/**
#	Line 138 | Line 138 | public class TreeSubMapTest extends JSR1
138		*/
139		public void testLastKey() {
140		NavigableMap map = map5();
141	<	assertEquals(five, map.lastKey());
141	>	assertEquals(five, map.lastKey());
142		}
143
144
#	Line 147 | Line 147 | public class TreeSubMapTest extends JSR1
147		*/
148		public void testKeySet() {
149		NavigableMap map = map5();
150	<	Set s = map.keySet();
151	<	assertEquals(5, s.size());
152	<	assertTrue(s.contains(one));
153	<	assertTrue(s.contains(two));
154	<	assertTrue(s.contains(three));
155	<	assertTrue(s.contains(four));
156	<	assertTrue(s.contains(five));
150	>	Set s = map.keySet();
151	>	assertEquals(5, s.size());
152	>	assertTrue(s.contains(one));
153	>	assertTrue(s.contains(two));
154	>	assertTrue(s.contains(three));
155	>	assertTrue(s.contains(four));
156	>	assertTrue(s.contains(five));
157		}
158
159		/**
#	Line 161 | Line 161 | public class TreeSubMapTest extends JSR1
161		*/
162		public void testKeySetOrder() {
163		NavigableMap map = map5();
164	<	Set s = map.keySet();
164	>	Set s = map.keySet();
165		Iterator i = s.iterator();
166		Integer last = (Integer)i.next();
167		assertEquals(last, one);
#	Line 177 | Line 177 | public class TreeSubMapTest extends JSR1
177		*/
178		public void testValues() {
179		NavigableMap map = map5();
180	<	Collection s = map.values();
181	<	assertEquals(5, s.size());
182	<	assertTrue(s.contains("A"));
183	<	assertTrue(s.contains("B"));
184	<	assertTrue(s.contains("C"));
185	<	assertTrue(s.contains("D"));
186	<	assertTrue(s.contains("E"));
180	>	Collection s = map.values();
181	>	assertEquals(5, s.size());
182	>	assertTrue(s.contains("A"));
183	>	assertTrue(s.contains("B"));
184	>	assertTrue(s.contains("C"));
185	>	assertTrue(s.contains("D"));
186	>	assertTrue(s.contains("E"));
187		}
188
189		/**
#	Line 191 | Line 191 | public class TreeSubMapTest extends JSR1
191		*/
192		public void testEntrySet() {
193		NavigableMap map = map5();
194	<	Set s = map.entrySet();
195	<	assertEquals(5, s.size());
194	>	Set s = map.entrySet();
195	>	assertEquals(5, s.size());
196		Iterator it = s.iterator();
197		while (it.hasNext()) {
198		Map.Entry e = (Map.Entry) it.next();
#	Line 211 | Line 211 | public class TreeSubMapTest extends JSR1
211		public void testPutAll() {
212		NavigableMap empty = map0();
213		NavigableMap map = map5();
214	<	empty.putAll(map);
215	<	assertEquals(5, empty.size());
216	<	assertTrue(empty.containsKey(one));
217	<	assertTrue(empty.containsKey(two));
218	<	assertTrue(empty.containsKey(three));
219	<	assertTrue(empty.containsKey(four));
220	<	assertTrue(empty.containsKey(five));
214	>	empty.putAll(map);
215	>	assertEquals(5, empty.size());
216	>	assertTrue(empty.containsKey(one));
217	>	assertTrue(empty.containsKey(two));
218	>	assertTrue(empty.containsKey(three));
219	>	assertTrue(empty.containsKey(four));
220	>	assertTrue(empty.containsKey(five));
221		}
222
223		/**
#	Line 225 | Line 225 | public class TreeSubMapTest extends JSR1
225		*/
226		public void testRemove() {
227		NavigableMap map = map5();
228	<	map.remove(five);
229	<	assertEquals(4, map.size());
230	<	assertFalse(map.containsKey(five));
228	>	map.remove(five);
229	>	assertEquals(4, map.size());
230	>	assertFalse(map.containsKey(five));
231		}
232
233		/**
#	Line 328 | Line 328 | public class TreeSubMapTest extends JSR1
328		try {
329		e.setValue("A");
330		shouldThrow();
331	<	} catch (Exception ok) {
332	<	}
331	>	} catch (UnsupportedOperationException success) {}
332		assertTrue(map.isEmpty());
333		Map.Entry f = map.firstEntry();
334		assertNull(f);
#	Line 359 | Line 358 | public class TreeSubMapTest extends JSR1
358		try {
359		e.setValue("E");
360		shouldThrow();
361	<	} catch (Exception ok) {
363	<	}
361	>	} catch (UnsupportedOperationException success) {}
362		e = map.pollLastEntry();
363		assertNull(e);
364		}
#	Line 371 | Line 369 | public class TreeSubMapTest extends JSR1
369		public void testSize() {
370		NavigableMap map = map5();
371		NavigableMap empty = map0();
372	<	assertEquals(0, empty.size());
373	<	assertEquals(5, map.size());
372	>	assertEquals(0, empty.size());
373	>	assertEquals(5, map.size());
374		}
375
376		/**
#	Line 396 | Line 394 | public class TreeSubMapTest extends JSR1
394		NavigableMap c = map5();
395		c.get(null);
396		shouldThrow();
397	<	} catch (NullPointerException e){}
397	>	} catch (NullPointerException success) {}
398		}
399
400		/**
#	Line 407 | Line 405 | public class TreeSubMapTest extends JSR1
405		NavigableMap c = map5();
406		c.containsKey(null);
407		shouldThrow();
408	<	} catch (NullPointerException e){}
408	>	} catch (NullPointerException success) {}
409		}
410
411		/**
#	Line 418 | Line 416 | public class TreeSubMapTest extends JSR1
416		NavigableMap c = map5();
417		c.put(null, "whatever");
418		shouldThrow();
419	<	} catch (NullPointerException e){}
419	>	} catch (NullPointerException success) {}
420		}
421
422		/**
#	Line 429 | Line 427 | public class TreeSubMapTest extends JSR1
427		NavigableMap c = map5();
428		c.remove(null);
429		shouldThrow();
430	<	} catch (NullPointerException e){}
430	>	} catch (NullPointerException success) {}
431		}
432
433		/**
434		* A deserialized map equals original
435		*/
436	<	public void testSerialization() {
436	>	public void testSerialization() throws Exception {
437		NavigableMap q = map5();
438
439	<	try {
440	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
441	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
442	<	out.writeObject(q);
443	<	out.close();
444	<
445	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
446	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
447	<	NavigableMap r = (NavigableMap)in.readObject();
448	<	assertFalse(r.isEmpty());
449	<	assertEquals(q.size(), r.size());
450	<	assertTrue(q.equals(r));
453	<	assertTrue(r.equals(q));
454	<	} catch (Exception e){
455	<	e.printStackTrace();
456	<	unexpectedException();
457	<	}
439	>	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
440	>	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
441	>	out.writeObject(q);
442	>	out.close();
443	>
444	>	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
445	>	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
446	>	NavigableMap r = (NavigableMap)in.readObject();
447	>	assertFalse(r.isEmpty());
448	>	assertEquals(q.size(), r.size());
449	>	assertTrue(q.equals(r));
450	>	assertTrue(r.equals(q));
451		}
452
453
#	Line 488 | Line 481 | public class TreeSubMapTest extends JSR1
481		assertEquals(1, sm.size());
482		assertEquals(three, sm.firstKey());
483		assertEquals(three, sm.lastKey());
484	<	assertTrue(sm.remove(three) != null);
484	>	assertEquals("C", sm.remove(three));
485		assertTrue(sm.isEmpty());
486		assertEquals(3, map.size());
487		}
#	Line 516 | Line 509 | public class TreeSubMapTest extends JSR1
509		assertEquals(4, map.size());
510		assertEquals(0, sm.size());
511		assertTrue(sm.isEmpty());
512	<	assertTrue(sm.remove(three) == null);
512	>	assertSame(sm.remove(three), null);
513		assertEquals(4, map.size());
514		}
515
#	Line 588 | Line 581 | public class TreeSubMapTest extends JSR1
581		SortedMap ssm = sm.tailMap(four);
582		assertEquals(four, ssm.firstKey());
583		assertEquals(five, ssm.lastKey());
584	<	assertTrue(ssm.remove(four) != null);
584	>	assertEquals("D", ssm.remove(four));
585		assertEquals(1, ssm.size());
586		assertEquals(3, sm.size());
587		assertEquals(4, map.size());
#	Line 599 | Line 592 | public class TreeSubMapTest extends JSR1
592		*/
593		public void testDescendingClear() {
594		NavigableMap map = dmap5();
595	<	map.clear();
596	<	assertEquals(map.size(), 0);
595	>	map.clear();
596	>	assertEquals(map.size(), 0);
597		}
598
599
#	Line 612 | Line 605 | public class TreeSubMapTest extends JSR1
605		NavigableMap map2 = dmap5();
606		assertEquals(map1, map2);
607		assertEquals(map2, map1);
608	<	map1.clear();
608	>	map1.clear();
609		assertFalse(map1.equals(map2));
610		assertFalse(map2.equals(map1));
611		}
#	Line 622 | Line 615 | public class TreeSubMapTest extends JSR1
615		*/
616		public void testDescendingContainsKey() {
617		NavigableMap map = dmap5();
618	<	assertTrue(map.containsKey(m1));
618	>	assertTrue(map.containsKey(m1));
619		assertFalse(map.containsKey(zero));
620		}
621
#	Line 631 | Line 624 | public class TreeSubMapTest extends JSR1
624		*/
625		public void testDescendingContainsValue() {
626		NavigableMap map = dmap5();
627	<	assertTrue(map.containsValue("A"));
627	>	assertTrue(map.containsValue("A"));
628		assertFalse(map.containsValue("Z"));
629		}
630
#	Line 641 | Line 634 | public class TreeSubMapTest extends JSR1
634		*/
635		public void testDescendingGet() {
636		NavigableMap map = dmap5();
637	<	assertEquals("A", (String)map.get(m1));
637	>	assertEquals("A", (String)map.get(m1));
638		NavigableMap empty = dmap0();
639		assertNull(empty.get(m1));
640		}
#	Line 652 | Line 645 | public class TreeSubMapTest extends JSR1
645		public void testDescendingIsEmpty() {
646		NavigableMap empty = dmap0();
647		NavigableMap map = dmap5();
648	<	assertTrue(empty.isEmpty());
648	>	assertTrue(empty.isEmpty());
649		assertFalse(map.isEmpty());
650		}
651
#	Line 661 | Line 654 | public class TreeSubMapTest extends JSR1
654		*/
655		public void testDescendingFirstKey() {
656		NavigableMap map = dmap5();
657	<	assertEquals(m1, map.firstKey());
657	>	assertEquals(m1, map.firstKey());
658		}
659
660		/**
#	Line 669 | Line 662 | public class TreeSubMapTest extends JSR1
662		*/
663		public void testDescendingLastKey() {
664		NavigableMap map = dmap5();
665	<	assertEquals(m5, map.lastKey());
665	>	assertEquals(m5, map.lastKey());
666		}
667
668
#	Line 678 | Line 671 | public class TreeSubMapTest extends JSR1
671		*/
672		public void testDescendingKeySet() {
673		NavigableMap map = dmap5();
674	<	Set s = map.keySet();
675	<	assertEquals(5, s.size());
676	<	assertTrue(s.contains(m1));
677	<	assertTrue(s.contains(m2));
678	<	assertTrue(s.contains(m3));
679	<	assertTrue(s.contains(m4));
680	<	assertTrue(s.contains(m5));
674	>	Set s = map.keySet();
675	>	assertEquals(5, s.size());
676	>	assertTrue(s.contains(m1));
677	>	assertTrue(s.contains(m2));
678	>	assertTrue(s.contains(m3));
679	>	assertTrue(s.contains(m4));
680	>	assertTrue(s.contains(m5));
681		}
682
683		/**
#	Line 692 | Line 685 | public class TreeSubMapTest extends JSR1
685		*/
686		public void testDescendingKeySetOrder() {
687		NavigableMap map = dmap5();
688	<	Set s = map.keySet();
688	>	Set s = map.keySet();
689		Iterator i = s.iterator();
690		Integer last = (Integer)i.next();
691		assertEquals(last, m1);
#	Line 708 | Line 701 | public class TreeSubMapTest extends JSR1
701		*/
702		public void testDescendingValues() {
703		NavigableMap map = dmap5();
704	<	Collection s = map.values();
705	<	assertEquals(5, s.size());
706	<	assertTrue(s.contains("A"));
707	<	assertTrue(s.contains("B"));
708	<	assertTrue(s.contains("C"));
709	<	assertTrue(s.contains("D"));
710	<	assertTrue(s.contains("E"));
704	>	Collection s = map.values();
705	>	assertEquals(5, s.size());
706	>	assertTrue(s.contains("A"));
707	>	assertTrue(s.contains("B"));
708	>	assertTrue(s.contains("C"));
709	>	assertTrue(s.contains("D"));
710	>	assertTrue(s.contains("E"));
711		}
712
713		/**
#	Line 722 | Line 715 | public class TreeSubMapTest extends JSR1
715		*/
716		public void testDescendingAscendingKeySetToArray() {
717		NavigableMap map = dmap5();
718	<	Set s = map.keySet();
718	>	Set s = map.keySet();
719		Object[] ar = s.toArray();
720		assertTrue(s.containsAll(Arrays.asList(ar)));
721	<	assertEquals(5, ar.length);
721	>	assertEquals(5, ar.length);
722		ar[0] = m10;
723		assertFalse(s.containsAll(Arrays.asList(ar)));
724		}
#	Line 735 | Line 728 | public class TreeSubMapTest extends JSR1
728		*/
729		public void testDescendingDescendingKeySetToArray() {
730		NavigableMap map = dmap5();
731	<	Set s = map.descendingKeySet();
731	>	Set s = map.descendingKeySet();
732		Object[] ar = s.toArray();
733	<	assertEquals(5, ar.length);
733	>	assertEquals(5, ar.length);
734		assertTrue(s.containsAll(Arrays.asList(ar)));
735		ar[0] = m10;
736		assertFalse(s.containsAll(Arrays.asList(ar)));
#	Line 748 | Line 741 | public class TreeSubMapTest extends JSR1
741		*/
742		public void testDescendingValuesToArray() {
743		NavigableMap map = dmap5();
744	<	Collection v = map.values();
744	>	Collection v = map.values();
745		Object[] ar = v.toArray();
746		ArrayList s = new ArrayList(Arrays.asList(ar));
747	<	assertEquals(5, ar.length);
748	<	assertTrue(s.contains("A"));
749	<	assertTrue(s.contains("B"));
750	<	assertTrue(s.contains("C"));
751	<	assertTrue(s.contains("D"));
752	<	assertTrue(s.contains("E"));
747	>	assertEquals(5, ar.length);
748	>	assertTrue(s.contains("A"));
749	>	assertTrue(s.contains("B"));
750	>	assertTrue(s.contains("C"));
751	>	assertTrue(s.contains("D"));
752	>	assertTrue(s.contains("E"));
753		}
754
755
#	Line 765 | Line 758 | public class TreeSubMapTest extends JSR1
758		*/
759		public void testDescendingEntrySet() {
760		NavigableMap map = dmap5();
761	<	Set s = map.entrySet();
762	<	assertEquals(5, s.size());
761	>	Set s = map.entrySet();
762	>	assertEquals(5, s.size());
763		Iterator it = s.iterator();
764		while (it.hasNext()) {
765		Map.Entry e = (Map.Entry) it.next();
#	Line 785 | Line 778 | public class TreeSubMapTest extends JSR1
778		public void testDescendingPutAll() {
779		NavigableMap empty = dmap0();
780		NavigableMap map = dmap5();
781	<	empty.putAll(map);
782	<	assertEquals(5, empty.size());
783	<	assertTrue(empty.containsKey(m1));
784	<	assertTrue(empty.containsKey(m2));
785	<	assertTrue(empty.containsKey(m3));
786	<	assertTrue(empty.containsKey(m4));
787	<	assertTrue(empty.containsKey(m5));
781	>	empty.putAll(map);
782	>	assertEquals(5, empty.size());
783	>	assertTrue(empty.containsKey(m1));
784	>	assertTrue(empty.containsKey(m2));
785	>	assertTrue(empty.containsKey(m3));
786	>	assertTrue(empty.containsKey(m4));
787	>	assertTrue(empty.containsKey(m5));
788		}
789
790
#	Line 800 | Line 793 | public class TreeSubMapTest extends JSR1
793		*/
794		public void testDescendingRemove() {
795		NavigableMap map = dmap5();
796	<	map.remove(m5);
797	<	assertEquals(4, map.size());
798	<	assertFalse(map.containsKey(m5));
796	>	map.remove(m5);
797	>	assertEquals(4, map.size());
798	>	assertFalse(map.containsKey(m5));
799		}
800
801		/**
#	Line 903 | Line 896 | public class TreeSubMapTest extends JSR1
896		try {
897		e.setValue("A");
898		shouldThrow();
899	<	} catch (Exception ok) {
907	<	}
899	>	} catch (UnsupportedOperationException success) {}
900		e = map.pollFirstEntry();
901		assertNull(e);
902		}
#	Line 931 | Line 923 | public class TreeSubMapTest extends JSR1
923		try {
924		e.setValue("E");
925		shouldThrow();
926	<	} catch (Exception ok) {
935	<	}
926	>	} catch (UnsupportedOperationException success) {}
927		e = map.pollLastEntry();
928		assertNull(e);
929		}
#	Line 943 | Line 934 | public class TreeSubMapTest extends JSR1
934		public void testDescendingSize() {
935		NavigableMap map = dmap5();
936		NavigableMap empty = dmap0();
937	<	assertEquals(0, empty.size());
938	<	assertEquals(5, map.size());
937	>	assertEquals(0, empty.size());
938	>	assertEquals(5, map.size());
939		}
940
941		/**
#	Line 968 | Line 959 | public class TreeSubMapTest extends JSR1
959		NavigableMap c = dmap5();
960		c.get(null);
961		shouldThrow();
962	<	} catch (NullPointerException e){}
962	>	} catch (NullPointerException success) {}
963		}
964
965		/**
#	Line 979 | Line 970 | public class TreeSubMapTest extends JSR1
970		NavigableMap c = dmap5();
971		c.put(null, "whatever");
972		shouldThrow();
973	<	} catch (NullPointerException e){}
973	>	} catch (NullPointerException success) {}
974		}
975
976		/**
977		* A deserialized map equals original
978		*/
979	<	public void testDescendingSerialization() {
979	>	public void testDescendingSerialization() throws Exception {
980		NavigableMap q = dmap5();
981
982	<	try {
983	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
984	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
985	<	out.writeObject(q);
986	<	out.close();
987	<
988	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
989	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
990	<	NavigableMap r = (NavigableMap)in.readObject();
991	<	assertEquals(q.size(), r.size());
992	<	assertTrue(q.equals(r));
1002	<	assertTrue(r.equals(q));
1003	<	} catch (Exception e){
1004	<	e.printStackTrace();
1005	<	unexpectedException();
1006	<	}
982	>	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
983	>	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
984	>	out.writeObject(q);
985	>	out.close();
986	>
987	>	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
988	>	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
989	>	NavigableMap r = (NavigableMap)in.readObject();
990	>	assertEquals(q.size(), r.size());
991	>	assertTrue(q.equals(r));
992	>	assertTrue(r.equals(q));
993		}
994
995
1010	–
996		/**
997		* subMap returns map with keys in requested range
998		*/
#	Line 1037 | Line 1022 | public class TreeSubMapTest extends JSR1
1022		assertEquals(1, sm.size());
1023		assertEquals(m3, sm.firstKey());
1024		assertEquals(m3, sm.lastKey());
1025	<	assertTrue(sm.remove(m3) != null);
1025	>	assertEquals("C", sm.remove(m3));
1026		assertTrue(sm.isEmpty());
1027		assertEquals(3, map.size());
1028		}
#	Line 1065 | Line 1050 | public class TreeSubMapTest extends JSR1
1050		assertEquals(4, map.size());
1051		assertEquals(0, sm.size());
1052		assertTrue(sm.isEmpty());
1053	<	assertTrue(sm.remove(m3) == null);
1053	>	assertSame(sm.remove(m3), null);
1054		assertEquals(4, map.size());
1055		}
1056
#	Line 1137 | Line 1122 | public class TreeSubMapTest extends JSR1
1122		SortedMap ssm = sm.tailMap(m4);
1123		assertEquals(m4, ssm.firstKey());
1124		assertEquals(m5, ssm.lastKey());
1125	<	assertTrue(ssm.remove(m4) != null);
1125	>	assertEquals("D", ssm.remove(m4));
1126		assertEquals(1, ssm.size());
1127		assertEquals(3, sm.size());
1128		assertEquals(4, map.size());

Diff Legend

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