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.3 by dl, Thu Apr 20 20:35:00 2006 UTC vs.
Revision 1.22 by jsr166, Sat Feb 28 18:32:12 2015 UTC

#	Line 1 | Line 1
1		/*
2		* Written by Doug Lea with assistance from members of JCP JSR-166
3		* Expert Group and released to the public domain, as explained at
4	<	* http://creativecommons.org/licenses/publicdomain
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6
7	<	import junit.framework.*;
8	<	import java.util.*;
9	<	import java.util.concurrent.*;
10	<	import java.io.*;
7	>	import java.util.ArrayList;
8	>	import java.util.Arrays;
9	>	import java.util.Collection;
10	>	import java.util.Iterator;
11	>	import java.util.Map;
12	>	import java.util.NavigableMap;
13	>	import java.util.Set;
14	>	import java.util.SortedMap;
15	>	import java.util.TreeMap;
16	>
17	>	import junit.framework.Test;
18	>	import junit.framework.TestSuite;
19
20		public class TreeSubMapTest extends JSR166TestCase {
21		public static void main(String[] args) {
22	<	junit.textui.TestRunner.run (suite());
22	>	junit.textui.TestRunner.run(suite());
23		}
24		public static Test suite() {
25	<	return new TestSuite(TreeSubMapTest.class);
25	>	return new TestSuite(TreeSubMapTest.class);
26		}
27
28		/**
29	<	* Create a map from Integers 1-5 to Strings "A"-"E".
29	>	* Returns a new map from Integers 1-5 to Strings "A"-"E".
30		*/
31	<	private static NavigableMap map5() {
32	<	TreeMap map = new TreeMap();
31	>	private static NavigableMap map5() {
32	>	TreeMap map = new TreeMap();
33		assertTrue(map.isEmpty());
34	<	map.put(zero, "Z");
35	<	map.put(one, "A");
36	<	map.put(five, "E");
37	<	map.put(three, "C");
38	<	map.put(two, "B");
39	<	map.put(four, "D");
40	<	map.put(seven, "F");
34	>	map.put(zero, "Z");
35	>	map.put(one, "A");
36	>	map.put(five, "E");
37	>	map.put(three, "C");
38	>	map.put(two, "B");
39	>	map.put(four, "D");
40	>	map.put(seven, "F");
41		assertFalse(map.isEmpty());
42		assertEquals(7, map.size());
43		return map.subMap(one, true, seven, false);
44		}
45
46	<	private static NavigableMap map0() {
47	<	TreeMap map = new TreeMap();
46	>	private static NavigableMap map0() {
47	>	TreeMap map = new TreeMap();
48		assertTrue(map.isEmpty());
49		return map.tailMap(one, true);
50		}
51
52		/**
53	<	* Create a map from Integers -5 to -1 to Strings "A"-"E".
53	>	* Returns a new map from Integers -5 to -1 to Strings "A"-"E".
54		*/
55	<	private static NavigableMap dmap5() {
56	<	TreeMap map = new TreeMap();
55	>	private static NavigableMap dmap5() {
56	>	TreeMap map = new TreeMap();
57		assertTrue(map.isEmpty());
58	<	map.put(m1, "A");
59	<	map.put(m5, "E");
60	<	map.put(m3, "C");
61	<	map.put(m2, "B");
62	<	map.put(m4, "D");
58	>	map.put(m1, "A");
59	>	map.put(m5, "E");
60	>	map.put(m3, "C");
61	>	map.put(m2, "B");
62	>	map.put(m4, "D");
63		assertFalse(map.isEmpty());
64		assertEquals(5, map.size());
65	<	return map.descendingMap();
65	>	return map.descendingMap();
66		}
67
68	<	private static NavigableMap dmap0() {
69	<	TreeMap map = new TreeMap();
68	>	private static NavigableMap dmap0() {
69	>	TreeMap map = new TreeMap();
70		assertTrue(map.isEmpty());
71		return map;
72		}
73
74		/**
75	<	*  clear removes all pairs
75	>	* clear removes all pairs
76		*/
77		public void testClear() {
78		NavigableMap map = map5();
79	<	map.clear();
80	<	assertEquals(map.size(), 0);
79	>	map.clear();
80	>	assertEquals(0, map.size());
81		}
82
75	–
83		/**
84	<	*  Maps with same contents are equal
84	>	* Maps with same contents are equal
85		*/
86		public void testEquals() {
87		NavigableMap map1 = map5();
88		NavigableMap map2 = map5();
89		assertEquals(map1, map2);
90		assertEquals(map2, map1);
91	<	map1.clear();
91	>	map1.clear();
92		assertFalse(map1.equals(map2));
93		assertFalse(map2.equals(map1));
94		}
95
96		/**
97	<	*  containsKey returns true for contained key
97	>	* containsKey returns true for contained key
98		*/
99		public void testContainsKey() {
100		NavigableMap map = map5();
101	<	assertTrue(map.containsKey(one));
101	>	assertTrue(map.containsKey(one));
102		assertFalse(map.containsKey(zero));
103		}
104
105		/**
106	<	*  containsValue returns true for held values
106	>	* containsValue returns true for held values
107		*/
108		public void testContainsValue() {
109		NavigableMap map = map5();
110	<	assertTrue(map.containsValue("A"));
110	>	assertTrue(map.containsValue("A"));
111		assertFalse(map.containsValue("Z"));
112		}
113
114		/**
115	<	*  get returns the correct element at the given key,
116	<	*  or null if not present
115	>	* get returns the correct element at the given key,
116	>	* or null if not present
117		*/
118		public void testGet() {
119		NavigableMap map = map5();
120	<	assertEquals("A", (String)map.get(one));
120	>	assertEquals("A", (String)map.get(one));
121		NavigableMap empty = map0();
122		assertNull(empty.get(one));
123		}
124
125		/**
126	<	*  isEmpty is true of empty map and false for non-empty
126	>	* isEmpty is true of empty map and false for non-empty
127		*/
128		public void testIsEmpty() {
129		NavigableMap empty = map0();
130		NavigableMap map = map5();
131	<	assertTrue(empty.isEmpty());
131	>	assertTrue(empty.isEmpty());
132		assertFalse(map.isEmpty());
133		}
134
135		/**
136	<	*   firstKey returns first key
136	>	* firstKey returns first key
137		*/
138		public void testFirstKey() {
139		NavigableMap map = map5();
140	<	assertEquals(one, map.firstKey());
140	>	assertEquals(one, map.firstKey());
141		}
142
143		/**
144	<	*   lastKey returns last key
144	>	* lastKey returns last key
145		*/
146		public void testLastKey() {
147		NavigableMap map = map5();
148	<	assertEquals(five, map.lastKey());
148	>	assertEquals(five, map.lastKey());
149		}
150
144	–
151		/**
152	<	*   keySet returns a Set containing all the keys
152	>	* keySet returns a Set containing all the keys
153		*/
154		public void testKeySet() {
155		NavigableMap map = map5();
156	<	Set s = map.keySet();
157	<	assertEquals(5, s.size());
158	<	assertTrue(s.contains(one));
159	<	assertTrue(s.contains(two));
160	<	assertTrue(s.contains(three));
161	<	assertTrue(s.contains(four));
162	<	assertTrue(s.contains(five));
156	>	Set s = map.keySet();
157	>	assertEquals(5, s.size());
158	>	assertTrue(s.contains(one));
159	>	assertTrue(s.contains(two));
160	>	assertTrue(s.contains(three));
161	>	assertTrue(s.contains(four));
162	>	assertTrue(s.contains(five));
163		}
164
165		/**
166	<	*   keySet is ordered
166	>	* keySet is ordered
167		*/
168		public void testKeySetOrder() {
169		NavigableMap map = map5();
170	<	Set s = map.keySet();
170	>	Set s = map.keySet();
171		Iterator i = s.iterator();
172		Integer last = (Integer)i.next();
173		assertEquals(last, one);
#	Line 177 | Line 183 | public class TreeSubMapTest extends JSR1
183		*/
184		public void testValues() {
185		NavigableMap map = map5();
186	<	Collection s = map.values();
187	<	assertEquals(5, s.size());
188	<	assertTrue(s.contains("A"));
189	<	assertTrue(s.contains("B"));
190	<	assertTrue(s.contains("C"));
191	<	assertTrue(s.contains("D"));
192	<	assertTrue(s.contains("E"));
186	>	Collection s = map.values();
187	>	assertEquals(5, s.size());
188	>	assertTrue(s.contains("A"));
189	>	assertTrue(s.contains("B"));
190	>	assertTrue(s.contains("C"));
191	>	assertTrue(s.contains("D"));
192	>	assertTrue(s.contains("E"));
193		}
194
195		/**
#	Line 191 | Line 197 | public class TreeSubMapTest extends JSR1
197		*/
198		public void testEntrySet() {
199		NavigableMap map = map5();
200	<	Set s = map.entrySet();
201	<	assertEquals(5, s.size());
200	>	Set s = map.entrySet();
201	>	assertEquals(5, s.size());
202		Iterator it = s.iterator();
203		while (it.hasNext()) {
204		Map.Entry e = (Map.Entry) it.next();
205	<	assertTrue(
205	>	assertTrue(
206		(e.getKey().equals(one) && e.getValue().equals("A")) ||
207		(e.getKey().equals(two) && e.getValue().equals("B")) ||
208		(e.getKey().equals(three) && e.getValue().equals("C")) ||
#	Line 206 | Line 212 | public class TreeSubMapTest extends JSR1
212		}
213
214		/**
215	<	*   putAll  adds all key-value pairs from the given map
215	>	* putAll adds all key-value pairs from the given map
216		*/
217		public void testPutAll() {
218		NavigableMap empty = map0();
219		NavigableMap map = map5();
220	<	empty.putAll(map);
221	<	assertEquals(5, empty.size());
222	<	assertTrue(empty.containsKey(one));
223	<	assertTrue(empty.containsKey(two));
224	<	assertTrue(empty.containsKey(three));
225	<	assertTrue(empty.containsKey(four));
226	<	assertTrue(empty.containsKey(five));
220	>	empty.putAll(map);
221	>	assertEquals(5, empty.size());
222	>	assertTrue(empty.containsKey(one));
223	>	assertTrue(empty.containsKey(two));
224	>	assertTrue(empty.containsKey(three));
225	>	assertTrue(empty.containsKey(four));
226	>	assertTrue(empty.containsKey(five));
227		}
228
229		/**
230	<	*   remove removes the correct key-value pair from the map
230	>	* remove removes the correct key-value pair from the map
231		*/
232		public void testRemove() {
233		NavigableMap map = map5();
234	<	map.remove(five);
235	<	assertEquals(4, map.size());
236	<	assertFalse(map.containsKey(five));
234	>	map.remove(five);
235	>	assertEquals(4, map.size());
236	>	assertFalse(map.containsKey(five));
237		}
238
239		/**
#	Line 246 | Line 252 | public class TreeSubMapTest extends JSR1
252
253		Map.Entry e4 = map.lowerEntry(zero);
254		assertNull(e4);
249	–
255		}
256
257		/**
#	Line 265 | Line 270 | public class TreeSubMapTest extends JSR1
270
271		Map.Entry e4 = map.higherEntry(six);
272		assertNull(e4);
268	–
273		}
274
275		/**
#	Line 284 | Line 288 | public class TreeSubMapTest extends JSR1
288
289		Map.Entry e4 = map.floorEntry(zero);
290		assertNull(e4);
287	–
291		}
292
293		/**
#	Line 303 | Line 306 | public class TreeSubMapTest extends JSR1
306
307		Map.Entry e4 = map.ceilingEntry(six);
308		assertNull(e4);
306	–
309		}
310
311		/**
#	Line 328 | Line 330 | public class TreeSubMapTest extends JSR1
330		try {
331		e.setValue("A");
332		shouldThrow();
333	<	} catch (Exception ok) {
332	<	}
333	>	} catch (UnsupportedOperationException success) {}
334		assertTrue(map.isEmpty());
335		Map.Entry f = map.firstEntry();
336		assertNull(f);
#	Line 359 | Line 360 | public class TreeSubMapTest extends JSR1
360		try {
361		e.setValue("E");
362		shouldThrow();
363	<	} catch (Exception ok) {
363	<	}
363	>	} catch (UnsupportedOperationException success) {}
364		e = map.pollLastEntry();
365		assertNull(e);
366		}
367
368		/**
369	<	*   size returns the correct values
369	>	* size returns the correct values
370		*/
371		public void testSize() {
372		NavigableMap map = map5();
373		NavigableMap empty = map0();
374	<	assertEquals(0, empty.size());
375	<	assertEquals(5, map.size());
374	>	assertEquals(0, empty.size());
375	>	assertEquals(5, map.size());
376		}
377
378		/**
#	Line 382 | Line 382 | public class TreeSubMapTest extends JSR1
382		NavigableMap map = map5();
383		String s = map.toString();
384		for (int i = 1; i <= 5; ++i) {
385	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
385	>	assertTrue(s.contains(String.valueOf(i)));
386		}
387	<	}
387	>	}
388
389		// Exception tests
390
#	Line 392 | Line 392 | public class TreeSubMapTest extends JSR1
392		* get(null) of nonempty map throws NPE
393		*/
394		public void testGet_NullPointerException() {
395	+	NavigableMap c = map5();
396		try {
396	–	NavigableMap c = map5();
397		c.get(null);
398		shouldThrow();
399	<	} catch(NullPointerException e){}
399	>	} catch (NullPointerException success) {}
400		}
401
402		/**
403		* containsKey(null) of nonempty map throws NPE
404		*/
405		public void testContainsKey_NullPointerException() {
406	+	NavigableMap c = map5();
407		try {
407	–	NavigableMap c = map5();
408		c.containsKey(null);
409		shouldThrow();
410	<	} catch(NullPointerException e){}
410	>	} catch (NullPointerException success) {}
411		}
412
413		/**
414		* put(null,x) throws NPE
415		*/
416		public void testPut1_NullPointerException() {
417	+	NavigableMap c = map5();
418		try {
418	–	NavigableMap c = map5();
419		c.put(null, "whatever");
420		shouldThrow();
421	<	} catch(NullPointerException e){}
421	>	} catch (NullPointerException success) {}
422		}
423
424		/**
425		* remove(null) throws NPE
426		*/
427		public void testRemove1_NullPointerException() {
428	+	NavigableMap c = map5();
429		try {
429	–	NavigableMap c = map5();
430		c.remove(null);
431		shouldThrow();
432	<	} catch(NullPointerException e){}
432	>	} catch (NullPointerException success) {}
433		}
434
435		/**
436		* A deserialized map equals original
437		*/
438	<	public void testSerialization() {
439	<	NavigableMap q = map5();
440	<
441	<	try {
442	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
443	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
444	<	out.writeObject(q);
445	<	out.close();
446	<
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	<	}
438	>	public void testSerialization() throws Exception {
439	>	NavigableMap x = map5();
440	>	NavigableMap y = serialClone(x);
441	>
442	>	assertNotSame(x, y);
443	>	assertEquals(x.size(), y.size());
444	>	assertEquals(x.toString(), y.toString());
445	>	assertEquals(x, y);
446	>	assertEquals(y, x);
447		}
448
460	–
461	–
449		/**
450		* subMap returns map with keys in requested range
451		*/
#	Line 488 | Line 475 | public class TreeSubMapTest extends JSR1
475		assertEquals(1, sm.size());
476		assertEquals(three, sm.firstKey());
477		assertEquals(three, sm.lastKey());
478	<	assertTrue(sm.remove(three) != null);
478	>	assertEquals("C", sm.remove(three));
479		assertTrue(sm.isEmpty());
480		assertEquals(3, map.size());
481		}
#	Line 516 | Line 503 | public class TreeSubMapTest extends JSR1
503		assertEquals(4, map.size());
504		assertEquals(0, sm.size());
505		assertTrue(sm.isEmpty());
506	<	assertTrue(sm.remove(three) == null);
506	>	assertSame(sm.remove(three), null);
507		assertEquals(4, map.size());
508		}
509
#	Line 588 | Line 575 | public class TreeSubMapTest extends JSR1
575		SortedMap ssm = sm.tailMap(four);
576		assertEquals(four, ssm.firstKey());
577		assertEquals(five, ssm.lastKey());
578	<	assertTrue(ssm.remove(four) != null);
578	>	assertEquals("D", ssm.remove(four));
579		assertEquals(1, ssm.size());
580		assertEquals(3, sm.size());
581		assertEquals(4, map.size());
582		}
583
584		/**
585	<	*  clear removes all pairs
585	>	* clear removes all pairs
586		*/
587		public void testDescendingClear() {
588		NavigableMap map = dmap5();
589	<	map.clear();
590	<	assertEquals(map.size(), 0);
589	>	map.clear();
590	>	assertEquals(0, map.size());
591		}
592
606	–
593		/**
594	<	*  Maps with same contents are equal
594	>	* Maps with same contents are equal
595		*/
596		public void testDescendingEquals() {
597		NavigableMap map1 = dmap5();
598		NavigableMap map2 = dmap5();
599		assertEquals(map1, map2);
600		assertEquals(map2, map1);
601	<	map1.clear();
601	>	map1.clear();
602		assertFalse(map1.equals(map2));
603		assertFalse(map2.equals(map1));
604		}
605
606		/**
607	<	*  containsKey returns true for contained key
607	>	* containsKey returns true for contained key
608		*/
609		public void testDescendingContainsKey() {
610		NavigableMap map = dmap5();
611	<	assertTrue(map.containsKey(m1));
611	>	assertTrue(map.containsKey(m1));
612		assertFalse(map.containsKey(zero));
613		}
614
615		/**
616	<	*  containsValue returns true for held values
616	>	* containsValue returns true for held values
617		*/
618		public void testDescendingContainsValue() {
619		NavigableMap map = dmap5();
620	<	assertTrue(map.containsValue("A"));
620	>	assertTrue(map.containsValue("A"));
621		assertFalse(map.containsValue("Z"));
622		}
623
624		/**
625	<	*  get returns the correct element at the given key,
626	<	*  or null if not present
625	>	* get returns the correct element at the given key,
626	>	* or null if not present
627		*/
628		public void testDescendingGet() {
629		NavigableMap map = dmap5();
630	<	assertEquals("A", (String)map.get(m1));
630	>	assertEquals("A", (String)map.get(m1));
631		NavigableMap empty = dmap0();
632		assertNull(empty.get(m1));
633		}
634
635		/**
636	<	*  isEmpty is true of empty map and false for non-empty
636	>	* isEmpty is true of empty map and false for non-empty
637		*/
638		public void testDescendingIsEmpty() {
639		NavigableMap empty = dmap0();
640		NavigableMap map = dmap5();
641	<	assertTrue(empty.isEmpty());
641	>	assertTrue(empty.isEmpty());
642		assertFalse(map.isEmpty());
643		}
644
645		/**
646	<	*   firstKey returns first key
646	>	* firstKey returns first key
647		*/
648		public void testDescendingFirstKey() {
649		NavigableMap map = dmap5();
650	<	assertEquals(m1, map.firstKey());
650	>	assertEquals(m1, map.firstKey());
651		}
652
653		/**
654	<	*   lastKey returns last key
654	>	* lastKey returns last key
655		*/
656		public void testDescendingLastKey() {
657		NavigableMap map = dmap5();
658	<	assertEquals(m5, map.lastKey());
658	>	assertEquals(m5, map.lastKey());
659		}
660
675	–
661		/**
662	<	*   keySet returns a Set containing all the keys
662	>	* keySet returns a Set containing all the keys
663		*/
664		public void testDescendingKeySet() {
665		NavigableMap map = dmap5();
666	<	Set s = map.keySet();
667	<	assertEquals(5, s.size());
668	<	assertTrue(s.contains(m1));
669	<	assertTrue(s.contains(m2));
670	<	assertTrue(s.contains(m3));
671	<	assertTrue(s.contains(m4));
672	<	assertTrue(s.contains(m5));
666	>	Set s = map.keySet();
667	>	assertEquals(5, s.size());
668	>	assertTrue(s.contains(m1));
669	>	assertTrue(s.contains(m2));
670	>	assertTrue(s.contains(m3));
671	>	assertTrue(s.contains(m4));
672	>	assertTrue(s.contains(m5));
673		}
674
675		/**
676	<	*   keySet is ordered
676	>	* keySet is ordered
677		*/
678		public void testDescendingKeySetOrder() {
679		NavigableMap map = dmap5();
680	<	Set s = map.keySet();
680	>	Set s = map.keySet();
681		Iterator i = s.iterator();
682		Integer last = (Integer)i.next();
683		assertEquals(last, m1);
#	Line 708 | Line 693 | public class TreeSubMapTest extends JSR1
693		*/
694		public void testDescendingValues() {
695		NavigableMap map = dmap5();
696	<	Collection s = map.values();
697	<	assertEquals(5, s.size());
698	<	assertTrue(s.contains("A"));
699	<	assertTrue(s.contains("B"));
700	<	assertTrue(s.contains("C"));
701	<	assertTrue(s.contains("D"));
702	<	assertTrue(s.contains("E"));
696	>	Collection s = map.values();
697	>	assertEquals(5, s.size());
698	>	assertTrue(s.contains("A"));
699	>	assertTrue(s.contains("B"));
700	>	assertTrue(s.contains("C"));
701	>	assertTrue(s.contains("D"));
702	>	assertTrue(s.contains("E"));
703		}
704
705		/**
706	<	*  keySet.toArray returns contains all keys
706	>	* keySet.toArray returns contains all keys
707		*/
708		public void testDescendingAscendingKeySetToArray() {
709		NavigableMap map = dmap5();
710	<	Set s = map.keySet();
710	>	Set s = map.keySet();
711		Object[] ar = s.toArray();
712		assertTrue(s.containsAll(Arrays.asList(ar)));
713	<	assertEquals(5, ar.length);
713	>	assertEquals(5, ar.length);
714		ar[0] = m10;
715		assertFalse(s.containsAll(Arrays.asList(ar)));
716		}
717
718		/**
719	<	*  descendingkeySet.toArray returns contains all keys
719	>	* descendingkeySet.toArray returns contains all keys
720		*/
721		public void testDescendingDescendingKeySetToArray() {
722		NavigableMap map = dmap5();
723	<	Set s = map.descendingKeySet();
723	>	Set s = map.descendingKeySet();
724		Object[] ar = s.toArray();
725	<	assertEquals(5, ar.length);
725	>	assertEquals(5, ar.length);
726		assertTrue(s.containsAll(Arrays.asList(ar)));
727		ar[0] = m10;
728		assertFalse(s.containsAll(Arrays.asList(ar)));
729		}
730
731		/**
732	<	*  Values.toArray contains all values
732	>	* Values.toArray contains all values
733		*/
734		public void testDescendingValuesToArray() {
735		NavigableMap map = dmap5();
736	<	Collection v = map.values();
736	>	Collection v = map.values();
737		Object[] ar = v.toArray();
738		ArrayList s = new ArrayList(Arrays.asList(ar));
739	<	assertEquals(5, ar.length);
740	<	assertTrue(s.contains("A"));
741	<	assertTrue(s.contains("B"));
742	<	assertTrue(s.contains("C"));
743	<	assertTrue(s.contains("D"));
744	<	assertTrue(s.contains("E"));
739	>	assertEquals(5, ar.length);
740	>	assertTrue(s.contains("A"));
741	>	assertTrue(s.contains("B"));
742	>	assertTrue(s.contains("C"));
743	>	assertTrue(s.contains("D"));
744	>	assertTrue(s.contains("E"));
745		}
746
762	–
747		/**
748		* entrySet contains all pairs
749		*/
750		public void testDescendingEntrySet() {
751		NavigableMap map = dmap5();
752	<	Set s = map.entrySet();
753	<	assertEquals(5, s.size());
752	>	Set s = map.entrySet();
753	>	assertEquals(5, s.size());
754		Iterator it = s.iterator();
755		while (it.hasNext()) {
756		Map.Entry e = (Map.Entry) it.next();
757	<	assertTrue(
757	>	assertTrue(
758		(e.getKey().equals(m1) && e.getValue().equals("A")) ||
759		(e.getKey().equals(m2) && e.getValue().equals("B")) ||
760		(e.getKey().equals(m3) && e.getValue().equals("C")) ||
#	Line 780 | Line 764 | public class TreeSubMapTest extends JSR1
764		}
765
766		/**
767	<	*   putAll  adds all key-value pairs from the given map
767	>	* putAll adds all key-value pairs from the given map
768		*/
769		public void testDescendingPutAll() {
770		NavigableMap empty = dmap0();
771		NavigableMap map = dmap5();
772	<	empty.putAll(map);
773	<	assertEquals(5, empty.size());
774	<	assertTrue(empty.containsKey(m1));
775	<	assertTrue(empty.containsKey(m2));
776	<	assertTrue(empty.containsKey(m3));
777	<	assertTrue(empty.containsKey(m4));
778	<	assertTrue(empty.containsKey(m5));
772	>	empty.putAll(map);
773	>	assertEquals(5, empty.size());
774	>	assertTrue(empty.containsKey(m1));
775	>	assertTrue(empty.containsKey(m2));
776	>	assertTrue(empty.containsKey(m3));
777	>	assertTrue(empty.containsKey(m4));
778	>	assertTrue(empty.containsKey(m5));
779		}
780
797	–
781		/**
782	<	*   remove removes the correct key-value pair from the map
782	>	* remove removes the correct key-value pair from the map
783		*/
784		public void testDescendingRemove() {
785		NavigableMap map = dmap5();
786	<	map.remove(m5);
787	<	assertEquals(4, map.size());
788	<	assertFalse(map.containsKey(m5));
786	>	map.remove(m5);
787	>	assertEquals(4, map.size());
788	>	assertFalse(map.containsKey(m5));
789		}
790
791		/**
#	Line 821 | Line 804 | public class TreeSubMapTest extends JSR1
804
805		Map.Entry e4 = map.lowerEntry(zero);
806		assertNull(e4);
824	–
807		}
808
809		/**
#	Line 840 | Line 822 | public class TreeSubMapTest extends JSR1
822
823		Map.Entry e4 = map.higherEntry(m6);
824		assertNull(e4);
843	–
825		}
826
827		/**
#	Line 859 | Line 840 | public class TreeSubMapTest extends JSR1
840
841		Map.Entry e4 = map.floorEntry(zero);
842		assertNull(e4);
862	–
843		}
844
845		/**
#	Line 878 | Line 858 | public class TreeSubMapTest extends JSR1
858
859		Map.Entry e4 = map.ceilingEntry(m6);
860		assertNull(e4);
881	–
861		}
862
863		/**
#	Line 903 | Line 882 | public class TreeSubMapTest extends JSR1
882		try {
883		e.setValue("A");
884		shouldThrow();
885	<	} catch (Exception ok) {
907	<	}
885	>	} catch (UnsupportedOperationException success) {}
886		e = map.pollFirstEntry();
887		assertNull(e);
888		}
#	Line 931 | Line 909 | public class TreeSubMapTest extends JSR1
909		try {
910		e.setValue("E");
911		shouldThrow();
912	<	} catch (Exception ok) {
935	<	}
912	>	} catch (UnsupportedOperationException success) {}
913		e = map.pollLastEntry();
914		assertNull(e);
915		}
916
917		/**
918	<	*   size returns the correct values
918	>	* size returns the correct values
919		*/
920		public void testDescendingSize() {
921		NavigableMap map = dmap5();
922		NavigableMap empty = dmap0();
923	<	assertEquals(0, empty.size());
924	<	assertEquals(5, map.size());
923	>	assertEquals(0, empty.size());
924	>	assertEquals(5, map.size());
925		}
926
927		/**
#	Line 954 | Line 931 | public class TreeSubMapTest extends JSR1
931		NavigableMap map = dmap5();
932		String s = map.toString();
933		for (int i = 1; i <= 5; ++i) {
934	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
934	>	assertTrue(s.contains(String.valueOf(i)));
935		}
936	<	}
936	>	}
937
938		// Exception testDescendings
939
#	Line 964 | Line 941 | public class TreeSubMapTest extends JSR1
941		* get(null) of nonempty map throws NPE
942		*/
943		public void testDescendingGet_NullPointerException() {
944	+	NavigableMap c = dmap5();
945		try {
968	–	NavigableMap c = dmap5();
946		c.get(null);
947		shouldThrow();
948	<	} catch(NullPointerException e){}
948	>	} catch (NullPointerException success) {}
949		}
950
951		/**
952		* put(null,x) throws NPE
953		*/
954		public void testDescendingPut1_NullPointerException() {
955	+	NavigableMap c = dmap5();
956		try {
979	–	NavigableMap c = dmap5();
957		c.put(null, "whatever");
958		shouldThrow();
959	<	} catch(NullPointerException e){}
959	>	} catch (NullPointerException success) {}
960		}
961
962		/**
963		* A deserialized map equals original
964		*/
965	<	public void testDescendingSerialization() {
966	<	NavigableMap q = dmap5();
967	<
968	<	try {
969	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
970	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
971	<	out.writeObject(q);
972	<	out.close();
973	<
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	<	}
965	>	public void testDescendingSerialization() throws Exception {
966	>	NavigableMap x = dmap5();
967	>	NavigableMap y = serialClone(x);
968	>
969	>	assertNotSame(x, y);
970	>	assertEquals(x.size(), y.size());
971	>	assertEquals(x.toString(), y.toString());
972	>	assertEquals(x, y);
973	>	assertEquals(y, x);
974		}
975
1009	–
1010	–
976		/**
977		* subMap returns map with keys in requested range
978		*/
#	Line 1037 | Line 1002 | public class TreeSubMapTest extends JSR1
1002		assertEquals(1, sm.size());
1003		assertEquals(m3, sm.firstKey());
1004		assertEquals(m3, sm.lastKey());
1005	<	assertTrue(sm.remove(m3) != null);
1005	>	assertEquals("C", sm.remove(m3));
1006		assertTrue(sm.isEmpty());
1007		assertEquals(3, map.size());
1008		}
#	Line 1065 | Line 1030 | public class TreeSubMapTest extends JSR1
1030		assertEquals(4, map.size());
1031		assertEquals(0, sm.size());
1032		assertTrue(sm.isEmpty());
1033	<	assertTrue(sm.remove(m3) == null);
1033	>	assertSame(sm.remove(m3), null);
1034		assertEquals(4, map.size());
1035		}
1036
#	Line 1137 | Line 1102 | public class TreeSubMapTest extends JSR1
1102		SortedMap ssm = sm.tailMap(m4);
1103		assertEquals(m4, ssm.firstKey());
1104		assertEquals(m5, ssm.lastKey());
1105	<	assertTrue(ssm.remove(m4) != null);
1105	>	assertEquals("D", ssm.remove(m4));
1106		assertEquals(1, ssm.size());
1107		assertEquals(3, sm.size());
1108		assertEquals(4, map.size());
1109		}
1110	<
1110	>
1111		}

Diff Legend

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