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.6 by jsr166, Mon Nov 16 05:30:08 2009 UTC vs.
Revision 1.7 by jsr166, Sat Nov 21 02:07:27 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 371 | Line 371 | public class TreeSubMapTest extends JSR1
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 599 | Line 599 | public class TreeSubMapTest extends JSR1
599		*/
600		public void testDescendingClear() {
601		NavigableMap map = dmap5();
602	<	map.clear();
603	<	assertEquals(map.size(), 0);
602	>	map.clear();
603	>	assertEquals(map.size(), 0);
604		}
605
606
#	Line 612 | Line 612 | public class TreeSubMapTest extends JSR1
612		NavigableMap map2 = dmap5();
613		assertEquals(map1, map2);
614		assertEquals(map2, map1);
615	<	map1.clear();
615	>	map1.clear();
616		assertFalse(map1.equals(map2));
617		assertFalse(map2.equals(map1));
618		}
#	Line 622 | Line 622 | public class TreeSubMapTest extends JSR1
622		*/
623		public void testDescendingContainsKey() {
624		NavigableMap map = dmap5();
625	<	assertTrue(map.containsKey(m1));
625	>	assertTrue(map.containsKey(m1));
626		assertFalse(map.containsKey(zero));
627		}
628
#	Line 631 | Line 631 | public class TreeSubMapTest extends JSR1
631		*/
632		public void testDescendingContainsValue() {
633		NavigableMap map = dmap5();
634	<	assertTrue(map.containsValue("A"));
634	>	assertTrue(map.containsValue("A"));
635		assertFalse(map.containsValue("Z"));
636		}
637
#	Line 641 | Line 641 | public class TreeSubMapTest extends JSR1
641		*/
642		public void testDescendingGet() {
643		NavigableMap map = dmap5();
644	<	assertEquals("A", (String)map.get(m1));
644	>	assertEquals("A", (String)map.get(m1));
645		NavigableMap empty = dmap0();
646		assertNull(empty.get(m1));
647		}
#	Line 652 | Line 652 | public class TreeSubMapTest extends JSR1
652		public void testDescendingIsEmpty() {
653		NavigableMap empty = dmap0();
654		NavigableMap map = dmap5();
655	<	assertTrue(empty.isEmpty());
655	>	assertTrue(empty.isEmpty());
656		assertFalse(map.isEmpty());
657		}
658
#	Line 661 | Line 661 | public class TreeSubMapTest extends JSR1
661		*/
662		public void testDescendingFirstKey() {
663		NavigableMap map = dmap5();
664	<	assertEquals(m1, map.firstKey());
664	>	assertEquals(m1, map.firstKey());
665		}
666
667		/**
#	Line 669 | Line 669 | public class TreeSubMapTest extends JSR1
669		*/
670		public void testDescendingLastKey() {
671		NavigableMap map = dmap5();
672	<	assertEquals(m5, map.lastKey());
672	>	assertEquals(m5, map.lastKey());
673		}
674
675
#	Line 678 | Line 678 | public class TreeSubMapTest extends JSR1
678		*/
679		public void testDescendingKeySet() {
680		NavigableMap map = dmap5();
681	<	Set s = map.keySet();
682	<	assertEquals(5, s.size());
683	<	assertTrue(s.contains(m1));
684	<	assertTrue(s.contains(m2));
685	<	assertTrue(s.contains(m3));
686	<	assertTrue(s.contains(m4));
687	<	assertTrue(s.contains(m5));
681	>	Set s = map.keySet();
682	>	assertEquals(5, s.size());
683	>	assertTrue(s.contains(m1));
684	>	assertTrue(s.contains(m2));
685	>	assertTrue(s.contains(m3));
686	>	assertTrue(s.contains(m4));
687	>	assertTrue(s.contains(m5));
688		}
689
690		/**
#	Line 692 | Line 692 | public class TreeSubMapTest extends JSR1
692		*/
693		public void testDescendingKeySetOrder() {
694		NavigableMap map = dmap5();
695	<	Set s = map.keySet();
695	>	Set s = map.keySet();
696		Iterator i = s.iterator();
697		Integer last = (Integer)i.next();
698		assertEquals(last, m1);
#	Line 708 | Line 708 | public class TreeSubMapTest extends JSR1
708		*/
709		public void testDescendingValues() {
710		NavigableMap map = dmap5();
711	<	Collection s = map.values();
712	<	assertEquals(5, s.size());
713	<	assertTrue(s.contains("A"));
714	<	assertTrue(s.contains("B"));
715	<	assertTrue(s.contains("C"));
716	<	assertTrue(s.contains("D"));
717	<	assertTrue(s.contains("E"));
711	>	Collection s = map.values();
712	>	assertEquals(5, s.size());
713	>	assertTrue(s.contains("A"));
714	>	assertTrue(s.contains("B"));
715	>	assertTrue(s.contains("C"));
716	>	assertTrue(s.contains("D"));
717	>	assertTrue(s.contains("E"));
718		}
719
720		/**
#	Line 722 | Line 722 | public class TreeSubMapTest extends JSR1
722		*/
723		public void testDescendingAscendingKeySetToArray() {
724		NavigableMap map = dmap5();
725	<	Set s = map.keySet();
725	>	Set s = map.keySet();
726		Object[] ar = s.toArray();
727		assertTrue(s.containsAll(Arrays.asList(ar)));
728	<	assertEquals(5, ar.length);
728	>	assertEquals(5, ar.length);
729		ar[0] = m10;
730		assertFalse(s.containsAll(Arrays.asList(ar)));
731		}
#	Line 735 | Line 735 | public class TreeSubMapTest extends JSR1
735		*/
736		public void testDescendingDescendingKeySetToArray() {
737		NavigableMap map = dmap5();
738	<	Set s = map.descendingKeySet();
738	>	Set s = map.descendingKeySet();
739		Object[] ar = s.toArray();
740	<	assertEquals(5, ar.length);
740	>	assertEquals(5, ar.length);
741		assertTrue(s.containsAll(Arrays.asList(ar)));
742		ar[0] = m10;
743		assertFalse(s.containsAll(Arrays.asList(ar)));
#	Line 748 | Line 748 | public class TreeSubMapTest extends JSR1
748		*/
749		public void testDescendingValuesToArray() {
750		NavigableMap map = dmap5();
751	<	Collection v = map.values();
751	>	Collection v = map.values();
752		Object[] ar = v.toArray();
753		ArrayList s = new ArrayList(Arrays.asList(ar));
754	<	assertEquals(5, ar.length);
755	<	assertTrue(s.contains("A"));
756	<	assertTrue(s.contains("B"));
757	<	assertTrue(s.contains("C"));
758	<	assertTrue(s.contains("D"));
759	<	assertTrue(s.contains("E"));
754	>	assertEquals(5, ar.length);
755	>	assertTrue(s.contains("A"));
756	>	assertTrue(s.contains("B"));
757	>	assertTrue(s.contains("C"));
758	>	assertTrue(s.contains("D"));
759	>	assertTrue(s.contains("E"));
760		}
761
762
#	Line 765 | Line 765 | public class TreeSubMapTest extends JSR1
765		*/
766		public void testDescendingEntrySet() {
767		NavigableMap map = dmap5();
768	<	Set s = map.entrySet();
769	<	assertEquals(5, s.size());
768	>	Set s = map.entrySet();
769	>	assertEquals(5, s.size());
770		Iterator it = s.iterator();
771		while (it.hasNext()) {
772		Map.Entry e = (Map.Entry) it.next();
#	Line 785 | Line 785 | public class TreeSubMapTest extends JSR1
785		public void testDescendingPutAll() {
786		NavigableMap empty = dmap0();
787		NavigableMap map = dmap5();
788	<	empty.putAll(map);
789	<	assertEquals(5, empty.size());
790	<	assertTrue(empty.containsKey(m1));
791	<	assertTrue(empty.containsKey(m2));
792	<	assertTrue(empty.containsKey(m3));
793	<	assertTrue(empty.containsKey(m4));
794	<	assertTrue(empty.containsKey(m5));
788	>	empty.putAll(map);
789	>	assertEquals(5, empty.size());
790	>	assertTrue(empty.containsKey(m1));
791	>	assertTrue(empty.containsKey(m2));
792	>	assertTrue(empty.containsKey(m3));
793	>	assertTrue(empty.containsKey(m4));
794	>	assertTrue(empty.containsKey(m5));
795		}
796
797
#	Line 800 | Line 800 | public class TreeSubMapTest extends JSR1
800		*/
801		public void testDescendingRemove() {
802		NavigableMap map = dmap5();
803	<	map.remove(m5);
804	<	assertEquals(4, map.size());
805	<	assertFalse(map.containsKey(m5));
803	>	map.remove(m5);
804	>	assertEquals(4, map.size());
805	>	assertFalse(map.containsKey(m5));
806		}
807
808		/**
#	Line 943 | Line 943 | public class TreeSubMapTest extends JSR1
943		public void testDescendingSize() {
944		NavigableMap map = dmap5();
945		NavigableMap empty = dmap0();
946	<	assertEquals(0, empty.size());
947	<	assertEquals(5, map.size());
946	>	assertEquals(0, empty.size());
947	>	assertEquals(5, map.size());
948		}
949
950		/**

Diff Legend

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