ViewVC Help

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

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

Comparing jsr166/src/test/tck/ConcurrentSkipListMapTest.java (file contents):
Revision 1.15 by jsr166, Tue Dec 1 06:03:49 2009 UTC vs.
Revision 1.24 by jsr166, Fri May 27 19:21:27 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.*;
#	Line 11 | Line 11 | import java.io.*;
11
12		public class ConcurrentSkipListMapTest 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(ConcurrentSkipListMapTest.class);
#	Line 34 | Line 34 | public class ConcurrentSkipListMapTest e
34		}
35
36		/**
37	<	*  clear removes all pairs
37	>	* clear removes all pairs
38		*/
39		public void testClear() {
40		ConcurrentSkipListMap map = map5();
#	Line 52 | Line 52 | public class ConcurrentSkipListMapTest e
52		}
53
54		/**
55	<	*  Maps with same contents are equal
55	>	* Maps with same contents are equal
56		*/
57		public void testEquals() {
58		ConcurrentSkipListMap map1 = map5();
#	Line 65 | Line 65 | public class ConcurrentSkipListMapTest e
65		}
66
67		/**
68	<	*  containsKey returns true for contained key
68	>	* containsKey returns true for contained key
69		*/
70		public void testContainsKey() {
71		ConcurrentSkipListMap map = map5();
#	Line 74 | Line 74 | public class ConcurrentSkipListMapTest e
74		}
75
76		/**
77	<	*  containsValue returns true for held values
77	>	* containsValue returns true for held values
78		*/
79		public void testContainsValue() {
80		ConcurrentSkipListMap map = map5();
#	Line 83 | Line 83 | public class ConcurrentSkipListMapTest e
83		}
84
85		/**
86	<	*  get returns the correct element at the given key,
87	<	*  or null if not present
86	>	* get returns the correct element at the given key,
87	>	* or null if not present
88		*/
89		public void testGet() {
90		ConcurrentSkipListMap map = map5();
#	Line 94 | Line 94 | public class ConcurrentSkipListMapTest e
94		}
95
96		/**
97	<	*  isEmpty is true of empty map and false for non-empty
97	>	* isEmpty is true of empty map and false for non-empty
98		*/
99		public void testIsEmpty() {
100		ConcurrentSkipListMap empty = new ConcurrentSkipListMap();
#	Line 104 | Line 104 | public class ConcurrentSkipListMapTest e
104		}
105
106		/**
107	<	*   firstKey returns first key
107	>	* firstKey returns first key
108		*/
109		public void testFirstKey() {
110		ConcurrentSkipListMap map = map5();
#	Line 112 | Line 112 | public class ConcurrentSkipListMapTest e
112		}
113
114		/**
115	<	*   lastKey returns last key
115	>	* lastKey returns last key
116		*/
117		public void testLastKey() {
118		ConcurrentSkipListMap map = map5();
119		assertEquals(five, map.lastKey());
120		}
121
122	–
122		/**
123	<	*  keySet.toArray returns contains all keys
123	>	* keySet.toArray returns contains all keys
124		*/
125		public void testKeySetToArray() {
126		ConcurrentSkipListMap map = map5();
#	Line 134 | Line 133 | public class ConcurrentSkipListMapTest e
133		}
134
135		/**
136	<	*  descendingkeySet.toArray returns contains all keys
136	>	* descendingkeySet.toArray returns contains all keys
137		*/
138		public void testDescendingKeySetToArray() {
139		ConcurrentSkipListMap map = map5();
#	Line 147 | Line 146 | public class ConcurrentSkipListMapTest e
146		}
147
148		/**
149	<	*   keySet returns a Set containing all the keys
149	>	* keySet returns a Set containing all the keys
150		*/
151		public void testKeySet() {
152		ConcurrentSkipListMap map = map5();
#	Line 161 | Line 160 | public class ConcurrentSkipListMapTest e
160		}
161
162		/**
163	<	*   keySet is ordered
163	>	* keySet is ordered
164		*/
165		public void testKeySetOrder() {
166		ConcurrentSkipListMap map = map5();
#	Line 199 | Line 198 | public class ConcurrentSkipListMapTest e
198		}
199
200		/**
201	<	*   descendingKeySet is ordered
201	>	* descendingKeySet is ordered
202		*/
203		public void testDescendingKeySetOrder() {
204		ConcurrentSkipListMap map = map5();
#	Line 218 | Line 217 | public class ConcurrentSkipListMapTest e
217		}
218
219		/**
220	<	*  descending iterator of descendingKeySet is ordered
220	>	* descending iterator of descendingKeySet is ordered
221		*/
222		public void testDescendingKeySetDescendingIteratorOrder() {
223		ConcurrentSkipListMap map = map5();
#	Line 237 | Line 236 | public class ConcurrentSkipListMapTest e
236		}
237
238		/**
239	<	*  Values.toArray contains all values
239	>	* Values.toArray contains all values
240		*/
241		public void testValuesToArray() {
242		ConcurrentSkipListMap map = map5();
#	Line 305 | Line 304 | public class ConcurrentSkipListMapTest e
304		}
305
306		/**
307	<	*  entrySet.toArray contains all entries
307	>	* entrySet.toArray contains all entries
308		*/
309		public void testEntrySetToArray() {
310		ConcurrentSkipListMap map = map5();
#	Line 319 | Line 318 | public class ConcurrentSkipListMapTest e
318		}
319
320		/**
321	<	*  descendingEntrySet.toArray contains all entries
321	>	* descendingEntrySet.toArray contains all entries
322		*/
323		public void testDescendingEntrySetToArray() {
324		ConcurrentSkipListMap map = map5();
#	Line 333 | Line 332 | public class ConcurrentSkipListMapTest e
332		}
333
334		/**
335	<	*   putAll  adds all key-value pairs from the given map
335	>	* putAll adds all key-value pairs from the given map
336		*/
337		public void testPutAll() {
338		ConcurrentSkipListMap empty = new ConcurrentSkipListMap();
#	Line 348 | Line 347 | public class ConcurrentSkipListMapTest e
347		}
348
349		/**
350	<	*   putIfAbsent works when the given key is not present
350	>	* putIfAbsent works when the given key is not present
351		*/
352		public void testPutIfAbsent() {
353		ConcurrentSkipListMap map = map5();
#	Line 357 | Line 356 | public class ConcurrentSkipListMapTest e
356		}
357
358		/**
359	<	*   putIfAbsent does not add the pair if the key is already present
359	>	* putIfAbsent does not add the pair if the key is already present
360		*/
361		public void testPutIfAbsent2() {
362		ConcurrentSkipListMap map = map5();
#	Line 365 | Line 364 | public class ConcurrentSkipListMapTest e
364		}
365
366		/**
367	<	*   replace fails when the given key is not present
367	>	* replace fails when the given key is not present
368		*/
369		public void testReplace() {
370		ConcurrentSkipListMap map = map5();
#	Line 374 | Line 373 | public class ConcurrentSkipListMapTest e
373		}
374
375		/**
376	<	*   replace succeeds if the key is already present
376	>	* replace succeeds if the key is already present
377		*/
378		public void testReplace2() {
379		ConcurrentSkipListMap map = map5();
#	Line 382 | Line 381 | public class ConcurrentSkipListMapTest e
381		assertEquals("Z", map.get(one));
382		}
383
385	–
384		/**
385		* replace value fails when the given key not mapped to expected value
386		*/
#	Line 403 | Line 401 | public class ConcurrentSkipListMapTest e
401		assertEquals("Z", map.get(one));
402		}
403
406	–
404		/**
405	<	*   remove removes the correct key-value pair from the map
405	>	* remove removes the correct key-value pair from the map
406		*/
407		public void testRemove() {
408		ConcurrentSkipListMap map = map5();
#	Line 427 | Line 424 | public class ConcurrentSkipListMapTest e
424		map.remove(four, "A");
425		assertEquals(4, map.size());
426		assertTrue(map.containsKey(four));
430	–
427		}
428
429		/**
#	Line 446 | Line 442 | public class ConcurrentSkipListMapTest e
442
443		Map.Entry e4 = map.lowerEntry(zero);
444		assertNull(e4);
449	–
445		}
446
447		/**
#	Line 465 | Line 460 | public class ConcurrentSkipListMapTest e
460
461		Map.Entry e4 = map.higherEntry(six);
462		assertNull(e4);
468	–
463		}
464
465		/**
#	Line 484 | Line 478 | public class ConcurrentSkipListMapTest e
478
479		Map.Entry e4 = map.floorEntry(zero);
480		assertNull(e4);
487	–
481		}
482
483		/**
#	Line 503 | Line 496 | public class ConcurrentSkipListMapTest e
496
497		Map.Entry e4 = map.ceilingEntry(six);
498		assertNull(e4);
506	–
499		}
500
501		/**
502		* lowerEntry, higherEntry, ceilingEntry, and floorEntry return
503	<	* imutable entries
503	>	* immutable entries
504		*/
505		public void testEntryImmutablity() {
506		ConcurrentSkipListMap map = map5();
#	Line 539 | Line 531 | public class ConcurrentSkipListMapTest e
531		}
532
533
542	–
534		/**
535		* lowerKey returns preceding element
536		*/
#	Line 556 | Line 547 | public class ConcurrentSkipListMapTest e
547
548		Object e4 = q.lowerKey(zero);
549		assertNull(e4);
559	–
550		}
551
552		/**
#	Line 575 | Line 565 | public class ConcurrentSkipListMapTest e
565
566		Object e4 = q.higherKey(six);
567		assertNull(e4);
578	–
568		}
569
570		/**
#	Line 594 | Line 583 | public class ConcurrentSkipListMapTest e
583
584		Object e4 = q.floorKey(zero);
585		assertNull(e4);
597	–
586		}
587
588		/**
#	Line 613 | Line 601 | public class ConcurrentSkipListMapTest e
601
602		Object e4 = q.ceilingKey(six);
603		assertNull(e4);
616	–
604		}
605
606		/**
#	Line 671 | Line 658 | public class ConcurrentSkipListMapTest e
658		}
659
660		/**
661	<	*   size returns the correct values
661	>	* size returns the correct values
662		*/
663		public void testSize() {
664		ConcurrentSkipListMap map = map5();
#	Line 687 | Line 674 | public class ConcurrentSkipListMapTest e
674		ConcurrentSkipListMap map = map5();
675		String s = map.toString();
676		for (int i = 1; i <= 5; ++i) {
677	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
677	>	assertTrue(s.contains(String.valueOf(i)));
678		}
679		}
680
#	Line 726 | Line 713 | public class ConcurrentSkipListMapTest e
713		} catch (NullPointerException success) {}
714		}
715
729	–
716		/**
717		* put(null,x) throws NPE
718		*/
#	Line 823 | Line 809 | public class ConcurrentSkipListMapTest e
809		assertTrue(r.equals(q));
810		}
811
826	–
827	–
812		/**
813		* subMap returns map with keys in requested range
814		*/
#	Line 989 | Line 973 | public class ConcurrentSkipListMapTest e
973		* Submaps of submaps subdivide correctly
974		*/
975		public void testRecursiveSubMaps() throws Exception {
976	<	int mapSize = 1000;
976	>	int mapSize = expensiveTests ? 1000 : 100;
977		Class cl = ConcurrentSkipListMap.class;
978		NavigableMap<Integer, Integer> map = newMap(cl);
979		bs = new BitSet(mapSize);
#	Line 1170 | Line 1154 | public class ConcurrentSkipListMapTest e
1154		*/
1155		void check(NavigableMap<Integer, Integer> map,
1156		final int min, final int max, final boolean ascending) {
1157	<	class ReferenceSet {
1157	>	class ReferenceSet {
1158		int lower(int key) {
1159		return ascending ? lowerAscending(key) : higherAscending(key);
1160		}
#	Line 1201 | Line 1185 | public class ConcurrentSkipListMapTest e
1185		// BitSet should support this! Test would run much faster
1186		while (key >= min) {
1187		if (bs.get(key))
1188	<	return(key);
1188	>	return key;
1189		key--;
1190		}
1191		return -1;

Diff Legend

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