ViewVC Help

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

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

Comparing jsr166/src/test/tck/ConcurrentSkipListSubMapTest.java (file contents):
Revision 1.1 by dl, Tue Dec 28 16:15:59 2004 UTC vs.
Revision 1.12 by jsr166, Tue Dec 1 06:03:49 2009 UTC

#	Line 11 | Line 11 | import java.io.*;
11
12		public class ConcurrentSkipListSubMapTest 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(ConcurrentSkipListSubMapTest.class);
17	>	return new TestSuite(ConcurrentSkipListSubMapTest.class);
18		}
19
20		/**
21		* Create a map from Integers 1-5 to Strings "A"-"E".
22		*/
23	<	private static ConcurrentNavigableMap map5() {
24	<	ConcurrentSkipListMap map = new ConcurrentSkipListMap();
23	>	private static ConcurrentNavigableMap map5() {
24	>	ConcurrentSkipListMap map = new ConcurrentSkipListMap();
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, seven);
35	>	return map.subMap(one, true, seven, false);
36	>	}
37	>
38	>	/**
39	>	* Create a map from Integers -5 to -1 to Strings "A"-"E".
40	>	*/
41	>	private static ConcurrentNavigableMap dmap5() {
42	>	ConcurrentSkipListMap map = new ConcurrentSkipListMap();
43	>	assertTrue(map.isEmpty());
44	>	map.put(m1, "A");
45	>	map.put(m5, "E");
46	>	map.put(m3, "C");
47	>	map.put(m2, "B");
48	>	map.put(m4, "D");
49	>	assertFalse(map.isEmpty());
50	>	assertEquals(5, map.size());
51	>	return map.descendingMap();
52	>	}
53	>
54	>	private static ConcurrentNavigableMap map0() {
55	>	ConcurrentSkipListMap map = new ConcurrentSkipListMap();
56	>	assertTrue(map.isEmpty());
57	>	return map.tailMap(one, true);
58		}
59
60	<	private static ConcurrentNavigableMap map0() {
61	<	ConcurrentSkipListMap map = new ConcurrentSkipListMap();
60	>	private static ConcurrentNavigableMap dmap0() {
61	>	ConcurrentSkipListMap map = new ConcurrentSkipListMap();
62		assertTrue(map.isEmpty());
63	<	return map.tailMap(one);
63	>	return map;
64		}
65
66		/**
#	Line 46 | Line 68 | public class ConcurrentSkipListSubMapTes
68		*/
69		public void testClear() {
70		ConcurrentNavigableMap map = map5();
71	<	map.clear();
72	<	assertEquals(map.size(), 0);
71	>	map.clear();
72	>	assertEquals(map.size(), 0);
73		}
74
75
#	Line 59 | Line 81 | public class ConcurrentSkipListSubMapTes
81		ConcurrentNavigableMap 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 69 | Line 91 | public class ConcurrentSkipListSubMapTes
91		*/
92		public void testContainsKey() {
93		ConcurrentNavigableMap map = map5();
94	<	assertTrue(map.containsKey(one));
94	>	assertTrue(map.containsKey(one));
95		assertFalse(map.containsKey(zero));
96		}
97
#	Line 78 | Line 100 | public class ConcurrentSkipListSubMapTes
100		*/
101		public void testContainsValue() {
102		ConcurrentNavigableMap map = map5();
103	<	assertTrue(map.containsValue("A"));
103	>	assertTrue(map.containsValue("A"));
104		assertFalse(map.containsValue("Z"));
105		}
106
#	Line 88 | Line 110 | public class ConcurrentSkipListSubMapTes
110		*/
111		public void testGet() {
112		ConcurrentNavigableMap map = map5();
113	<	assertEquals("A", (String)map.get(one));
113	>	assertEquals("A", (String)map.get(one));
114		ConcurrentNavigableMap empty = map0();
115		assertNull(empty.get(one));
116		}
#	Line 99 | Line 121 | public class ConcurrentSkipListSubMapTes
121		public void testIsEmpty() {
122		ConcurrentNavigableMap empty = map0();
123		ConcurrentNavigableMap map = map5();
124	<	assertTrue(empty.isEmpty());
124	>	assertTrue(empty.isEmpty());
125		assertFalse(map.isEmpty());
126		}
127
#	Line 108 | Line 130 | public class ConcurrentSkipListSubMapTes
130		*/
131		public void testFirstKey() {
132		ConcurrentNavigableMap map = map5();
133	<	assertEquals(one, map.firstKey());
133	>	assertEquals(one, map.firstKey());
134		}
135
136		/**
#	Line 116 | Line 138 | public class ConcurrentSkipListSubMapTes
138		*/
139		public void testLastKey() {
140		ConcurrentNavigableMap map = map5();
141	<	assertEquals(five, map.lastKey());
141	>	assertEquals(five, map.lastKey());
142		}
143
144
#	Line 125 | Line 147 | public class ConcurrentSkipListSubMapTes
147		*/
148		public void testKeySet() {
149		ConcurrentNavigableMap 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 139 | Line 161 | public class ConcurrentSkipListSubMapTes
161		*/
162		public void testKeySetOrder() {
163		ConcurrentNavigableMap 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 155 | Line 177 | public class ConcurrentSkipListSubMapTes
177		*/
178		public void testValues() {
179		ConcurrentNavigableMap 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		/**
190	+	*  keySet.toArray returns contains all keys
191	+	*/
192	+	public void testKeySetToArray() {
193	+	ConcurrentNavigableMap map = map5();
194	+	Set s = map.keySet();
195	+	Object[] ar = s.toArray();
196	+	assertTrue(s.containsAll(Arrays.asList(ar)));
197	+	assertEquals(5, ar.length);
198	+	ar[0] = m10;
199	+	assertFalse(s.containsAll(Arrays.asList(ar)));
200	+	}
201	+
202	+	/**
203	+	*  descendingkeySet.toArray returns contains all keys
204	+	*/
205	+	public void testDescendingKeySetToArray() {
206	+	ConcurrentNavigableMap map = map5();
207	+	Set s = map.descendingKeySet();
208	+	Object[] ar = s.toArray();
209	+	assertEquals(5, ar.length);
210	+	assertTrue(s.containsAll(Arrays.asList(ar)));
211	+	ar[0] = m10;
212	+	assertFalse(s.containsAll(Arrays.asList(ar)));
213	+	}
214	+
215	+	/**
216	+	*  Values.toArray contains all values
217	+	*/
218	+	public void testValuesToArray() {
219	+	ConcurrentNavigableMap map = map5();
220	+	Collection v = map.values();
221	+	Object[] ar = v.toArray();
222	+	ArrayList s = new ArrayList(Arrays.asList(ar));
223	+	assertEquals(5, ar.length);
224	+	assertTrue(s.contains("A"));
225	+	assertTrue(s.contains("B"));
226	+	assertTrue(s.contains("C"));
227	+	assertTrue(s.contains("D"));
228	+	assertTrue(s.contains("E"));
229	+	}
230	+
231	+
232	+	/**
233		* entrySet contains all pairs
234		*/
235		public void testEntrySet() {
236		ConcurrentNavigableMap map = map5();
237	<	Set s = map.entrySet();
238	<	assertEquals(5, s.size());
237	>	Set s = map.entrySet();
238	>	assertEquals(5, s.size());
239		Iterator it = s.iterator();
240		while (it.hasNext()) {
241		Map.Entry e = (Map.Entry) it.next();
242	<	assertTrue(
242	>	assertTrue(
243		(e.getKey().equals(one) && e.getValue().equals("A")) ||
244		(e.getKey().equals(two) && e.getValue().equals("B")) ||
245		(e.getKey().equals(three) && e.getValue().equals("C")) ||
#	Line 189 | Line 254 | public class ConcurrentSkipListSubMapTes
254		public void testPutAll() {
255		ConcurrentNavigableMap empty = map0();
256		ConcurrentNavigableMap map = map5();
257	<	empty.putAll(map);
258	<	assertEquals(5, empty.size());
259	<	assertTrue(empty.containsKey(one));
260	<	assertTrue(empty.containsKey(two));
261	<	assertTrue(empty.containsKey(three));
262	<	assertTrue(empty.containsKey(four));
263	<	assertTrue(empty.containsKey(five));
257	>	empty.putAll(map);
258	>	assertEquals(5, empty.size());
259	>	assertTrue(empty.containsKey(one));
260	>	assertTrue(empty.containsKey(two));
261	>	assertTrue(empty.containsKey(three));
262	>	assertTrue(empty.containsKey(four));
263	>	assertTrue(empty.containsKey(five));
264		}
265
266		/**
#	Line 203 | Line 268 | public class ConcurrentSkipListSubMapTes
268		*/
269		public void testPutIfAbsent() {
270		ConcurrentNavigableMap map = map5();
271	<	map.putIfAbsent(six, "Z");
271	>	map.putIfAbsent(six, "Z");
272		assertTrue(map.containsKey(six));
273		}
274
#	Line 220 | Line 285 | public class ConcurrentSkipListSubMapTes
285		*/
286		public void testReplace() {
287		ConcurrentNavigableMap map = map5();
288	<	assertNull(map.replace(six, "Z"));
288	>	assertNull(map.replace(six, "Z"));
289		assertFalse(map.containsKey(six));
290		}
291
#	Line 240 | Line 305 | public class ConcurrentSkipListSubMapTes
305		public void testReplaceValue() {
306		ConcurrentNavigableMap map = map5();
307		assertEquals("A", map.get(one));
308	<	assertFalse(map.replace(one, "Z", "Z"));
308	>	assertFalse(map.replace(one, "Z", "Z"));
309		assertEquals("A", map.get(one));
310		}
311
#	Line 250 | Line 315 | public class ConcurrentSkipListSubMapTes
315		public void testReplaceValue2() {
316		ConcurrentNavigableMap map = map5();
317		assertEquals("A", map.get(one));
318	<	assertTrue(map.replace(one, "A", "Z"));
318	>	assertTrue(map.replace(one, "A", "Z"));
319		assertEquals("Z", map.get(one));
320		}
321
#	Line 260 | Line 325 | public class ConcurrentSkipListSubMapTes
325		*/
326		public void testRemove() {
327		ConcurrentNavigableMap map = map5();
328	<	map.remove(five);
329	<	assertEquals(4, map.size());
330	<	assertFalse(map.containsKey(five));
328	>	map.remove(five);
329	>	assertEquals(4, map.size());
330	>	assertFalse(map.containsKey(five));
331		}
332
333		/**
#	Line 270 | Line 335 | public class ConcurrentSkipListSubMapTes
335		*/
336		public void testRemove2() {
337		ConcurrentNavigableMap map = map5();
338	<	assertTrue(map.containsKey(five));
338	>	assertTrue(map.containsKey(five));
339		assertEquals("E", map.get(five));
340	<	map.remove(five, "E");
341	<	assertEquals(4, map.size());
342	<	assertFalse(map.containsKey(five));
343	<	map.remove(four, "A");
344	<	assertEquals(4, map.size());
345	<	assertTrue(map.containsKey(four));
340	>	map.remove(five, "E");
341	>	assertEquals(4, map.size());
342	>	assertFalse(map.containsKey(five));
343	>	map.remove(four, "A");
344	>	assertEquals(4, map.size());
345	>	assertTrue(map.containsKey(four));
346
347		}
348
#	Line 379 | Line 444 | public class ConcurrentSkipListSubMapTes
444		try {
445		e.setValue("A");
446		shouldThrow();
447	<	} catch (Exception ok) {
383	<	}
447	>	} catch (UnsupportedOperationException success) {}
448		e = map.pollFirstEntry();
449		assertNull(e);
450		}
#	Line 407 | Line 471 | public class ConcurrentSkipListSubMapTes
471		try {
472		e.setValue("E");
473		shouldThrow();
474	<	} catch (Exception ok) {
411	<	}
474	>	} catch (UnsupportedOperationException success) {}
475		e = map.pollLastEntry();
476		assertNull(e);
477		}
#	Line 419 | Line 482 | public class ConcurrentSkipListSubMapTes
482		public void testSize() {
483		ConcurrentNavigableMap map = map5();
484		ConcurrentNavigableMap empty = map0();
485	<	assertEquals(0, empty.size());
486	<	assertEquals(5, map.size());
485	>	assertEquals(0, empty.size());
486	>	assertEquals(5, map.size());
487		}
488
489		/**
#	Line 432 | Line 495 | public class ConcurrentSkipListSubMapTes
495		for (int i = 1; i <= 5; ++i) {
496		assertTrue(s.indexOf(String.valueOf(i)) >= 0);
497		}
498	<	}
498	>	}
499
500		// Exception tests
501
#	Line 444 | Line 507 | public class ConcurrentSkipListSubMapTes
507		ConcurrentNavigableMap c = map5();
508		c.get(null);
509		shouldThrow();
510	<	} catch(NullPointerException e){}
510	>	} catch (NullPointerException success) {}
511		}
512
513		/**
#	Line 455 | Line 518 | public class ConcurrentSkipListSubMapTes
518		ConcurrentNavigableMap c = map5();
519		c.containsKey(null);
520		shouldThrow();
521	<	} catch(NullPointerException e){}
521	>	} catch (NullPointerException success) {}
522		}
523
524		/**
#	Line 466 | Line 529 | public class ConcurrentSkipListSubMapTes
529		ConcurrentNavigableMap c = map0();
530		c.containsValue(null);
531		shouldThrow();
532	<	} catch(NullPointerException e){}
532	>	} catch (NullPointerException success) {}
533		}
534
535
#	Line 478 | Line 541 | public class ConcurrentSkipListSubMapTes
541		ConcurrentNavigableMap c = map5();
542		c.put(null, "whatever");
543		shouldThrow();
544	<	} catch(NullPointerException e){}
544	>	} catch (NullPointerException success) {}
545		}
546
547		/**
#	Line 489 | Line 552 | public class ConcurrentSkipListSubMapTes
552		ConcurrentNavigableMap c = map5();
553		c.putIfAbsent(null, "whatever");
554		shouldThrow();
555	<	} catch(NullPointerException e){}
555	>	} catch (NullPointerException success) {}
556		}
557
558		/**
#	Line 500 | Line 563 | public class ConcurrentSkipListSubMapTes
563		ConcurrentNavigableMap c = map5();
564		c.replace(null, "whatever");
565		shouldThrow();
566	<	} catch(NullPointerException e){}
566	>	} catch (NullPointerException success) {}
567		}
568
569		/**
#	Line 511 | Line 574 | public class ConcurrentSkipListSubMapTes
574		ConcurrentNavigableMap c = map5();
575		c.replace(null, one, "whatever");
576		shouldThrow();
577	<	} catch(NullPointerException e){}
577	>	} catch (NullPointerException success) {}
578		}
579
580		/**
#	Line 522 | Line 585 | public class ConcurrentSkipListSubMapTes
585		ConcurrentNavigableMap c = map5();
586		c.remove(null);
587		shouldThrow();
588	<	} catch(NullPointerException e){}
588	>	} catch (NullPointerException success) {}
589		}
590
591		/**
#	Line 533 | Line 596 | public class ConcurrentSkipListSubMapTes
596		ConcurrentNavigableMap c = map5();
597		c.remove(null, "whatever");
598		shouldThrow();
599	<	} catch(NullPointerException e){}
599	>	} catch (NullPointerException success) {}
600		}
601
602		/**
603		* A deserialized map equals original
604		*/
605	<	public void testSerialization() {
605	>	public void testSerialization() throws Exception {
606		ConcurrentNavigableMap q = map5();
607
608	<	try {
609	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
610	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
611	<	out.writeObject(q);
612	<	out.close();
613	<
614	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
615	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
616	<	ConcurrentNavigableMap r = (ConcurrentNavigableMap)in.readObject();
617	<	assertEquals(q.size(), r.size());
618	<	assertTrue(q.equals(r));
556	<	assertTrue(r.equals(q));
557	<	} catch(Exception e){
558	<	e.printStackTrace();
559	<	unexpectedException();
560	<	}
608	>	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
609	>	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
610	>	out.writeObject(q);
611	>	out.close();
612	>
613	>	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
614	>	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
615	>	ConcurrentNavigableMap r = (ConcurrentNavigableMap)in.readObject();
616	>	assertEquals(q.size(), r.size());
617	>	assertTrue(q.equals(r));
618	>	assertTrue(r.equals(q));
619		}
620
621
#	Line 591 | Line 649 | public class ConcurrentSkipListSubMapTes
649		assertEquals(1, sm.size());
650		assertEquals(three, sm.firstKey());
651		assertEquals(three, sm.lastKey());
652	<	assertTrue(sm.remove(three) != null);
652	>	assertEquals("C", sm.remove(three));
653		assertTrue(sm.isEmpty());
654		assertEquals(3, map.size());
655		}
#	Line 619 | Line 677 | public class ConcurrentSkipListSubMapTes
677		assertEquals(4, map.size());
678		assertEquals(0, sm.size());
679		assertTrue(sm.isEmpty());
680	<	assertTrue(sm.remove(three) == null);
680	>	assertSame(sm.remove(three), null);
681		assertEquals(4, map.size());
682		}
683
#	Line 691 | Line 749 | public class ConcurrentSkipListSubMapTes
749		SortedMap ssm = sm.tailMap(four);
750		assertEquals(four, ssm.firstKey());
751		assertEquals(five, ssm.lastKey());
752	<	assertTrue(ssm.remove(four) != null);
752	>	assertEquals("D", ssm.remove(four));
753		assertEquals(1, ssm.size());
754		assertEquals(3, sm.size());
755		assertEquals(4, map.size());
756		}
757	<
757	>
758	>	/**
759	>	*  clear removes all pairs
760	>	*/
761	>	public void testDescendingClear() {
762	>	ConcurrentNavigableMap map = dmap5();
763	>	map.clear();
764	>	assertEquals(map.size(), 0);
765	>	}
766	>
767	>
768	>	/**
769	>	*  Maps with same contents are equal
770	>	*/
771	>	public void testDescendingEquals() {
772	>	ConcurrentNavigableMap map1 = dmap5();
773	>	ConcurrentNavigableMap map2 = dmap5();
774	>	assertEquals(map1, map2);
775	>	assertEquals(map2, map1);
776	>	map1.clear();
777	>	assertFalse(map1.equals(map2));
778	>	assertFalse(map2.equals(map1));
779	>	}
780	>
781	>	/**
782	>	*  containsKey returns true for contained key
783	>	*/
784	>	public void testDescendingContainsKey() {
785	>	ConcurrentNavigableMap map = dmap5();
786	>	assertTrue(map.containsKey(m1));
787	>	assertFalse(map.containsKey(zero));
788	>	}
789	>
790	>	/**
791	>	*  containsValue returns true for held values
792	>	*/
793	>	public void testDescendingContainsValue() {
794	>	ConcurrentNavigableMap map = dmap5();
795	>	assertTrue(map.containsValue("A"));
796	>	assertFalse(map.containsValue("Z"));
797	>	}
798	>
799	>	/**
800	>	*  get returns the correct element at the given key,
801	>	*  or null if not present
802	>	*/
803	>	public void testDescendingGet() {
804	>	ConcurrentNavigableMap map = dmap5();
805	>	assertEquals("A", (String)map.get(m1));
806	>	ConcurrentNavigableMap empty = dmap0();
807	>	assertNull(empty.get(m1));
808	>	}
809	>
810	>	/**
811	>	*  isEmpty is true of empty map and false for non-empty
812	>	*/
813	>	public void testDescendingIsEmpty() {
814	>	ConcurrentNavigableMap empty = dmap0();
815	>	ConcurrentNavigableMap map = dmap5();
816	>	assertTrue(empty.isEmpty());
817	>	assertFalse(map.isEmpty());
818	>	}
819	>
820	>	/**
821	>	*   firstKey returns first key
822	>	*/
823	>	public void testDescendingFirstKey() {
824	>	ConcurrentNavigableMap map = dmap5();
825	>	assertEquals(m1, map.firstKey());
826	>	}
827	>
828	>	/**
829	>	*   lastKey returns last key
830	>	*/
831	>	public void testDescendingLastKey() {
832	>	ConcurrentNavigableMap map = dmap5();
833	>	assertEquals(m5, map.lastKey());
834	>	}
835	>
836	>
837	>	/**
838	>	*   keySet returns a Set containing all the keys
839	>	*/
840	>	public void testDescendingKeySet() {
841	>	ConcurrentNavigableMap map = dmap5();
842	>	Set s = map.keySet();
843	>	assertEquals(5, s.size());
844	>	assertTrue(s.contains(m1));
845	>	assertTrue(s.contains(m2));
846	>	assertTrue(s.contains(m3));
847	>	assertTrue(s.contains(m4));
848	>	assertTrue(s.contains(m5));
849	>	}
850	>
851	>	/**
852	>	*   keySet is ordered
853	>	*/
854	>	public void testDescendingKeySetOrder() {
855	>	ConcurrentNavigableMap map = dmap5();
856	>	Set s = map.keySet();
857	>	Iterator i = s.iterator();
858	>	Integer last = (Integer)i.next();
859	>	assertEquals(last, m1);
860	>	while (i.hasNext()) {
861	>	Integer k = (Integer)i.next();
862	>	assertTrue(last.compareTo(k) > 0);
863	>	last = k;
864	>	}
865	>	}
866	>
867	>	/**
868	>	* values collection contains all values
869	>	*/
870	>	public void testDescendingValues() {
871	>	ConcurrentNavigableMap map = dmap5();
872	>	Collection s = map.values();
873	>	assertEquals(5, s.size());
874	>	assertTrue(s.contains("A"));
875	>	assertTrue(s.contains("B"));
876	>	assertTrue(s.contains("C"));
877	>	assertTrue(s.contains("D"));
878	>	assertTrue(s.contains("E"));
879	>	}
880	>
881	>	/**
882	>	*  keySet.toArray returns contains all keys
883	>	*/
884	>	public void testDescendingAscendingKeySetToArray() {
885	>	ConcurrentNavigableMap map = dmap5();
886	>	Set s = map.keySet();
887	>	Object[] ar = s.toArray();
888	>	assertTrue(s.containsAll(Arrays.asList(ar)));
889	>	assertEquals(5, ar.length);
890	>	ar[0] = m10;
891	>	assertFalse(s.containsAll(Arrays.asList(ar)));
892	>	}
893	>
894	>	/**
895	>	*  descendingkeySet.toArray returns contains all keys
896	>	*/
897	>	public void testDescendingDescendingKeySetToArray() {
898	>	ConcurrentNavigableMap map = dmap5();
899	>	Set s = map.descendingKeySet();
900	>	Object[] ar = s.toArray();
901	>	assertEquals(5, ar.length);
902	>	assertTrue(s.containsAll(Arrays.asList(ar)));
903	>	ar[0] = m10;
904	>	assertFalse(s.containsAll(Arrays.asList(ar)));
905	>	}
906	>
907	>	/**
908	>	*  Values.toArray contains all values
909	>	*/
910	>	public void testDescendingValuesToArray() {
911	>	ConcurrentNavigableMap map = dmap5();
912	>	Collection v = map.values();
913	>	Object[] ar = v.toArray();
914	>	ArrayList s = new ArrayList(Arrays.asList(ar));
915	>	assertEquals(5, ar.length);
916	>	assertTrue(s.contains("A"));
917	>	assertTrue(s.contains("B"));
918	>	assertTrue(s.contains("C"));
919	>	assertTrue(s.contains("D"));
920	>	assertTrue(s.contains("E"));
921	>	}
922	>
923	>
924	>	/**
925	>	* entrySet contains all pairs
926	>	*/
927	>	public void testDescendingEntrySet() {
928	>	ConcurrentNavigableMap map = dmap5();
929	>	Set s = map.entrySet();
930	>	assertEquals(5, s.size());
931	>	Iterator it = s.iterator();
932	>	while (it.hasNext()) {
933	>	Map.Entry e = (Map.Entry) it.next();
934	>	assertTrue(
935	>	(e.getKey().equals(m1) && e.getValue().equals("A")) ||
936	>	(e.getKey().equals(m2) && e.getValue().equals("B")) ||
937	>	(e.getKey().equals(m3) && e.getValue().equals("C")) ||
938	>	(e.getKey().equals(m4) && e.getValue().equals("D")) ||
939	>	(e.getKey().equals(m5) && e.getValue().equals("E")));
940	>	}
941	>	}
942	>
943	>	/**
944	>	*   putAll  adds all key-value pairs from the given map
945	>	*/
946	>	public void testDescendingPutAll() {
947	>	ConcurrentNavigableMap empty = dmap0();
948	>	ConcurrentNavigableMap map = dmap5();
949	>	empty.putAll(map);
950	>	assertEquals(5, empty.size());
951	>	assertTrue(empty.containsKey(m1));
952	>	assertTrue(empty.containsKey(m2));
953	>	assertTrue(empty.containsKey(m3));
954	>	assertTrue(empty.containsKey(m4));
955	>	assertTrue(empty.containsKey(m5));
956	>	}
957	>
958	>	/**
959	>	*   putIfAbsent works when the given key is not present
960	>	*/
961	>	public void testDescendingPutIfAbsent() {
962	>	ConcurrentNavigableMap map = dmap5();
963	>	map.putIfAbsent(six, "Z");
964	>	assertTrue(map.containsKey(six));
965	>	}
966	>
967	>	/**
968	>	*   putIfAbsent does not add the pair if the key is already present
969	>	*/
970	>	public void testDescendingPutIfAbsent2() {
971	>	ConcurrentNavigableMap map = dmap5();
972	>	assertEquals("A", map.putIfAbsent(m1, "Z"));
973	>	}
974	>
975	>	/**
976	>	*   replace fails when the given key is not present
977	>	*/
978	>	public void testDescendingReplace() {
979	>	ConcurrentNavigableMap map = dmap5();
980	>	assertNull(map.replace(six, "Z"));
981	>	assertFalse(map.containsKey(six));
982	>	}
983	>
984	>	/**
985	>	*   replace succeeds if the key is already present
986	>	*/
987	>	public void testDescendingReplace2() {
988	>	ConcurrentNavigableMap map = dmap5();
989	>	assertNotNull(map.replace(m1, "Z"));
990	>	assertEquals("Z", map.get(m1));
991	>	}
992	>
993	>
994	>	/**
995	>	* replace value fails when the given key not mapped to expected value
996	>	*/
997	>	public void testDescendingReplaceValue() {
998	>	ConcurrentNavigableMap map = dmap5();
999	>	assertEquals("A", map.get(m1));
1000	>	assertFalse(map.replace(m1, "Z", "Z"));
1001	>	assertEquals("A", map.get(m1));
1002	>	}
1003	>
1004	>	/**
1005	>	* replace value succeeds when the given key mapped to expected value
1006	>	*/
1007	>	public void testDescendingReplaceValue2() {
1008	>	ConcurrentNavigableMap map = dmap5();
1009	>	assertEquals("A", map.get(m1));
1010	>	assertTrue(map.replace(m1, "A", "Z"));
1011	>	assertEquals("Z", map.get(m1));
1012	>	}
1013	>
1014	>
1015	>	/**
1016	>	*   remove removes the correct key-value pair from the map
1017	>	*/
1018	>	public void testDescendingRemove() {
1019	>	ConcurrentNavigableMap map = dmap5();
1020	>	map.remove(m5);
1021	>	assertEquals(4, map.size());
1022	>	assertFalse(map.containsKey(m5));
1023	>	}
1024	>
1025	>	/**
1026	>	* remove(key,value) removes only if pair present
1027	>	*/
1028	>	public void testDescendingRemove2() {
1029	>	ConcurrentNavigableMap map = dmap5();
1030	>	assertTrue(map.containsKey(m5));
1031	>	assertEquals("E", map.get(m5));
1032	>	map.remove(m5, "E");
1033	>	assertEquals(4, map.size());
1034	>	assertFalse(map.containsKey(m5));
1035	>	map.remove(m4, "A");
1036	>	assertEquals(4, map.size());
1037	>	assertTrue(map.containsKey(m4));
1038	>
1039	>	}
1040	>
1041	>	/**
1042	>	* lowerEntry returns preceding entry.
1043	>	*/
1044	>	public void testDescendingLowerEntry() {
1045	>	ConcurrentNavigableMap map = dmap5();
1046	>	Map.Entry e1 = map.lowerEntry(m3);
1047	>	assertEquals(m2, e1.getKey());
1048	>
1049	>	Map.Entry e2 = map.lowerEntry(m6);
1050	>	assertEquals(m5, e2.getKey());
1051	>
1052	>	Map.Entry e3 = map.lowerEntry(m1);
1053	>	assertNull(e3);
1054	>
1055	>	Map.Entry e4 = map.lowerEntry(zero);
1056	>	assertNull(e4);
1057	>
1058	>	}
1059	>
1060	>	/**
1061	>	* higherEntry returns next entry.
1062	>	*/
1063	>	public void testDescendingHigherEntry() {
1064	>	ConcurrentNavigableMap map = dmap5();
1065	>	Map.Entry e1 = map.higherEntry(m3);
1066	>	assertEquals(m4, e1.getKey());
1067	>
1068	>	Map.Entry e2 = map.higherEntry(zero);
1069	>	assertEquals(m1, e2.getKey());
1070	>
1071	>	Map.Entry e3 = map.higherEntry(m5);
1072	>	assertNull(e3);
1073	>
1074	>	Map.Entry e4 = map.higherEntry(m6);
1075	>	assertNull(e4);
1076	>
1077	>	}
1078	>
1079	>	/**
1080	>	* floorEntry returns preceding entry.
1081	>	*/
1082	>	public void testDescendingFloorEntry() {
1083	>	ConcurrentNavigableMap map = dmap5();
1084	>	Map.Entry e1 = map.floorEntry(m3);
1085	>	assertEquals(m3, e1.getKey());
1086	>
1087	>	Map.Entry e2 = map.floorEntry(m6);
1088	>	assertEquals(m5, e2.getKey());
1089	>
1090	>	Map.Entry e3 = map.floorEntry(m1);
1091	>	assertEquals(m1, e3.getKey());
1092	>
1093	>	Map.Entry e4 = map.floorEntry(zero);
1094	>	assertNull(e4);
1095	>
1096	>	}
1097	>
1098	>	/**
1099	>	* ceilingEntry returns next entry.
1100	>	*/
1101	>	public void testDescendingCeilingEntry() {
1102	>	ConcurrentNavigableMap map = dmap5();
1103	>	Map.Entry e1 = map.ceilingEntry(m3);
1104	>	assertEquals(m3, e1.getKey());
1105	>
1106	>	Map.Entry e2 = map.ceilingEntry(zero);
1107	>	assertEquals(m1, e2.getKey());
1108	>
1109	>	Map.Entry e3 = map.ceilingEntry(m5);
1110	>	assertEquals(m5, e3.getKey());
1111	>
1112	>	Map.Entry e4 = map.ceilingEntry(m6);
1113	>	assertNull(e4);
1114	>
1115	>	}
1116	>
1117	>	/**
1118	>	* pollFirstEntry returns entries in order
1119	>	*/
1120	>	public void testDescendingPollFirstEntry() {
1121	>	ConcurrentNavigableMap map = dmap5();
1122	>	Map.Entry e = map.pollFirstEntry();
1123	>	assertEquals(m1, e.getKey());
1124	>	assertEquals("A", e.getValue());
1125	>	e = map.pollFirstEntry();
1126	>	assertEquals(m2, e.getKey());
1127	>	map.put(m1, "A");
1128	>	e = map.pollFirstEntry();
1129	>	assertEquals(m1, e.getKey());
1130	>	assertEquals("A", e.getValue());
1131	>	e = map.pollFirstEntry();
1132	>	assertEquals(m3, e.getKey());
1133	>	map.remove(m4);
1134	>	e = map.pollFirstEntry();
1135	>	assertEquals(m5, e.getKey());
1136	>	try {
1137	>	e.setValue("A");
1138	>	shouldThrow();
1139	>	} catch (UnsupportedOperationException success) {}
1140	>	e = map.pollFirstEntry();
1141	>	assertNull(e);
1142	>	}
1143	>
1144	>	/**
1145	>	* pollLastEntry returns entries in order
1146	>	*/
1147	>	public void testDescendingPollLastEntry() {
1148	>	ConcurrentNavigableMap map = dmap5();
1149	>	Map.Entry e = map.pollLastEntry();
1150	>	assertEquals(m5, e.getKey());
1151	>	assertEquals("E", e.getValue());
1152	>	e = map.pollLastEntry();
1153	>	assertEquals(m4, e.getKey());
1154	>	map.put(m5, "E");
1155	>	e = map.pollLastEntry();
1156	>	assertEquals(m5, e.getKey());
1157	>	assertEquals("E", e.getValue());
1158	>	e = map.pollLastEntry();
1159	>	assertEquals(m3, e.getKey());
1160	>	map.remove(m2);
1161	>	e = map.pollLastEntry();
1162	>	assertEquals(m1, e.getKey());
1163	>	try {
1164	>	e.setValue("E");
1165	>	shouldThrow();
1166	>	} catch (UnsupportedOperationException success) {}
1167	>	e = map.pollLastEntry();
1168	>	assertNull(e);
1169	>	}
1170	>
1171	>	/**
1172	>	*   size returns the correct values
1173	>	*/
1174	>	public void testDescendingSize() {
1175	>	ConcurrentNavigableMap map = dmap5();
1176	>	ConcurrentNavigableMap empty = dmap0();
1177	>	assertEquals(0, empty.size());
1178	>	assertEquals(5, map.size());
1179	>	}
1180	>
1181	>	/**
1182	>	* toString contains toString of elements
1183	>	*/
1184	>	public void testDescendingToString() {
1185	>	ConcurrentNavigableMap map = dmap5();
1186	>	String s = map.toString();
1187	>	for (int i = 1; i <= 5; ++i) {
1188	>	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
1189	>	}
1190	>	}
1191	>
1192	>	// Exception testDescendings
1193	>
1194	>	/**
1195	>	* get(null) of nm1mpty map throws NPE
1196	>	*/
1197	>	public void testDescendingGet_NullPointerException() {
1198	>	try {
1199	>	ConcurrentNavigableMap c = dmap5();
1200	>	c.get(null);
1201	>	shouldThrow();
1202	>	} catch (NullPointerException success) {}
1203	>	}
1204	>
1205	>	/**
1206	>	* containsKey(null) of nm1mpty map throws NPE
1207	>	*/
1208	>	public void testDescendingContainsKey_NullPointerException() {
1209	>	try {
1210	>	ConcurrentNavigableMap c = dmap5();
1211	>	c.containsKey(null);
1212	>	shouldThrow();
1213	>	} catch (NullPointerException success) {}
1214	>	}
1215	>
1216	>	/**
1217	>	* containsValue(null) throws NPE
1218	>	*/
1219	>	public void testDescendingContainsValue_NullPointerException() {
1220	>	try {
1221	>	ConcurrentNavigableMap c = dmap0();
1222	>	c.containsValue(null);
1223	>	shouldThrow();
1224	>	} catch (NullPointerException success) {}
1225	>	}
1226	>
1227	>
1228	>	/**
1229	>	* put(null,x) throws NPE
1230	>	*/
1231	>	public void testDescendingPut1_NullPointerException() {
1232	>	try {
1233	>	ConcurrentNavigableMap c = dmap5();
1234	>	c.put(null, "whatever");
1235	>	shouldThrow();
1236	>	} catch (NullPointerException success) {}
1237	>	}
1238	>
1239	>	/**
1240	>	* putIfAbsent(null, x) throws NPE
1241	>	*/
1242	>	public void testDescendingPutIfAbsent1_NullPointerException() {
1243	>	try {
1244	>	ConcurrentNavigableMap c = dmap5();
1245	>	c.putIfAbsent(null, "whatever");
1246	>	shouldThrow();
1247	>	} catch (NullPointerException success) {}
1248	>	}
1249	>
1250	>	/**
1251	>	* replace(null, x) throws NPE
1252	>	*/
1253	>	public void testDescendingReplace_NullPointerException() {
1254	>	try {
1255	>	ConcurrentNavigableMap c = dmap5();
1256	>	c.replace(null, "whatever");
1257	>	shouldThrow();
1258	>	} catch (NullPointerException success) {}
1259	>	}
1260	>
1261	>	/**
1262	>	* replace(null, x, y) throws NPE
1263	>	*/
1264	>	public void testDescendingReplaceValue_NullPointerException() {
1265	>	try {
1266	>	ConcurrentNavigableMap c = dmap5();
1267	>	c.replace(null, m1, "whatever");
1268	>	shouldThrow();
1269	>	} catch (NullPointerException success) {}
1270	>	}
1271	>
1272	>	/**
1273	>	* remove(null) throws NPE
1274	>	*/
1275	>	public void testDescendingRemove1_NullPointerException() {
1276	>	try {
1277	>	ConcurrentNavigableMap c = dmap5();
1278	>	c.remove(null);
1279	>	shouldThrow();
1280	>	} catch (NullPointerException success) {}
1281	>	}
1282	>
1283	>	/**
1284	>	* remove(null, x) throws NPE
1285	>	*/
1286	>	public void testDescendingRemove2_NullPointerException() {
1287	>	try {
1288	>	ConcurrentNavigableMap c = dmap5();
1289	>	c.remove(null, "whatever");
1290	>	shouldThrow();
1291	>	} catch (NullPointerException success) {}
1292	>	}
1293	>
1294	>	/**
1295	>	* A deserialized map equals original
1296	>	*/
1297	>	public void testDescendingSerialization() throws Exception {
1298	>	ConcurrentNavigableMap q = dmap5();
1299	>
1300	>	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
1301	>	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
1302	>	out.writeObject(q);
1303	>	out.close();
1304	>
1305	>	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
1306	>	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
1307	>	ConcurrentNavigableMap r = (ConcurrentNavigableMap)in.readObject();
1308	>	assertEquals(q.size(), r.size());
1309	>	assertTrue(q.equals(r));
1310	>	assertTrue(r.equals(q));
1311	>	}
1312	>
1313	>
1314	>	/**
1315	>	* subMap returns map with keys in requested range
1316	>	*/
1317	>	public void testDescendingSubMapContents() {
1318	>	ConcurrentNavigableMap map = dmap5();
1319	>	SortedMap sm = map.subMap(m2, m4);
1320	>	assertEquals(m2, sm.firstKey());
1321	>	assertEquals(m3, sm.lastKey());
1322	>	assertEquals(2, sm.size());
1323	>	assertFalse(sm.containsKey(m1));
1324	>	assertTrue(sm.containsKey(m2));
1325	>	assertTrue(sm.containsKey(m3));
1326	>	assertFalse(sm.containsKey(m4));
1327	>	assertFalse(sm.containsKey(m5));
1328	>	Iterator i = sm.keySet().iterator();
1329	>	Object k;
1330	>	k = (Integer)(i.next());
1331	>	assertEquals(m2, k);
1332	>	k = (Integer)(i.next());
1333	>	assertEquals(m3, k);
1334	>	assertFalse(i.hasNext());
1335	>	Iterator j = sm.keySet().iterator();
1336	>	j.next();
1337	>	j.remove();
1338	>	assertFalse(map.containsKey(m2));
1339	>	assertEquals(4, map.size());
1340	>	assertEquals(1, sm.size());
1341	>	assertEquals(m3, sm.firstKey());
1342	>	assertEquals(m3, sm.lastKey());
1343	>	assertEquals("C", sm.remove(m3));
1344	>	assertTrue(sm.isEmpty());
1345	>	assertEquals(3, map.size());
1346	>	}
1347	>
1348	>	public void testDescendingSubMapContents2() {
1349	>	ConcurrentNavigableMap map = dmap5();
1350	>	SortedMap sm = map.subMap(m2, m3);
1351	>	assertEquals(1, sm.size());
1352	>	assertEquals(m2, sm.firstKey());
1353	>	assertEquals(m2, sm.lastKey());
1354	>	assertFalse(sm.containsKey(m1));
1355	>	assertTrue(sm.containsKey(m2));
1356	>	assertFalse(sm.containsKey(m3));
1357	>	assertFalse(sm.containsKey(m4));
1358	>	assertFalse(sm.containsKey(m5));
1359	>	Iterator i = sm.keySet().iterator();
1360	>	Object k;
1361	>	k = (Integer)(i.next());
1362	>	assertEquals(m2, k);
1363	>	assertFalse(i.hasNext());
1364	>	Iterator j = sm.keySet().iterator();
1365	>	j.next();
1366	>	j.remove();
1367	>	assertFalse(map.containsKey(m2));
1368	>	assertEquals(4, map.size());
1369	>	assertEquals(0, sm.size());
1370	>	assertTrue(sm.isEmpty());
1371	>	assertSame(sm.remove(m3), null);
1372	>	assertEquals(4, map.size());
1373	>	}
1374	>
1375	>	/**
1376	>	* headMap returns map with keys in requested range
1377	>	*/
1378	>	public void testDescendingHeadMapContents() {
1379	>	ConcurrentNavigableMap map = dmap5();
1380	>	SortedMap sm = map.headMap(m4);
1381	>	assertTrue(sm.containsKey(m1));
1382	>	assertTrue(sm.containsKey(m2));
1383	>	assertTrue(sm.containsKey(m3));
1384	>	assertFalse(sm.containsKey(m4));
1385	>	assertFalse(sm.containsKey(m5));
1386	>	Iterator i = sm.keySet().iterator();
1387	>	Object k;
1388	>	k = (Integer)(i.next());
1389	>	assertEquals(m1, k);
1390	>	k = (Integer)(i.next());
1391	>	assertEquals(m2, k);
1392	>	k = (Integer)(i.next());
1393	>	assertEquals(m3, k);
1394	>	assertFalse(i.hasNext());
1395	>	sm.clear();
1396	>	assertTrue(sm.isEmpty());
1397	>	assertEquals(2, map.size());
1398	>	assertEquals(m4, map.firstKey());
1399	>	}
1400	>
1401	>	/**
1402	>	* headMap returns map with keys in requested range
1403	>	*/
1404	>	public void testDescendingTailMapContents() {
1405	>	ConcurrentNavigableMap map = dmap5();
1406	>	SortedMap sm = map.tailMap(m2);
1407	>	assertFalse(sm.containsKey(m1));
1408	>	assertTrue(sm.containsKey(m2));
1409	>	assertTrue(sm.containsKey(m3));
1410	>	assertTrue(sm.containsKey(m4));
1411	>	assertTrue(sm.containsKey(m5));
1412	>	Iterator i = sm.keySet().iterator();
1413	>	Object k;
1414	>	k = (Integer)(i.next());
1415	>	assertEquals(m2, k);
1416	>	k = (Integer)(i.next());
1417	>	assertEquals(m3, k);
1418	>	k = (Integer)(i.next());
1419	>	assertEquals(m4, k);
1420	>	k = (Integer)(i.next());
1421	>	assertEquals(m5, k);
1422	>	assertFalse(i.hasNext());
1423	>
1424	>	Iterator ei = sm.entrySet().iterator();
1425	>	Map.Entry e;
1426	>	e = (Map.Entry)(ei.next());
1427	>	assertEquals(m2, e.getKey());
1428	>	assertEquals("B", e.getValue());
1429	>	e = (Map.Entry)(ei.next());
1430	>	assertEquals(m3, e.getKey());
1431	>	assertEquals("C", e.getValue());
1432	>	e = (Map.Entry)(ei.next());
1433	>	assertEquals(m4, e.getKey());
1434	>	assertEquals("D", e.getValue());
1435	>	e = (Map.Entry)(ei.next());
1436	>	assertEquals(m5, e.getKey());
1437	>	assertEquals("E", e.getValue());
1438	>	assertFalse(i.hasNext());
1439	>
1440	>	SortedMap ssm = sm.tailMap(m4);
1441	>	assertEquals(m4, ssm.firstKey());
1442	>	assertEquals(m5, ssm.lastKey());
1443	>	assertEquals("D", ssm.remove(m4));
1444	>	assertEquals(1, ssm.size());
1445	>	assertEquals(3, sm.size());
1446	>	assertEquals(4, map.size());
1447	>	}
1448	>
1449		}

Diff Legend

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