ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/TreeMapTest.java

Comparing jsr166/src/test/tck/TreeMapTest.java (file contents):
Revision 1.10 by jsr166, Sat Nov 21 10:25:05 2009 UTC vs.
Revision 1.29 by jsr166, Wed Dec 31 21:45:16 2014 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.Arrays;
8	>	import java.util.BitSet;
9	>	import java.util.Collection;
10	>	import java.util.Iterator;
11	>	import java.util.Map;
12	>	import java.util.NavigableMap;
13	>	import java.util.NavigableSet;
14	>	import java.util.NoSuchElementException;
15	>	import java.util.Random;
16	>	import java.util.Set;
17	>	import java.util.TreeMap;
18	>
19	>	import junit.framework.Test;
20	>	import junit.framework.TestSuite;
21
22		public class TreeMapTest extends JSR166TestCase {
23		public static void main(String[] args) {
24	<	junit.textui.TestRunner.run (suite());
24	>	junit.textui.TestRunner.run(suite());
25		}
26		public static Test suite() {
27		return new TestSuite(TreeMapTest.class);
28		}
29
30		/**
31	<	* Create a map from Integers 1-5 to Strings "A"-"E".
31	>	* Returns a new map from Integers 1-5 to Strings "A"-"E".
32		*/
33		private static TreeMap map5() {
34		TreeMap map = new TreeMap();
#	Line 34 | Line 44 | public class TreeMapTest extends JSR166T
44		}
45
46		/**
47	<	*  clear removes all pairs
47	>	* clear removes all pairs
48		*/
49		public void testClear() {
50		TreeMap map = map5();
51		map.clear();
52	<	assertEquals(map.size(), 0);
52	>	assertEquals(0, map.size());
53		}
54
55		/**
56	<	*
56	>	* copy constructor creates map equal to source map
57		*/
58		public void testConstructFromSorted() {
59		TreeMap map = map5();
#	Line 52 | Line 62 | public class TreeMapTest extends JSR166T
62		}
63
64		/**
65	<	*  Maps with same contents are equal
65	>	* Maps with same contents are equal
66		*/
67		public void testEquals() {
68		TreeMap map1 = map5();
#	Line 65 | Line 75 | public class TreeMapTest extends JSR166T
75		}
76
77		/**
78	<	*  containsKey returns true for contained key
78	>	* containsKey returns true for contained key
79		*/
80		public void testContainsKey() {
81		TreeMap map = map5();
#	Line 74 | Line 84 | public class TreeMapTest extends JSR166T
84		}
85
86		/**
87	<	*  containsValue returns true for held values
87	>	* containsValue returns true for held values
88		*/
89		public void testContainsValue() {
90		TreeMap map = map5();
#	Line 83 | Line 93 | public class TreeMapTest extends JSR166T
93		}
94
95		/**
96	<	*  get returns the correct element at the given key,
97	<	*  or null if not present
96	>	* get returns the correct element at the given key,
97	>	* or null if not present
98		*/
99		public void testGet() {
100		TreeMap map = map5();
#	Line 94 | Line 104 | public class TreeMapTest extends JSR166T
104		}
105
106		/**
107	<	*  isEmpty is true of empty map and false for non-empty
107	>	* isEmpty is true of empty map and false for non-empty
108		*/
109		public void testIsEmpty() {
110		TreeMap empty = new TreeMap();
#	Line 104 | Line 114 | public class TreeMapTest extends JSR166T
114		}
115
116		/**
117	<	*   firstKey returns first key
117	>	* firstKey returns first key
118		*/
119		public void testFirstKey() {
120		TreeMap map = map5();
#	Line 112 | Line 122 | public class TreeMapTest extends JSR166T
122		}
123
124		/**
125	<	*   lastKey returns last key
125	>	* lastKey returns last key
126		*/
127		public void testLastKey() {
128		TreeMap map = map5();
129		assertEquals(five, map.lastKey());
130		}
131
122	–
132		/**
133	<	*  keySet.toArray returns contains all keys
133	>	* keySet.toArray returns contains all keys
134		*/
135		public void testKeySetToArray() {
136		TreeMap map = map5();
#	Line 134 | Line 143 | public class TreeMapTest extends JSR166T
143		}
144
145		/**
146	<	*  descendingkeySet.toArray returns contains all keys
146	>	* descendingkeySet.toArray returns contains all keys
147		*/
148		public void testDescendingKeySetToArray() {
149		TreeMap map = map5();
#	Line 147 | Line 156 | public class TreeMapTest extends JSR166T
156		}
157
158		/**
159	<	*   keySet returns a Set containing all the keys
159	>	* keySet returns a Set containing all the keys
160		*/
161		public void testKeySet() {
162		TreeMap map = map5();
#	Line 161 | Line 170 | public class TreeMapTest extends JSR166T
170		}
171
172		/**
173	<	*   keySet is ordered
173	>	* keySet is ordered
174		*/
175		public void testKeySetOrder() {
176		TreeMap map = map5();
#	Line 176 | Line 185 | public class TreeMapTest extends JSR166T
185		last = k;
186		++count;
187		}
188	<	assertEquals(count ,5);
188	>	assertEquals(5, count);
189		}
190
191		/**
#	Line 195 | Line 204 | public class TreeMapTest extends JSR166T
204		last = k;
205		++count;
206		}
207	<	assertEquals(count ,5);
207	>	assertEquals(5, count);
208		}
209
210		/**
211	<	*   descendingKeySet is ordered
211	>	* descendingKeySet is ordered
212		*/
213		public void testDescendingKeySetOrder() {
214		TreeMap map = map5();
#	Line 214 | Line 223 | public class TreeMapTest extends JSR166T
223		last = k;
224		++count;
225		}
226	<	assertEquals(count, 5);
226	>	assertEquals(5, count);
227		}
228
229		/**
230	<	*  descending iterator of descendingKeySet is ordered
230	>	* descending iterator of descendingKeySet is ordered
231		*/
232		public void testDescendingKeySetDescendingIteratorOrder() {
233		TreeMap map = map5();
#	Line 233 | Line 242 | public class TreeMapTest extends JSR166T
242		last = k;
243		++count;
244		}
245	<	assertEquals(count, 5);
245	>	assertEquals(5, count);
246		}
247
248		/**
#	Line 289 | Line 298 | public class TreeMapTest extends JSR166T
298		}
299
300		/**
301	<	*  entrySet.toArray contains all entries
301	>	* entrySet.toArray contains all entries
302		*/
303		public void testEntrySetToArray() {
304		TreeMap map = map5();
#	Line 303 | Line 312 | public class TreeMapTest extends JSR166T
312		}
313
314		/**
315	<	*  descendingEntrySet.toArray contains all entries
315	>	* descendingEntrySet.toArray contains all entries
316		*/
317		public void testDescendingEntrySetToArray() {
318		TreeMap map = map5();
#	Line 317 | Line 326 | public class TreeMapTest extends JSR166T
326		}
327
328		/**
329	<	*   putAll  adds all key-value pairs from the given map
329	>	* putAll adds all key-value pairs from the given map
330		*/
331		public void testPutAll() {
332		TreeMap empty = new TreeMap();
#	Line 332 | Line 341 | public class TreeMapTest extends JSR166T
341		}
342
343		/**
344	<	*   remove removes the correct key-value pair from the map
344	>	* remove removes the correct key-value pair from the map
345		*/
346		public void testRemove() {
347		TreeMap map = map5();
#	Line 357 | Line 366 | public class TreeMapTest extends JSR166T
366
367		Map.Entry e4 = map.lowerEntry(zero);
368		assertNull(e4);
360	–
369		}
370
371		/**
#	Line 376 | Line 384 | public class TreeMapTest extends JSR166T
384
385		Map.Entry e4 = map.higherEntry(six);
386		assertNull(e4);
379	–
387		}
388
389		/**
#	Line 395 | Line 402 | public class TreeMapTest extends JSR166T
402
403		Map.Entry e4 = map.floorEntry(zero);
404		assertNull(e4);
398	–
405		}
406
407		/**
#	Line 414 | Line 420 | public class TreeMapTest extends JSR166T
420
421		Map.Entry e4 = map.ceilingEntry(six);
422		assertNull(e4);
417	–
423		}
424
420	–
425		/**
426		* lowerKey returns preceding element
427		*/
#	Line 434 | Line 438 | public class TreeMapTest extends JSR166T
438
439		Object e4 = q.lowerKey(zero);
440		assertNull(e4);
437	–
441		}
442
443		/**
#	Line 453 | Line 456 | public class TreeMapTest extends JSR166T
456
457		Object e4 = q.higherKey(six);
458		assertNull(e4);
456	–
459		}
460
461		/**
#	Line 472 | Line 474 | public class TreeMapTest extends JSR166T
474
475		Object e4 = q.floorKey(zero);
476		assertNull(e4);
475	–
477		}
478
479		/**
#	Line 491 | Line 492 | public class TreeMapTest extends JSR166T
492
493		Object e4 = q.ceilingKey(six);
494		assertNull(e4);
494	–
495		}
496
497		/**
#	Line 516 | Line 516 | public class TreeMapTest extends JSR166T
516		try {
517		e.setValue("A");
518		shouldThrow();
519	<	} catch (Exception ok) {
520	<	}
519	>	} catch (UnsupportedOperationException success) {}
520		e = map.pollFirstEntry();
521		assertNull(e);
522		}
#	Line 544 | Line 543 | public class TreeMapTest extends JSR166T
543		try {
544		e.setValue("E");
545		shouldThrow();
546	<	} catch (Exception ok) {
548	<	}
546	>	} catch (UnsupportedOperationException success) {}
547		e = map.pollLastEntry();
548		assertNull(e);
549		}
550
551		/**
552	<	*   size returns the correct values
552	>	* size returns the correct values
553		*/
554		public void testSize() {
555		TreeMap map = map5();
#	Line 567 | Line 565 | public class TreeMapTest extends JSR166T
565		TreeMap map = map5();
566		String s = map.toString();
567		for (int i = 1; i <= 5; ++i) {
568	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
568	>	assertTrue(s.contains(String.valueOf(i)));
569		}
570		}
571
#	Line 581 | Line 579 | public class TreeMapTest extends JSR166T
579		TreeMap c = map5();
580		c.get(null);
581		shouldThrow();
582	<	} catch (NullPointerException e) {}
582	>	} catch (NullPointerException success) {}
583		}
584
585		/**
#	Line 592 | Line 590 | public class TreeMapTest extends JSR166T
590		TreeMap c = map5();
591		c.containsKey(null);
592		shouldThrow();
593	<	} catch (NullPointerException e) {}
593	>	} catch (NullPointerException success) {}
594		}
595
596		/**
#	Line 604 | Line 602 | public class TreeMapTest extends JSR166T
602		c.put("sadsdf", "asdads");
603		c.remove(null);
604		shouldThrow();
605	<	} catch (NullPointerException e) {}
605	>	} catch (NullPointerException success) {}
606		}
607
608		/**
609		* A deserialized map equals original
610		*/
611		public void testSerialization() throws Exception {
612	<	TreeMap q = map5();
612	>	NavigableMap x = map5();
613	>	NavigableMap y = serialClone(x);
614
615	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
616	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
617	<	out.writeObject(q);
618	<	out.close();
619	<
621	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
622	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
623	<	TreeMap r = (TreeMap)in.readObject();
624	<	assertEquals(q.size(), r.size());
625	<	assertTrue(q.equals(r));
626	<	assertTrue(r.equals(q));
615	>	assertNotSame(x, y);
616	>	assertEquals(x.size(), y.size());
617	>	assertEquals(x.toString(), y.toString());
618	>	assertEquals(x, y);
619	>	assertEquals(y, x);
620		}
621
622		/**
#	Line 662 | Line 655 | public class TreeMapTest extends JSR166T
655		assertEquals(1, sm.size());
656		assertEquals(three, sm.firstKey());
657		assertEquals(three, sm.lastKey());
658	<	assertTrue(sm.remove(three) != null);
658	>	assertEquals("C", sm.remove(three));
659		assertTrue(sm.isEmpty());
660		assertEquals(3, map.size());
661		}
#	Line 695 | Line 688 | public class TreeMapTest extends JSR166T
688		assertEquals(4, map.size());
689		assertEquals(0, sm.size());
690		assertTrue(sm.isEmpty());
691	<	assertTrue(sm.remove(three) == null);
691	>	assertSame(sm.remove(three), null);
692		assertEquals(4, map.size());
693		}
694
#	Line 777 | Line 770 | public class TreeMapTest extends JSR166T
770		NavigableMap ssm = sm.tailMap(four, true);
771		assertEquals(four, ssm.firstKey());
772		assertEquals(five, ssm.lastKey());
773	<	assertTrue(ssm.remove(four) != null);
773	>	assertEquals("D", ssm.remove(four));
774		assertEquals(1, ssm.size());
775		assertEquals(3, sm.size());
776		assertEquals(4, map.size());
#	Line 789 | Line 782 | public class TreeMapTest extends JSR166T
782		/**
783		* Submaps of submaps subdivide correctly
784		*/
785	<	public void testRecursiveSubMaps() {
786	<	int mapSize = 1000;
785	>	public void testRecursiveSubMaps() throws Exception {
786	>	int mapSize = expensiveTests ? 1000 : 100;
787		Class cl = TreeMap.class;
788		NavigableMap<Integer, Integer> map = newMap(cl);
789		bs = new BitSet(mapSize);
#	Line 807 | Line 800 | public class TreeMapTest extends JSR166T
800		0, mapSize - 1, true);
801		}
802
803	<	static NavigableMap<Integer, Integer> newMap(Class cl) {
804	<	NavigableMap<Integer, Integer> result = null;
805	<	try {
806	<	result = (NavigableMap<Integer, Integer>) cl.newInstance();
814	<	} catch (Exception e) {
815	<	fail();
816	<	}
817	<	assertEquals(result.size(), 0);
803	>	static NavigableMap<Integer, Integer> newMap(Class cl) throws Exception {
804	>	NavigableMap<Integer, Integer> result
805	>	= (NavigableMap<Integer, Integer>) cl.newInstance();
806	>	assertEquals(0, result.size());
807		assertFalse(result.keySet().iterator().hasNext());
808		return result;
809		}
#	Line 846 | Line 835 | public class TreeMapTest extends JSR166T
835		// Add entries till we're back to original size
836		while (map.size() < size) {
837		int key = min + rnd.nextInt(rangeSize);
838	<	assertTrue(key >= min && key<= max);
838	>	assertTrue(key >= min && key <= max);
839		put(map, key);
840		}
841		}
#	Line 871 | Line 860 | public class TreeMapTest extends JSR166T
860		// Add entries till we're back to original size
861		while (map.size() < size) {
862		int key = min - 5 + rnd.nextInt(rangeSize + 10);
863	<	if (key >= min && key<= max) {
863	>	if (key >= min && key <= max) {
864		put(map, key);
865		} else {
866		try {
867		map.put(key, 2 * key);
868	<	fail();
869	<	} catch (IllegalArgumentException e) {
881	<	// expected
882	<	}
868	>	shouldThrow();
869	>	} catch (IllegalArgumentException success) {}
870		}
871		}
872		}
#	Line 977 | Line 964 | public class TreeMapTest extends JSR166T
964		*/
965		void check(NavigableMap<Integer, Integer> map,
966		final int min, final int max, final boolean ascending) {
967	<	class ReferenceSet {
967	>	class ReferenceSet {
968		int lower(int key) {
969		return ascending ? lowerAscending(key) : higherAscending(key);
970		}
#	Line 1008 | Line 995 | public class TreeMapTest extends JSR166T
995		// BitSet should support this! Test would run much faster
996		while (key >= min) {
997		if (bs.get(key))
998	<	return(key);
998	>	return key;
999		key--;
1000		}
1001		return -1;
#	Line 1043 | Line 1030 | public class TreeMapTest extends JSR166T
1030		if (bsContainsI)
1031		size++;
1032		}
1033	<	assertEquals(map.size(), size);
1033	>	assertEquals(size, map.size());
1034
1035		// Test contents using contains keySet iterator
1036		int size2 = 0;
#	Line 1074 | Line 1061 | public class TreeMapTest extends JSR166T
1061		assertEq(rs.last(),  -1);
1062		try {
1063		map.firstKey();
1064	<	fail();
1065	<	} catch (NoSuchElementException e) {
1079	<	// expected
1080	<	}
1064	>	shouldThrow();
1065	>	} catch (NoSuchElementException success) {}
1066		try {
1067		map.lastKey();
1068	<	fail();
1069	<	} catch (NoSuchElementException e) {
1085	<	// expected
1086	<	}
1068	>	shouldThrow();
1069	>	} catch (NoSuchElementException success) {}
1070		}
1071		}
1072

Diff Legend

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