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.8 by jsr166, Sat Nov 21 10:25:05 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();
23	>	private static NavigableMap map5() {
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();
38	>	private static NavigableMap map0() {
39	>	TreeMap map = new TreeMap();
40		assertTrue(map.isEmpty());
41		return map.tailMap(one, true);
42		}
#	Line 44 | Line 44 | public class TreeSubMapTest extends JSR1
44		/**
45		* Create a map from Integers -5 to -1 to Strings "A"-"E".
46		*/
47	<	private static NavigableMap dmap5() {
48	<	TreeMap map = new TreeMap();
47	>	private static NavigableMap dmap5() {
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();
60	>	private static NavigableMap dmap0() {
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();
199	<	assertTrue(
199	>	assertTrue(
200		(e.getKey().equals(one) && e.getValue().equals("A")) ||
201		(e.getKey().equals(two) && e.getValue().equals("B")) ||
202		(e.getKey().equals(three) && e.getValue().equals("C")) ||
#	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 384 | Line 384 | public class TreeSubMapTest extends JSR1
384		for (int i = 1; i <= 5; ++i) {
385		assertTrue(s.indexOf(String.valueOf(i)) >= 0);
386		}
387	<	}
387	>	}
388
389		// Exception tests
390
#	Line 396 | Line 396 | public class TreeSubMapTest extends JSR1
396		NavigableMap c = map5();
397		c.get(null);
398		shouldThrow();
399	<	} catch(NullPointerException e){}
399	>	} catch (NullPointerException e) {}
400		}
401
402		/**
#	Line 407 | Line 407 | public class TreeSubMapTest extends JSR1
407		NavigableMap c = map5();
408		c.containsKey(null);
409		shouldThrow();
410	<	} catch(NullPointerException e){}
410	>	} catch (NullPointerException e) {}
411		}
412
413		/**
#	Line 418 | Line 418 | public class TreeSubMapTest extends JSR1
418		NavigableMap c = map5();
419		c.put(null, "whatever");
420		shouldThrow();
421	<	} catch(NullPointerException e){}
421	>	} catch (NullPointerException e) {}
422		}
423
424		/**
#	Line 429 | Line 429 | public class TreeSubMapTest extends JSR1
429		NavigableMap c = map5();
430		c.remove(null);
431		shouldThrow();
432	<	} catch(NullPointerException e){}
432	>	} catch (NullPointerException e) {}
433		}
434
435		/**
436		* A deserialized map equals original
437		*/
438	<	public void testSerialization() {
438	>	public void testSerialization() throws Exception {
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	<	}
441	>	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
442	>	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
443	>	out.writeObject(q);
444	>	out.close();
445	>
446	>	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
447	>	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
448	>	NavigableMap r = (NavigableMap)in.readObject();
449	>	assertFalse(r.isEmpty());
450	>	assertEquals(q.size(), r.size());
451	>	assertTrue(q.equals(r));
452	>	assertTrue(r.equals(q));
453		}
454
455
#	Line 599 | Line 594 | public class TreeSubMapTest extends JSR1
594		*/
595		public void testDescendingClear() {
596		NavigableMap map = dmap5();
597	<	map.clear();
598	<	assertEquals(map.size(), 0);
597	>	map.clear();
598	>	assertEquals(map.size(), 0);
599		}
600
601
#	Line 612 | Line 607 | public class TreeSubMapTest extends JSR1
607		NavigableMap map2 = dmap5();
608		assertEquals(map1, map2);
609		assertEquals(map2, map1);
610	<	map1.clear();
610	>	map1.clear();
611		assertFalse(map1.equals(map2));
612		assertFalse(map2.equals(map1));
613		}
#	Line 622 | Line 617 | public class TreeSubMapTest extends JSR1
617		*/
618		public void testDescendingContainsKey() {
619		NavigableMap map = dmap5();
620	<	assertTrue(map.containsKey(m1));
620	>	assertTrue(map.containsKey(m1));
621		assertFalse(map.containsKey(zero));
622		}
623
#	Line 631 | Line 626 | public class TreeSubMapTest extends JSR1
626		*/
627		public void testDescendingContainsValue() {
628		NavigableMap map = dmap5();
629	<	assertTrue(map.containsValue("A"));
629	>	assertTrue(map.containsValue("A"));
630		assertFalse(map.containsValue("Z"));
631		}
632
#	Line 641 | Line 636 | public class TreeSubMapTest extends JSR1
636		*/
637		public void testDescendingGet() {
638		NavigableMap map = dmap5();
639	<	assertEquals("A", (String)map.get(m1));
639	>	assertEquals("A", (String)map.get(m1));
640		NavigableMap empty = dmap0();
641		assertNull(empty.get(m1));
642		}
#	Line 652 | Line 647 | public class TreeSubMapTest extends JSR1
647		public void testDescendingIsEmpty() {
648		NavigableMap empty = dmap0();
649		NavigableMap map = dmap5();
650	<	assertTrue(empty.isEmpty());
650	>	assertTrue(empty.isEmpty());
651		assertFalse(map.isEmpty());
652		}
653
#	Line 661 | Line 656 | public class TreeSubMapTest extends JSR1
656		*/
657		public void testDescendingFirstKey() {
658		NavigableMap map = dmap5();
659	<	assertEquals(m1, map.firstKey());
659	>	assertEquals(m1, map.firstKey());
660		}
661
662		/**
#	Line 669 | Line 664 | public class TreeSubMapTest extends JSR1
664		*/
665		public void testDescendingLastKey() {
666		NavigableMap map = dmap5();
667	<	assertEquals(m5, map.lastKey());
667	>	assertEquals(m5, map.lastKey());
668		}
669
670
#	Line 678 | Line 673 | public class TreeSubMapTest extends JSR1
673		*/
674		public void testDescendingKeySet() {
675		NavigableMap map = dmap5();
676	<	Set s = map.keySet();
677	<	assertEquals(5, s.size());
678	<	assertTrue(s.contains(m1));
679	<	assertTrue(s.contains(m2));
680	<	assertTrue(s.contains(m3));
681	<	assertTrue(s.contains(m4));
682	<	assertTrue(s.contains(m5));
676	>	Set s = map.keySet();
677	>	assertEquals(5, s.size());
678	>	assertTrue(s.contains(m1));
679	>	assertTrue(s.contains(m2));
680	>	assertTrue(s.contains(m3));
681	>	assertTrue(s.contains(m4));
682	>	assertTrue(s.contains(m5));
683		}
684
685		/**
#	Line 692 | Line 687 | public class TreeSubMapTest extends JSR1
687		*/
688		public void testDescendingKeySetOrder() {
689		NavigableMap map = dmap5();
690	<	Set s = map.keySet();
690	>	Set s = map.keySet();
691		Iterator i = s.iterator();
692		Integer last = (Integer)i.next();
693		assertEquals(last, m1);
#	Line 708 | Line 703 | public class TreeSubMapTest extends JSR1
703		*/
704		public void testDescendingValues() {
705		NavigableMap map = dmap5();
706	<	Collection s = map.values();
707	<	assertEquals(5, s.size());
708	<	assertTrue(s.contains("A"));
709	<	assertTrue(s.contains("B"));
710	<	assertTrue(s.contains("C"));
711	<	assertTrue(s.contains("D"));
712	<	assertTrue(s.contains("E"));
706	>	Collection s = map.values();
707	>	assertEquals(5, s.size());
708	>	assertTrue(s.contains("A"));
709	>	assertTrue(s.contains("B"));
710	>	assertTrue(s.contains("C"));
711	>	assertTrue(s.contains("D"));
712	>	assertTrue(s.contains("E"));
713		}
714
715		/**
#	Line 722 | Line 717 | public class TreeSubMapTest extends JSR1
717		*/
718		public void testDescendingAscendingKeySetToArray() {
719		NavigableMap map = dmap5();
720	<	Set s = map.keySet();
720	>	Set s = map.keySet();
721		Object[] ar = s.toArray();
722		assertTrue(s.containsAll(Arrays.asList(ar)));
723	<	assertEquals(5, ar.length);
723	>	assertEquals(5, ar.length);
724		ar[0] = m10;
725		assertFalse(s.containsAll(Arrays.asList(ar)));
726		}
#	Line 735 | Line 730 | public class TreeSubMapTest extends JSR1
730		*/
731		public void testDescendingDescendingKeySetToArray() {
732		NavigableMap map = dmap5();
733	<	Set s = map.descendingKeySet();
733	>	Set s = map.descendingKeySet();
734		Object[] ar = s.toArray();
735	<	assertEquals(5, ar.length);
735	>	assertEquals(5, ar.length);
736		assertTrue(s.containsAll(Arrays.asList(ar)));
737		ar[0] = m10;
738		assertFalse(s.containsAll(Arrays.asList(ar)));
#	Line 748 | Line 743 | public class TreeSubMapTest extends JSR1
743		*/
744		public void testDescendingValuesToArray() {
745		NavigableMap map = dmap5();
746	<	Collection v = map.values();
746	>	Collection v = map.values();
747		Object[] ar = v.toArray();
748		ArrayList s = new ArrayList(Arrays.asList(ar));
749	<	assertEquals(5, ar.length);
750	<	assertTrue(s.contains("A"));
751	<	assertTrue(s.contains("B"));
752	<	assertTrue(s.contains("C"));
753	<	assertTrue(s.contains("D"));
754	<	assertTrue(s.contains("E"));
749	>	assertEquals(5, ar.length);
750	>	assertTrue(s.contains("A"));
751	>	assertTrue(s.contains("B"));
752	>	assertTrue(s.contains("C"));
753	>	assertTrue(s.contains("D"));
754	>	assertTrue(s.contains("E"));
755		}
756
757
#	Line 765 | Line 760 | public class TreeSubMapTest extends JSR1
760		*/
761		public void testDescendingEntrySet() {
762		NavigableMap map = dmap5();
763	<	Set s = map.entrySet();
764	<	assertEquals(5, s.size());
763	>	Set s = map.entrySet();
764	>	assertEquals(5, s.size());
765		Iterator it = s.iterator();
766		while (it.hasNext()) {
767		Map.Entry e = (Map.Entry) it.next();
768	<	assertTrue(
768	>	assertTrue(
769		(e.getKey().equals(m1) && e.getValue().equals("A")) ||
770		(e.getKey().equals(m2) && e.getValue().equals("B")) ||
771		(e.getKey().equals(m3) && e.getValue().equals("C")) ||
#	Line 785 | Line 780 | public class TreeSubMapTest extends JSR1
780		public void testDescendingPutAll() {
781		NavigableMap empty = dmap0();
782		NavigableMap map = dmap5();
783	<	empty.putAll(map);
784	<	assertEquals(5, empty.size());
785	<	assertTrue(empty.containsKey(m1));
786	<	assertTrue(empty.containsKey(m2));
787	<	assertTrue(empty.containsKey(m3));
788	<	assertTrue(empty.containsKey(m4));
789	<	assertTrue(empty.containsKey(m5));
783	>	empty.putAll(map);
784	>	assertEquals(5, empty.size());
785	>	assertTrue(empty.containsKey(m1));
786	>	assertTrue(empty.containsKey(m2));
787	>	assertTrue(empty.containsKey(m3));
788	>	assertTrue(empty.containsKey(m4));
789	>	assertTrue(empty.containsKey(m5));
790		}
791
792
#	Line 800 | Line 795 | public class TreeSubMapTest extends JSR1
795		*/
796		public void testDescendingRemove() {
797		NavigableMap map = dmap5();
798	<	map.remove(m5);
799	<	assertEquals(4, map.size());
800	<	assertFalse(map.containsKey(m5));
798	>	map.remove(m5);
799	>	assertEquals(4, map.size());
800	>	assertFalse(map.containsKey(m5));
801		}
802
803		/**
#	Line 943 | Line 938 | public class TreeSubMapTest extends JSR1
938		public void testDescendingSize() {
939		NavigableMap map = dmap5();
940		NavigableMap empty = dmap0();
941	<	assertEquals(0, empty.size());
942	<	assertEquals(5, map.size());
941	>	assertEquals(0, empty.size());
942	>	assertEquals(5, map.size());
943		}
944
945		/**
#	Line 956 | Line 951 | public class TreeSubMapTest extends JSR1
951		for (int i = 1; i <= 5; ++i) {
952		assertTrue(s.indexOf(String.valueOf(i)) >= 0);
953		}
954	<	}
954	>	}
955
956		// Exception testDescendings
957
#	Line 968 | Line 963 | public class TreeSubMapTest extends JSR1
963		NavigableMap c = dmap5();
964		c.get(null);
965		shouldThrow();
966	<	} catch(NullPointerException e){}
966	>	} catch (NullPointerException e) {}
967		}
968
969		/**
#	Line 979 | Line 974 | public class TreeSubMapTest extends JSR1
974		NavigableMap c = dmap5();
975		c.put(null, "whatever");
976		shouldThrow();
977	<	} catch(NullPointerException e){}
977	>	} catch (NullPointerException e) {}
978		}
979
980		/**
981		* A deserialized map equals original
982		*/
983	<	public void testDescendingSerialization() {
983	>	public void testDescendingSerialization() throws Exception {
984		NavigableMap q = dmap5();
990	–
991	–	try {
992	–	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
993	–	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
994	–	out.writeObject(q);
995	–	out.close();
996	–
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	–	}
1007	–	}
985
986	+	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
987	+	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
988	+	out.writeObject(q);
989	+	out.close();
990	+
991	+	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
992	+	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
993	+	NavigableMap r = (NavigableMap)in.readObject();
994	+	assertEquals(q.size(), r.size());
995	+	assertTrue(q.equals(r));
996	+	assertTrue(r.equals(q));
997	+	}
998
999
1000		/**
#	Line 1142 | Line 1131 | public class TreeSubMapTest extends JSR1
1131		assertEquals(3, sm.size());
1132		assertEquals(4, map.size());
1133		}
1134	<
1134	>
1135		}

Diff Legend

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