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.4 by jsr166, Mon Nov 2 20:28:32 2009 UTC vs.
Revision 1.11 by jsr166, Tue Dec 1 09:44:58 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 246 | Line 246 | public class TreeSubMapTest extends JSR1
246
247		Map.Entry e4 = map.lowerEntry(zero);
248		assertNull(e4);
249	–
249		}
250
251		/**
#	Line 265 | Line 264 | public class TreeSubMapTest extends JSR1
264
265		Map.Entry e4 = map.higherEntry(six);
266		assertNull(e4);
268	–
267		}
268
269		/**
#	Line 284 | Line 282 | public class TreeSubMapTest extends JSR1
282
283		Map.Entry e4 = map.floorEntry(zero);
284		assertNull(e4);
287	–
285		}
286
287		/**
#	Line 303 | Line 300 | public class TreeSubMapTest extends JSR1
300
301		Map.Entry e4 = map.ceilingEntry(six);
302		assertNull(e4);
306	–
303		}
304
305		/**
#	Line 328 | Line 324 | public class TreeSubMapTest extends JSR1
324		try {
325		e.setValue("A");
326		shouldThrow();
327	<	} catch (Exception ok) {
332	<	}
327	>	} catch (UnsupportedOperationException success) {}
328		assertTrue(map.isEmpty());
329		Map.Entry f = map.firstEntry();
330		assertNull(f);
#	Line 359 | Line 354 | public class TreeSubMapTest extends JSR1
354		try {
355		e.setValue("E");
356		shouldThrow();
357	<	} catch (Exception ok) {
363	<	}
357	>	} catch (UnsupportedOperationException success) {}
358		e = map.pollLastEntry();
359		assertNull(e);
360		}
#	Line 371 | Line 365 | public class TreeSubMapTest extends JSR1
365		public void testSize() {
366		NavigableMap map = map5();
367		NavigableMap empty = map0();
368	<	assertEquals(0, empty.size());
369	<	assertEquals(5, map.size());
368	>	assertEquals(0, empty.size());
369	>	assertEquals(5, map.size());
370		}
371
372		/**
#	Line 396 | Line 390 | public class TreeSubMapTest extends JSR1
390		NavigableMap c = map5();
391		c.get(null);
392		shouldThrow();
393	<	} catch(NullPointerException e){}
393	>	} catch (NullPointerException success) {}
394		}
395
396		/**
#	Line 407 | Line 401 | public class TreeSubMapTest extends JSR1
401		NavigableMap c = map5();
402		c.containsKey(null);
403		shouldThrow();
404	<	} catch(NullPointerException e){}
404	>	} catch (NullPointerException success) {}
405		}
406
407		/**
#	Line 418 | Line 412 | public class TreeSubMapTest extends JSR1
412		NavigableMap c = map5();
413		c.put(null, "whatever");
414		shouldThrow();
415	<	} catch(NullPointerException e){}
415	>	} catch (NullPointerException success) {}
416		}
417
418		/**
#	Line 429 | Line 423 | public class TreeSubMapTest extends JSR1
423		NavigableMap c = map5();
424		c.remove(null);
425		shouldThrow();
426	<	} catch(NullPointerException e){}
426	>	} catch (NullPointerException success) {}
427		}
428
429		/**
430		* A deserialized map equals original
431		*/
432	<	public void testSerialization() {
432	>	public void testSerialization() throws Exception {
433		NavigableMap q = map5();
434
435	<	try {
436	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
437	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
438	<	out.writeObject(q);
439	<	out.close();
440	<
441	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
442	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
443	<	NavigableMap r = (NavigableMap)in.readObject();
444	<	assertFalse(r.isEmpty());
445	<	assertEquals(q.size(), r.size());
446	<	assertTrue(q.equals(r));
453	<	assertTrue(r.equals(q));
454	<	} catch(Exception e){
455	<	e.printStackTrace();
456	<	unexpectedException();
457	<	}
435	>	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
436	>	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
437	>	out.writeObject(q);
438	>	out.close();
439	>
440	>	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
441	>	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
442	>	NavigableMap r = (NavigableMap)in.readObject();
443	>	assertFalse(r.isEmpty());
444	>	assertEquals(q.size(), r.size());
445	>	assertTrue(q.equals(r));
446	>	assertTrue(r.equals(q));
447		}
448
449
#	Line 488 | Line 477 | public class TreeSubMapTest extends JSR1
477		assertEquals(1, sm.size());
478		assertEquals(three, sm.firstKey());
479		assertEquals(three, sm.lastKey());
480	<	assertTrue(sm.remove(three) != null);
480	>	assertEquals("C", sm.remove(three));
481		assertTrue(sm.isEmpty());
482		assertEquals(3, map.size());
483		}
#	Line 516 | Line 505 | public class TreeSubMapTest extends JSR1
505		assertEquals(4, map.size());
506		assertEquals(0, sm.size());
507		assertTrue(sm.isEmpty());
508	<	assertTrue(sm.remove(three) == null);
508	>	assertSame(sm.remove(three), null);
509		assertEquals(4, map.size());
510		}
511
#	Line 588 | Line 577 | public class TreeSubMapTest extends JSR1
577		SortedMap ssm = sm.tailMap(four);
578		assertEquals(four, ssm.firstKey());
579		assertEquals(five, ssm.lastKey());
580	<	assertTrue(ssm.remove(four) != null);
580	>	assertEquals("D", ssm.remove(four));
581		assertEquals(1, ssm.size());
582		assertEquals(3, sm.size());
583		assertEquals(4, map.size());
#	Line 599 | Line 588 | public class TreeSubMapTest extends JSR1
588		*/
589		public void testDescendingClear() {
590		NavigableMap map = dmap5();
591	<	map.clear();
592	<	assertEquals(map.size(), 0);
591	>	map.clear();
592	>	assertEquals(map.size(), 0);
593		}
594
595
#	Line 612 | Line 601 | public class TreeSubMapTest extends JSR1
601		NavigableMap map2 = dmap5();
602		assertEquals(map1, map2);
603		assertEquals(map2, map1);
604	<	map1.clear();
604	>	map1.clear();
605		assertFalse(map1.equals(map2));
606		assertFalse(map2.equals(map1));
607		}
#	Line 622 | Line 611 | public class TreeSubMapTest extends JSR1
611		*/
612		public void testDescendingContainsKey() {
613		NavigableMap map = dmap5();
614	<	assertTrue(map.containsKey(m1));
614	>	assertTrue(map.containsKey(m1));
615		assertFalse(map.containsKey(zero));
616		}
617
#	Line 631 | Line 620 | public class TreeSubMapTest extends JSR1
620		*/
621		public void testDescendingContainsValue() {
622		NavigableMap map = dmap5();
623	<	assertTrue(map.containsValue("A"));
623	>	assertTrue(map.containsValue("A"));
624		assertFalse(map.containsValue("Z"));
625		}
626
#	Line 641 | Line 630 | public class TreeSubMapTest extends JSR1
630		*/
631		public void testDescendingGet() {
632		NavigableMap map = dmap5();
633	<	assertEquals("A", (String)map.get(m1));
633	>	assertEquals("A", (String)map.get(m1));
634		NavigableMap empty = dmap0();
635		assertNull(empty.get(m1));
636		}
#	Line 652 | Line 641 | public class TreeSubMapTest extends JSR1
641		public void testDescendingIsEmpty() {
642		NavigableMap empty = dmap0();
643		NavigableMap map = dmap5();
644	<	assertTrue(empty.isEmpty());
644	>	assertTrue(empty.isEmpty());
645		assertFalse(map.isEmpty());
646		}
647
#	Line 661 | Line 650 | public class TreeSubMapTest extends JSR1
650		*/
651		public void testDescendingFirstKey() {
652		NavigableMap map = dmap5();
653	<	assertEquals(m1, map.firstKey());
653	>	assertEquals(m1, map.firstKey());
654		}
655
656		/**
#	Line 669 | Line 658 | public class TreeSubMapTest extends JSR1
658		*/
659		public void testDescendingLastKey() {
660		NavigableMap map = dmap5();
661	<	assertEquals(m5, map.lastKey());
661	>	assertEquals(m5, map.lastKey());
662		}
663
664
#	Line 678 | Line 667 | public class TreeSubMapTest extends JSR1
667		*/
668		public void testDescendingKeySet() {
669		NavigableMap map = dmap5();
670	<	Set s = map.keySet();
671	<	assertEquals(5, s.size());
672	<	assertTrue(s.contains(m1));
673	<	assertTrue(s.contains(m2));
674	<	assertTrue(s.contains(m3));
675	<	assertTrue(s.contains(m4));
676	<	assertTrue(s.contains(m5));
670	>	Set s = map.keySet();
671	>	assertEquals(5, s.size());
672	>	assertTrue(s.contains(m1));
673	>	assertTrue(s.contains(m2));
674	>	assertTrue(s.contains(m3));
675	>	assertTrue(s.contains(m4));
676	>	assertTrue(s.contains(m5));
677		}
678
679		/**
#	Line 692 | Line 681 | public class TreeSubMapTest extends JSR1
681		*/
682		public void testDescendingKeySetOrder() {
683		NavigableMap map = dmap5();
684	<	Set s = map.keySet();
684	>	Set s = map.keySet();
685		Iterator i = s.iterator();
686		Integer last = (Integer)i.next();
687		assertEquals(last, m1);
#	Line 708 | Line 697 | public class TreeSubMapTest extends JSR1
697		*/
698		public void testDescendingValues() {
699		NavigableMap map = dmap5();
700	<	Collection s = map.values();
701	<	assertEquals(5, s.size());
702	<	assertTrue(s.contains("A"));
703	<	assertTrue(s.contains("B"));
704	<	assertTrue(s.contains("C"));
705	<	assertTrue(s.contains("D"));
706	<	assertTrue(s.contains("E"));
700	>	Collection s = map.values();
701	>	assertEquals(5, s.size());
702	>	assertTrue(s.contains("A"));
703	>	assertTrue(s.contains("B"));
704	>	assertTrue(s.contains("C"));
705	>	assertTrue(s.contains("D"));
706	>	assertTrue(s.contains("E"));
707		}
708
709		/**
#	Line 722 | Line 711 | public class TreeSubMapTest extends JSR1
711		*/
712		public void testDescendingAscendingKeySetToArray() {
713		NavigableMap map = dmap5();
714	<	Set s = map.keySet();
714	>	Set s = map.keySet();
715		Object[] ar = s.toArray();
716		assertTrue(s.containsAll(Arrays.asList(ar)));
717	<	assertEquals(5, ar.length);
717	>	assertEquals(5, ar.length);
718		ar[0] = m10;
719		assertFalse(s.containsAll(Arrays.asList(ar)));
720		}
#	Line 735 | Line 724 | public class TreeSubMapTest extends JSR1
724		*/
725		public void testDescendingDescendingKeySetToArray() {
726		NavigableMap map = dmap5();
727	<	Set s = map.descendingKeySet();
727	>	Set s = map.descendingKeySet();
728		Object[] ar = s.toArray();
729	<	assertEquals(5, ar.length);
729	>	assertEquals(5, ar.length);
730		assertTrue(s.containsAll(Arrays.asList(ar)));
731		ar[0] = m10;
732		assertFalse(s.containsAll(Arrays.asList(ar)));
#	Line 748 | Line 737 | public class TreeSubMapTest extends JSR1
737		*/
738		public void testDescendingValuesToArray() {
739		NavigableMap map = dmap5();
740	<	Collection v = map.values();
740	>	Collection v = map.values();
741		Object[] ar = v.toArray();
742		ArrayList s = new ArrayList(Arrays.asList(ar));
743	<	assertEquals(5, ar.length);
744	<	assertTrue(s.contains("A"));
745	<	assertTrue(s.contains("B"));
746	<	assertTrue(s.contains("C"));
747	<	assertTrue(s.contains("D"));
748	<	assertTrue(s.contains("E"));
743	>	assertEquals(5, ar.length);
744	>	assertTrue(s.contains("A"));
745	>	assertTrue(s.contains("B"));
746	>	assertTrue(s.contains("C"));
747	>	assertTrue(s.contains("D"));
748	>	assertTrue(s.contains("E"));
749		}
750
751
#	Line 765 | Line 754 | public class TreeSubMapTest extends JSR1
754		*/
755		public void testDescendingEntrySet() {
756		NavigableMap map = dmap5();
757	<	Set s = map.entrySet();
758	<	assertEquals(5, s.size());
757	>	Set s = map.entrySet();
758	>	assertEquals(5, s.size());
759		Iterator it = s.iterator();
760		while (it.hasNext()) {
761		Map.Entry e = (Map.Entry) it.next();
#	Line 785 | Line 774 | public class TreeSubMapTest extends JSR1
774		public void testDescendingPutAll() {
775		NavigableMap empty = dmap0();
776		NavigableMap map = dmap5();
777	<	empty.putAll(map);
778	<	assertEquals(5, empty.size());
779	<	assertTrue(empty.containsKey(m1));
780	<	assertTrue(empty.containsKey(m2));
781	<	assertTrue(empty.containsKey(m3));
782	<	assertTrue(empty.containsKey(m4));
783	<	assertTrue(empty.containsKey(m5));
777	>	empty.putAll(map);
778	>	assertEquals(5, empty.size());
779	>	assertTrue(empty.containsKey(m1));
780	>	assertTrue(empty.containsKey(m2));
781	>	assertTrue(empty.containsKey(m3));
782	>	assertTrue(empty.containsKey(m4));
783	>	assertTrue(empty.containsKey(m5));
784		}
785
786
#	Line 800 | Line 789 | public class TreeSubMapTest extends JSR1
789		*/
790		public void testDescendingRemove() {
791		NavigableMap map = dmap5();
792	<	map.remove(m5);
793	<	assertEquals(4, map.size());
794	<	assertFalse(map.containsKey(m5));
792	>	map.remove(m5);
793	>	assertEquals(4, map.size());
794	>	assertFalse(map.containsKey(m5));
795		}
796
797		/**
#	Line 821 | Line 810 | public class TreeSubMapTest extends JSR1
810
811		Map.Entry e4 = map.lowerEntry(zero);
812		assertNull(e4);
824	–
813		}
814
815		/**
#	Line 840 | Line 828 | public class TreeSubMapTest extends JSR1
828
829		Map.Entry e4 = map.higherEntry(m6);
830		assertNull(e4);
843	–
831		}
832
833		/**
#	Line 859 | Line 846 | public class TreeSubMapTest extends JSR1
846
847		Map.Entry e4 = map.floorEntry(zero);
848		assertNull(e4);
862	–
849		}
850
851		/**
#	Line 878 | Line 864 | public class TreeSubMapTest extends JSR1
864
865		Map.Entry e4 = map.ceilingEntry(m6);
866		assertNull(e4);
881	–
867		}
868
869		/**
#	Line 903 | Line 888 | public class TreeSubMapTest extends JSR1
888		try {
889		e.setValue("A");
890		shouldThrow();
891	<	} catch (Exception ok) {
907	<	}
891	>	} catch (UnsupportedOperationException success) {}
892		e = map.pollFirstEntry();
893		assertNull(e);
894		}
#	Line 931 | Line 915 | public class TreeSubMapTest extends JSR1
915		try {
916		e.setValue("E");
917		shouldThrow();
918	<	} catch (Exception ok) {
935	<	}
918	>	} catch (UnsupportedOperationException success) {}
919		e = map.pollLastEntry();
920		assertNull(e);
921		}
#	Line 943 | Line 926 | public class TreeSubMapTest extends JSR1
926		public void testDescendingSize() {
927		NavigableMap map = dmap5();
928		NavigableMap empty = dmap0();
929	<	assertEquals(0, empty.size());
930	<	assertEquals(5, map.size());
929	>	assertEquals(0, empty.size());
930	>	assertEquals(5, map.size());
931		}
932
933		/**
#	Line 968 | Line 951 | public class TreeSubMapTest extends JSR1
951		NavigableMap c = dmap5();
952		c.get(null);
953		shouldThrow();
954	<	} catch(NullPointerException e){}
954	>	} catch (NullPointerException success) {}
955		}
956
957		/**
#	Line 979 | Line 962 | public class TreeSubMapTest extends JSR1
962		NavigableMap c = dmap5();
963		c.put(null, "whatever");
964		shouldThrow();
965	<	} catch(NullPointerException e){}
965	>	} catch (NullPointerException success) {}
966		}
967
968		/**
969		* A deserialized map equals original
970		*/
971	<	public void testDescendingSerialization() {
971	>	public void testDescendingSerialization() throws Exception {
972		NavigableMap q = dmap5();
973
974	<	try {
975	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
976	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
977	<	out.writeObject(q);
978	<	out.close();
979	<
980	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
981	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
982	<	NavigableMap r = (NavigableMap)in.readObject();
983	<	assertEquals(q.size(), r.size());
984	<	assertTrue(q.equals(r));
1002	<	assertTrue(r.equals(q));
1003	<	} catch(Exception e){
1004	<	e.printStackTrace();
1005	<	unexpectedException();
1006	<	}
974	>	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
975	>	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
976	>	out.writeObject(q);
977	>	out.close();
978	>
979	>	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
980	>	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
981	>	NavigableMap r = (NavigableMap)in.readObject();
982	>	assertEquals(q.size(), r.size());
983	>	assertTrue(q.equals(r));
984	>	assertTrue(r.equals(q));
985		}
986
987
1010	–
988		/**
989		* subMap returns map with keys in requested range
990		*/
#	Line 1037 | Line 1014 | public class TreeSubMapTest extends JSR1
1014		assertEquals(1, sm.size());
1015		assertEquals(m3, sm.firstKey());
1016		assertEquals(m3, sm.lastKey());
1017	<	assertTrue(sm.remove(m3) != null);
1017	>	assertEquals("C", sm.remove(m3));
1018		assertTrue(sm.isEmpty());
1019		assertEquals(3, map.size());
1020		}
#	Line 1065 | Line 1042 | public class TreeSubMapTest extends JSR1
1042		assertEquals(4, map.size());
1043		assertEquals(0, sm.size());
1044		assertTrue(sm.isEmpty());
1045	<	assertTrue(sm.remove(m3) == null);
1045	>	assertSame(sm.remove(m3), null);
1046		assertEquals(4, map.size());
1047		}
1048
#	Line 1137 | Line 1114 | public class TreeSubMapTest extends JSR1
1114		SortedMap ssm = sm.tailMap(m4);
1115		assertEquals(m4, ssm.firstKey());
1116		assertEquals(m5, ssm.lastKey());
1117	<	assertTrue(ssm.remove(m4) != null);
1117	>	assertEquals("D", ssm.remove(m4));
1118		assertEquals(1, ssm.size());
1119		assertEquals(3, sm.size());
1120		assertEquals(4, map.size());

Diff Legend

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