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.11 by jsr166, Mon Nov 16 05:30:07 2009 UTC vs.
Revision 1.12 by jsr166, Sat Nov 21 02:07:26 2009 UTC

#	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);
17	>	return new TestSuite(ConcurrentSkipListMapTest.class);
18		}
19
20		/**
21		* Create a map from Integers 1-5 to Strings "A"-"E".
22		*/
23		private static ConcurrentSkipListMap map5() {
24	<	ConcurrentSkipListMap map = new ConcurrentSkipListMap();
24	>	ConcurrentSkipListMap map = new ConcurrentSkipListMap();
25		assertTrue(map.isEmpty());
26	<	map.put(one, "A");
27	<	map.put(five, "E");
28	<	map.put(three, "C");
29	<	map.put(two, "B");
30	<	map.put(four, "D");
26	>	map.put(one, "A");
27	>	map.put(five, "E");
28	>	map.put(three, "C");
29	>	map.put(two, "B");
30	>	map.put(four, "D");
31		assertFalse(map.isEmpty());
32		assertEquals(5, map.size());
33	<	return map;
33	>	return map;
34		}
35
36		/**
#	Line 38 | Line 38 | public class ConcurrentSkipListMapTest e
38		*/
39		public void testClear() {
40		ConcurrentSkipListMap map = map5();
41	<	map.clear();
42	<	assertEquals(map.size(), 0);
41	>	map.clear();
42	>	assertEquals(map.size(), 0);
43		}
44
45		/**
#	Line 59 | Line 59 | public class ConcurrentSkipListMapTest e
59		ConcurrentSkipListMap map2 = map5();
60		assertEquals(map1, map2);
61		assertEquals(map2, map1);
62	<	map1.clear();
62	>	map1.clear();
63		assertFalse(map1.equals(map2));
64		assertFalse(map2.equals(map1));
65		}
#	Line 69 | Line 69 | public class ConcurrentSkipListMapTest e
69		*/
70		public void testContainsKey() {
71		ConcurrentSkipListMap map = map5();
72	<	assertTrue(map.containsKey(one));
72	>	assertTrue(map.containsKey(one));
73		assertFalse(map.containsKey(zero));
74		}
75
#	Line 78 | Line 78 | public class ConcurrentSkipListMapTest e
78		*/
79		public void testContainsValue() {
80		ConcurrentSkipListMap map = map5();
81	<	assertTrue(map.containsValue("A"));
81	>	assertTrue(map.containsValue("A"));
82		assertFalse(map.containsValue("Z"));
83		}
84
#	Line 88 | Line 88 | public class ConcurrentSkipListMapTest e
88		*/
89		public void testGet() {
90		ConcurrentSkipListMap map = map5();
91	<	assertEquals("A", (String)map.get(one));
91	>	assertEquals("A", (String)map.get(one));
92		ConcurrentSkipListMap empty = new ConcurrentSkipListMap();
93		assertNull(empty.get(one));
94		}
#	Line 99 | Line 99 | public class ConcurrentSkipListMapTest e
99		public void testIsEmpty() {
100		ConcurrentSkipListMap empty = new ConcurrentSkipListMap();
101		ConcurrentSkipListMap map = map5();
102	<	assertTrue(empty.isEmpty());
102	>	assertTrue(empty.isEmpty());
103		assertFalse(map.isEmpty());
104		}
105
#	Line 108 | Line 108 | public class ConcurrentSkipListMapTest e
108		*/
109		public void testFirstKey() {
110		ConcurrentSkipListMap map = map5();
111	<	assertEquals(one, map.firstKey());
111	>	assertEquals(one, map.firstKey());
112		}
113
114		/**
#	Line 116 | Line 116 | public class ConcurrentSkipListMapTest e
116		*/
117		public void testLastKey() {
118		ConcurrentSkipListMap map = map5();
119	<	assertEquals(five, map.lastKey());
119	>	assertEquals(five, map.lastKey());
120		}
121
122
#	Line 125 | Line 125 | public class ConcurrentSkipListMapTest e
125		*/
126		public void testKeySetToArray() {
127		ConcurrentSkipListMap map = map5();
128	<	Set s = map.keySet();
128	>	Set s = map.keySet();
129		Object[] ar = s.toArray();
130		assertTrue(s.containsAll(Arrays.asList(ar)));
131	<	assertEquals(5, ar.length);
131	>	assertEquals(5, ar.length);
132		ar[0] = m10;
133		assertFalse(s.containsAll(Arrays.asList(ar)));
134		}
#	Line 138 | Line 138 | public class ConcurrentSkipListMapTest e
138		*/
139		public void testDescendingKeySetToArray() {
140		ConcurrentSkipListMap map = map5();
141	<	Set s = map.descendingKeySet();
141	>	Set s = map.descendingKeySet();
142		Object[] ar = s.toArray();
143	<	assertEquals(5, ar.length);
143	>	assertEquals(5, ar.length);
144		assertTrue(s.containsAll(Arrays.asList(ar)));
145		ar[0] = m10;
146		assertFalse(s.containsAll(Arrays.asList(ar)));
#	Line 151 | Line 151 | public class ConcurrentSkipListMapTest e
151		*/
152		public void testKeySet() {
153		ConcurrentSkipListMap map = map5();
154	<	Set s = map.keySet();
155	<	assertEquals(5, s.size());
156	<	assertTrue(s.contains(one));
157	<	assertTrue(s.contains(two));
158	<	assertTrue(s.contains(three));
159	<	assertTrue(s.contains(four));
160	<	assertTrue(s.contains(five));
154	>	Set s = map.keySet();
155	>	assertEquals(5, s.size());
156	>	assertTrue(s.contains(one));
157	>	assertTrue(s.contains(two));
158	>	assertTrue(s.contains(three));
159	>	assertTrue(s.contains(four));
160	>	assertTrue(s.contains(five));
161		}
162
163		/**
#	Line 165 | Line 165 | public class ConcurrentSkipListMapTest e
165		*/
166		public void testKeySetOrder() {
167		ConcurrentSkipListMap map = map5();
168	<	Set s = map.keySet();
168	>	Set s = map.keySet();
169		Iterator i = s.iterator();
170		Integer last = (Integer)i.next();
171		assertEquals(last, one);
#	Line 184 | Line 184 | public class ConcurrentSkipListMapTest e
184		*/
185		public void testKeySetDescendingIteratorOrder() {
186		ConcurrentSkipListMap map = map5();
187	<	NavigableSet s = map.navigableKeySet();
187	>	NavigableSet s = map.navigableKeySet();
188		Iterator i = s.descendingIterator();
189		Integer last = (Integer)i.next();
190		assertEquals(last, five);
#	Line 203 | Line 203 | public class ConcurrentSkipListMapTest e
203		*/
204		public void testDescendingKeySetOrder() {
205		ConcurrentSkipListMap map = map5();
206	<	Set s = map.descendingKeySet();
206	>	Set s = map.descendingKeySet();
207		Iterator i = s.iterator();
208		Integer last = (Integer)i.next();
209		assertEquals(last, five);
#	Line 222 | Line 222 | public class ConcurrentSkipListMapTest e
222		*/
223		public void testDescendingKeySetDescendingIteratorOrder() {
224		ConcurrentSkipListMap map = map5();
225	<	NavigableSet s = map.descendingKeySet();
225	>	NavigableSet s = map.descendingKeySet();
226		Iterator i = s.descendingIterator();
227		Integer last = (Integer)i.next();
228		assertEquals(last, one);
#	Line 241 | Line 241 | public class ConcurrentSkipListMapTest e
241		*/
242		public void testValuesToArray() {
243		ConcurrentSkipListMap map = map5();
244	<	Collection v = map.values();
244	>	Collection v = map.values();
245		Object[] ar = v.toArray();
246		ArrayList s = new ArrayList(Arrays.asList(ar));
247	<	assertEquals(5, ar.length);
248	<	assertTrue(s.contains("A"));
249	<	assertTrue(s.contains("B"));
250	<	assertTrue(s.contains("C"));
251	<	assertTrue(s.contains("D"));
252	<	assertTrue(s.contains("E"));
247	>	assertEquals(5, ar.length);
248	>	assertTrue(s.contains("A"));
249	>	assertTrue(s.contains("B"));
250	>	assertTrue(s.contains("C"));
251	>	assertTrue(s.contains("D"));
252	>	assertTrue(s.contains("E"));
253		}
254
255		/**
#	Line 257 | Line 257 | public class ConcurrentSkipListMapTest e
257		*/
258		public void testValues() {
259		ConcurrentSkipListMap map = map5();
260	<	Collection s = map.values();
261	<	assertEquals(5, s.size());
262	<	assertTrue(s.contains("A"));
263	<	assertTrue(s.contains("B"));
264	<	assertTrue(s.contains("C"));
265	<	assertTrue(s.contains("D"));
266	<	assertTrue(s.contains("E"));
260	>	Collection s = map.values();
261	>	assertEquals(5, s.size());
262	>	assertTrue(s.contains("A"));
263	>	assertTrue(s.contains("B"));
264	>	assertTrue(s.contains("C"));
265	>	assertTrue(s.contains("D"));
266	>	assertTrue(s.contains("E"));
267		}
268
269		/**
#	Line 271 | Line 271 | public class ConcurrentSkipListMapTest e
271		*/
272		public void testEntrySet() {
273		ConcurrentSkipListMap map = map5();
274	<	Set s = map.entrySet();
275	<	assertEquals(5, s.size());
274	>	Set s = map.entrySet();
275	>	assertEquals(5, s.size());
276		Iterator it = s.iterator();
277		while (it.hasNext()) {
278		Map.Entry e = (Map.Entry) it.next();
#	Line 290 | Line 290 | public class ConcurrentSkipListMapTest e
290		*/
291		public void testDescendingEntrySet() {
292		ConcurrentSkipListMap map = map5();
293	<	Set s = map.descendingMap().entrySet();
294	<	assertEquals(5, s.size());
293	>	Set s = map.descendingMap().entrySet();
294	>	assertEquals(5, s.size());
295		Iterator it = s.iterator();
296		while (it.hasNext()) {
297		Map.Entry e = (Map.Entry) it.next();
#	Line 309 | Line 309 | public class ConcurrentSkipListMapTest e
309		*/
310		public void testEntrySetToArray() {
311		ConcurrentSkipListMap map = map5();
312	<	Set s = map.entrySet();
312	>	Set s = map.entrySet();
313		Object[] ar = s.toArray();
314		assertEquals(5, ar.length);
315		for (int i = 0; i < 5; ++i) {
#	Line 323 | Line 323 | public class ConcurrentSkipListMapTest e
323		*/
324		public void testDescendingEntrySetToArray() {
325		ConcurrentSkipListMap map = map5();
326	<	Set s = map.descendingMap().entrySet();
326	>	Set s = map.descendingMap().entrySet();
327		Object[] ar = s.toArray();
328		assertEquals(5, ar.length);
329		for (int i = 0; i < 5; ++i) {
#	Line 338 | Line 338 | public class ConcurrentSkipListMapTest e
338		public void testPutAll() {
339		ConcurrentSkipListMap empty = new ConcurrentSkipListMap();
340		ConcurrentSkipListMap map = map5();
341	<	empty.putAll(map);
342	<	assertEquals(5, empty.size());
343	<	assertTrue(empty.containsKey(one));
344	<	assertTrue(empty.containsKey(two));
345	<	assertTrue(empty.containsKey(three));
346	<	assertTrue(empty.containsKey(four));
347	<	assertTrue(empty.containsKey(five));
341	>	empty.putAll(map);
342	>	assertEquals(5, empty.size());
343	>	assertTrue(empty.containsKey(one));
344	>	assertTrue(empty.containsKey(two));
345	>	assertTrue(empty.containsKey(three));
346	>	assertTrue(empty.containsKey(four));
347	>	assertTrue(empty.containsKey(five));
348		}
349
350		/**
#	Line 352 | Line 352 | public class ConcurrentSkipListMapTest e
352		*/
353		public void testPutIfAbsent() {
354		ConcurrentSkipListMap map = map5();
355	<	map.putIfAbsent(six, "Z");
355	>	map.putIfAbsent(six, "Z");
356		assertTrue(map.containsKey(six));
357		}
358
#	Line 369 | Line 369 | public class ConcurrentSkipListMapTest e
369		*/
370		public void testReplace() {
371		ConcurrentSkipListMap map = map5();
372	<	assertNull(map.replace(six, "Z"));
372	>	assertNull(map.replace(six, "Z"));
373		assertFalse(map.containsKey(six));
374		}
375
#	Line 389 | Line 389 | public class ConcurrentSkipListMapTest e
389		public void testReplaceValue() {
390		ConcurrentSkipListMap map = map5();
391		assertEquals("A", map.get(one));
392	<	assertFalse(map.replace(one, "Z", "Z"));
392	>	assertFalse(map.replace(one, "Z", "Z"));
393		assertEquals("A", map.get(one));
394		}
395
#	Line 399 | Line 399 | public class ConcurrentSkipListMapTest e
399		public void testReplaceValue2() {
400		ConcurrentSkipListMap map = map5();
401		assertEquals("A", map.get(one));
402	<	assertTrue(map.replace(one, "A", "Z"));
402	>	assertTrue(map.replace(one, "A", "Z"));
403		assertEquals("Z", map.get(one));
404		}
405
#	Line 409 | Line 409 | public class ConcurrentSkipListMapTest e
409		*/
410		public void testRemove() {
411		ConcurrentSkipListMap map = map5();
412	<	map.remove(five);
413	<	assertEquals(4, map.size());
414	<	assertFalse(map.containsKey(five));
412	>	map.remove(five);
413	>	assertEquals(4, map.size());
414	>	assertFalse(map.containsKey(five));
415		}
416
417		/**
#	Line 419 | Line 419 | public class ConcurrentSkipListMapTest e
419		*/
420		public void testRemove2() {
421		ConcurrentSkipListMap map = map5();
422	<	assertTrue(map.containsKey(five));
422	>	assertTrue(map.containsKey(five));
423		assertEquals("E", map.get(five));
424	<	map.remove(five, "E");
425	<	assertEquals(4, map.size());
426	<	assertFalse(map.containsKey(five));
427	<	map.remove(four, "A");
428	<	assertEquals(4, map.size());
429	<	assertTrue(map.containsKey(four));
424	>	map.remove(five, "E");
425	>	assertEquals(4, map.size());
426	>	assertFalse(map.containsKey(five));
427	>	map.remove(four, "A");
428	>	assertEquals(4, map.size());
429	>	assertTrue(map.containsKey(four));
430
431		}
432
#	Line 678 | Line 678 | public class ConcurrentSkipListMapTest e
678		public void testSize() {
679		ConcurrentSkipListMap map = map5();
680		ConcurrentSkipListMap empty = new ConcurrentSkipListMap();
681	<	assertEquals(0, empty.size());
682	<	assertEquals(5, map.size());
681	>	assertEquals(0, empty.size());
682	>	assertEquals(5, map.size());
683		}
684
685		/**
#	Line 1000 | Line 1000 | public class ConcurrentSkipListMapTest e
1000		* Submaps of submaps subdivide correctly
1001		*/
1002		public void testRecursiveSubMaps() {
1003	<	int mapSize = 1000;
1004	<	Class cl = ConcurrentSkipListMap.class;
1003	>	int mapSize = 1000;
1004	>	Class cl = ConcurrentSkipListMap.class;
1005		NavigableMap<Integer, Integer> map = newMap(cl);
1006		bs = new BitSet(mapSize);
1007
#	Line 1019 | Line 1019 | public class ConcurrentSkipListMapTest e
1019
1020		static NavigableMap<Integer, Integer> newMap(Class cl) {
1021		NavigableMap<Integer, Integer> result = null;
1022	<	try {
1022	>	try {
1023		result = (NavigableMap<Integer, Integer>) cl.newInstance();
1024	<	} catch (Exception e) {
1024	>	} catch (Exception e) {
1025		fail();
1026	<	}
1026	>	}
1027		assertEquals(result.size(), 0);
1028		assertFalse(result.keySet().iterator().hasNext());
1029		return result;

Diff Legend

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