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.9 by jsr166, Sat Nov 21 17:38:06 2009 UTC vs.
Revision 1.16 by jsr166, Tue May 31 16:16:24 2011 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.*;
9
10		public class TreeSubMapTest extends JSR166TestCase {
11		public static void main(String[] args) {
12	<	junit.textui.TestRunner.run (suite());
12	>	junit.textui.TestRunner.run(suite());
13		}
14		public static Test suite() {
15		return new TestSuite(TreeSubMapTest.class);
#	Line 64 | Line 62 | public class TreeSubMapTest extends JSR1
62		}
63
64		/**
65	<	*  clear removes all pairs
65	>	* clear removes all pairs
66		*/
67		public void testClear() {
68		NavigableMap map = map5();
#	Line 72 | Line 70 | public class TreeSubMapTest extends JSR1
70		assertEquals(map.size(), 0);
71		}
72
75	–
73		/**
74	<	*  Maps with same contents are equal
74	>	* Maps with same contents are equal
75		*/
76		public void testEquals() {
77		NavigableMap map1 = map5();
#	Line 87 | Line 84 | public class TreeSubMapTest extends JSR1
84		}
85
86		/**
87	<	*  containsKey returns true for contained key
87	>	* containsKey returns true for contained key
88		*/
89		public void testContainsKey() {
90		NavigableMap map = map5();
#	Line 96 | Line 93 | public class TreeSubMapTest extends JSR1
93		}
94
95		/**
96	<	*  containsValue returns true for held values
96	>	* containsValue returns true for held values
97		*/
98		public void testContainsValue() {
99		NavigableMap map = map5();
#	Line 105 | Line 102 | public class TreeSubMapTest extends JSR1
102		}
103
104		/**
105	<	*  get returns the correct element at the given key,
106	<	*  or null if not present
105	>	* get returns the correct element at the given key,
106	>	* or null if not present
107		*/
108		public void testGet() {
109		NavigableMap map = map5();
#	Line 116 | Line 113 | public class TreeSubMapTest extends JSR1
113		}
114
115		/**
116	<	*  isEmpty is true of empty map and false for non-empty
116	>	* isEmpty is true of empty map and false for non-empty
117		*/
118		public void testIsEmpty() {
119		NavigableMap empty = map0();
#	Line 126 | Line 123 | public class TreeSubMapTest extends JSR1
123		}
124
125		/**
126	<	*   firstKey returns first key
126	>	* firstKey returns first key
127		*/
128		public void testFirstKey() {
129		NavigableMap map = map5();
#	Line 134 | Line 131 | public class TreeSubMapTest extends JSR1
131		}
132
133		/**
134	<	*   lastKey returns last key
134	>	* lastKey returns last key
135		*/
136		public void testLastKey() {
137		NavigableMap map = map5();
138		assertEquals(five, map.lastKey());
139		}
140
144	–
141		/**
142	<	*   keySet returns a Set containing all the keys
142	>	* keySet returns a Set containing all the keys
143		*/
144		public void testKeySet() {
145		NavigableMap map = map5();
#	Line 157 | Line 153 | public class TreeSubMapTest extends JSR1
153		}
154
155		/**
156	<	*   keySet is ordered
156	>	* keySet is ordered
157		*/
158		public void testKeySetOrder() {
159		NavigableMap map = map5();
#	Line 206 | Line 202 | public class TreeSubMapTest extends JSR1
202		}
203
204		/**
205	<	*   putAll  adds all key-value pairs from the given map
205	>	* putAll adds all key-value pairs from the given map
206		*/
207		public void testPutAll() {
208		NavigableMap empty = map0();
#	Line 221 | Line 217 | public class TreeSubMapTest extends JSR1
217		}
218
219		/**
220	<	*   remove removes the correct key-value pair from the map
220	>	* remove removes the correct key-value pair from the map
221		*/
222		public void testRemove() {
223		NavigableMap map = map5();
#	Line 246 | Line 242 | public class TreeSubMapTest extends JSR1
242
243		Map.Entry e4 = map.lowerEntry(zero);
244		assertNull(e4);
249	–
245		}
246
247		/**
#	Line 265 | Line 260 | public class TreeSubMapTest extends JSR1
260
261		Map.Entry e4 = map.higherEntry(six);
262		assertNull(e4);
268	–
263		}
264
265		/**
#	Line 284 | Line 278 | public class TreeSubMapTest extends JSR1
278
279		Map.Entry e4 = map.floorEntry(zero);
280		assertNull(e4);
287	–
281		}
282
283		/**
#	Line 303 | Line 296 | public class TreeSubMapTest extends JSR1
296
297		Map.Entry e4 = map.ceilingEntry(six);
298		assertNull(e4);
306	–
299		}
300
301		/**
#	Line 364 | Line 356 | public class TreeSubMapTest extends JSR1
356		}
357
358		/**
359	<	*   size returns the correct values
359	>	* size returns the correct values
360		*/
361		public void testSize() {
362		NavigableMap map = map5();
#	Line 380 | Line 372 | public class TreeSubMapTest extends JSR1
372		NavigableMap map = map5();
373		String s = map.toString();
374		for (int i = 1; i <= 5; ++i) {
375	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
375	>	assertTrue(s.contains(String.valueOf(i)));
376		}
377		}
378
#	Line 434 | Line 426 | public class TreeSubMapTest extends JSR1
426		* A deserialized map equals original
427		*/
428		public void testSerialization() throws Exception {
429	<	NavigableMap q = map5();
429	>	NavigableMap x = map5();
430	>	NavigableMap y = serialClone(x);
431
432	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
433	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
434	<	out.writeObject(q);
435	<	out.close();
436	<
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));
432	>	assertTrue(x != y);
433	>	assertEquals(x.size(), y.size());
434	>	assertEquals(x.toString(), y.toString());
435	>	assertEquals(x, y);
436	>	assertEquals(y, x);
437		}
438
453	–
454	–
439		/**
440		* subMap returns map with keys in requested range
441		*/
#	Line 481 | Line 465 | public class TreeSubMapTest extends JSR1
465		assertEquals(1, sm.size());
466		assertEquals(three, sm.firstKey());
467		assertEquals(three, sm.lastKey());
468	<	assertTrue(sm.remove(three) != null);
468	>	assertEquals("C", sm.remove(three));
469		assertTrue(sm.isEmpty());
470		assertEquals(3, map.size());
471		}
#	Line 509 | Line 493 | public class TreeSubMapTest extends JSR1
493		assertEquals(4, map.size());
494		assertEquals(0, sm.size());
495		assertTrue(sm.isEmpty());
496	<	assertTrue(sm.remove(three) == null);
496	>	assertSame(sm.remove(three), null);
497		assertEquals(4, map.size());
498		}
499
#	Line 581 | Line 565 | public class TreeSubMapTest extends JSR1
565		SortedMap ssm = sm.tailMap(four);
566		assertEquals(four, ssm.firstKey());
567		assertEquals(five, ssm.lastKey());
568	<	assertTrue(ssm.remove(four) != null);
568	>	assertEquals("D", ssm.remove(four));
569		assertEquals(1, ssm.size());
570		assertEquals(3, sm.size());
571		assertEquals(4, map.size());
572		}
573
574		/**
575	<	*  clear removes all pairs
575	>	* clear removes all pairs
576		*/
577		public void testDescendingClear() {
578		NavigableMap map = dmap5();
#	Line 596 | Line 580 | public class TreeSubMapTest extends JSR1
580		assertEquals(map.size(), 0);
581		}
582
599	–
583		/**
584	<	*  Maps with same contents are equal
584	>	* Maps with same contents are equal
585		*/
586		public void testDescendingEquals() {
587		NavigableMap map1 = dmap5();
#	Line 611 | Line 594 | public class TreeSubMapTest extends JSR1
594		}
595
596		/**
597	<	*  containsKey returns true for contained key
597	>	* containsKey returns true for contained key
598		*/
599		public void testDescendingContainsKey() {
600		NavigableMap map = dmap5();
#	Line 620 | Line 603 | public class TreeSubMapTest extends JSR1
603		}
604
605		/**
606	<	*  containsValue returns true for held values
606	>	* containsValue returns true for held values
607		*/
608		public void testDescendingContainsValue() {
609		NavigableMap map = dmap5();
#	Line 629 | Line 612 | public class TreeSubMapTest extends JSR1
612		}
613
614		/**
615	<	*  get returns the correct element at the given key,
616	<	*  or null if not present
615	>	* get returns the correct element at the given key,
616	>	* or null if not present
617		*/
618		public void testDescendingGet() {
619		NavigableMap map = dmap5();
#	Line 640 | Line 623 | public class TreeSubMapTest extends JSR1
623		}
624
625		/**
626	<	*  isEmpty is true of empty map and false for non-empty
626	>	* isEmpty is true of empty map and false for non-empty
627		*/
628		public void testDescendingIsEmpty() {
629		NavigableMap empty = dmap0();
#	Line 650 | Line 633 | public class TreeSubMapTest extends JSR1
633		}
634
635		/**
636	<	*   firstKey returns first key
636	>	* firstKey returns first key
637		*/
638		public void testDescendingFirstKey() {
639		NavigableMap map = dmap5();
#	Line 658 | Line 641 | public class TreeSubMapTest extends JSR1
641		}
642
643		/**
644	<	*   lastKey returns last key
644	>	* lastKey returns last key
645		*/
646		public void testDescendingLastKey() {
647		NavigableMap map = dmap5();
648		assertEquals(m5, map.lastKey());
649		}
650
668	–
651		/**
652	<	*   keySet returns a Set containing all the keys
652	>	* keySet returns a Set containing all the keys
653		*/
654		public void testDescendingKeySet() {
655		NavigableMap map = dmap5();
#	Line 681 | Line 663 | public class TreeSubMapTest extends JSR1
663		}
664
665		/**
666	<	*   keySet is ordered
666	>	* keySet is ordered
667		*/
668		public void testDescendingKeySetOrder() {
669		NavigableMap map = dmap5();
#	Line 711 | Line 693 | public class TreeSubMapTest extends JSR1
693		}
694
695		/**
696	<	*  keySet.toArray returns contains all keys
696	>	* keySet.toArray returns contains all keys
697		*/
698		public void testDescendingAscendingKeySetToArray() {
699		NavigableMap map = dmap5();
#	Line 724 | Line 706 | public class TreeSubMapTest extends JSR1
706		}
707
708		/**
709	<	*  descendingkeySet.toArray returns contains all keys
709	>	* descendingkeySet.toArray returns contains all keys
710		*/
711		public void testDescendingDescendingKeySetToArray() {
712		NavigableMap map = dmap5();
#	Line 737 | Line 719 | public class TreeSubMapTest extends JSR1
719		}
720
721		/**
722	<	*  Values.toArray contains all values
722	>	* Values.toArray contains all values
723		*/
724		public void testDescendingValuesToArray() {
725		NavigableMap map = dmap5();
#	Line 752 | Line 734 | public class TreeSubMapTest extends JSR1
734		assertTrue(s.contains("E"));
735		}
736
755	–
737		/**
738		* entrySet contains all pairs
739		*/
#	Line 773 | Line 754 | public class TreeSubMapTest extends JSR1
754		}
755
756		/**
757	<	*   putAll  adds all key-value pairs from the given map
757	>	* putAll adds all key-value pairs from the given map
758		*/
759		public void testDescendingPutAll() {
760		NavigableMap empty = dmap0();
#	Line 787 | Line 768 | public class TreeSubMapTest extends JSR1
768		assertTrue(empty.containsKey(m5));
769		}
770
790	–
771		/**
772	<	*   remove removes the correct key-value pair from the map
772	>	* remove removes the correct key-value pair from the map
773		*/
774		public void testDescendingRemove() {
775		NavigableMap map = dmap5();
#	Line 814 | Line 794 | public class TreeSubMapTest extends JSR1
794
795		Map.Entry e4 = map.lowerEntry(zero);
796		assertNull(e4);
817	–
797		}
798
799		/**
#	Line 833 | Line 812 | public class TreeSubMapTest extends JSR1
812
813		Map.Entry e4 = map.higherEntry(m6);
814		assertNull(e4);
836	–
815		}
816
817		/**
#	Line 852 | Line 830 | public class TreeSubMapTest extends JSR1
830
831		Map.Entry e4 = map.floorEntry(zero);
832		assertNull(e4);
855	–
833		}
834
835		/**
#	Line 871 | Line 848 | public class TreeSubMapTest extends JSR1
848
849		Map.Entry e4 = map.ceilingEntry(m6);
850		assertNull(e4);
874	–
851		}
852
853		/**
#	Line 929 | Line 905 | public class TreeSubMapTest extends JSR1
905		}
906
907		/**
908	<	*   size returns the correct values
908	>	* size returns the correct values
909		*/
910		public void testDescendingSize() {
911		NavigableMap map = dmap5();
#	Line 945 | Line 921 | public class TreeSubMapTest extends JSR1
921		NavigableMap map = dmap5();
922		String s = map.toString();
923		for (int i = 1; i <= 5; ++i) {
924	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
924	>	assertTrue(s.contains(String.valueOf(i)));
925		}
926		}
927
#	Line 977 | Line 953 | public class TreeSubMapTest extends JSR1
953		* A deserialized map equals original
954		*/
955		public void testDescendingSerialization() throws Exception {
956	<	NavigableMap q = dmap5();
956	>	NavigableMap x = dmap5();
957	>	NavigableMap y = serialClone(x);
958
959	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
960	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
961	<	out.writeObject(q);
962	<	out.close();
963	<
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));
959	>	assertTrue(x != y);
960	>	assertEquals(x.size(), y.size());
961	>	assertEquals(x.toString(), y.toString());
962	>	assertEquals(x, y);
963	>	assertEquals(y, x);
964		}
965
995	–
966		/**
967		* subMap returns map with keys in requested range
968		*/
#	Line 1022 | Line 992 | public class TreeSubMapTest extends JSR1
992		assertEquals(1, sm.size());
993		assertEquals(m3, sm.firstKey());
994		assertEquals(m3, sm.lastKey());
995	<	assertTrue(sm.remove(m3) != null);
995	>	assertEquals("C", sm.remove(m3));
996		assertTrue(sm.isEmpty());
997		assertEquals(3, map.size());
998		}
#	Line 1050 | Line 1020 | public class TreeSubMapTest extends JSR1
1020		assertEquals(4, map.size());
1021		assertEquals(0, sm.size());
1022		assertTrue(sm.isEmpty());
1023	<	assertTrue(sm.remove(m3) == null);
1023	>	assertSame(sm.remove(m3), null);
1024		assertEquals(4, map.size());
1025		}
1026
#	Line 1122 | Line 1092 | public class TreeSubMapTest extends JSR1
1092		SortedMap ssm = sm.tailMap(m4);
1093		assertEquals(m4, ssm.firstKey());
1094		assertEquals(m5, ssm.lastKey());
1095	<	assertTrue(ssm.remove(m4) != null);
1095	>	assertEquals("D", ssm.remove(m4));
1096		assertEquals(1, ssm.size());
1097		assertEquals(3, sm.size());
1098		assertEquals(4, map.size());

Diff Legend

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