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.9 by jsr166, Sat Nov 21 02:07:26 2009 UTC vs.
Revision 1.15 by jsr166, Wed Aug 25 00:07:03 2010 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);
#	Line 343 | Line 343 | public class ConcurrentSkipListSubMapTes
343		map.remove(four, "A");
344		assertEquals(4, map.size());
345		assertTrue(map.containsKey(four));
346	–
346		}
347
348		/**
#	Line 362 | Line 361 | public class ConcurrentSkipListSubMapTes
361
362		Map.Entry e4 = map.lowerEntry(zero);
363		assertNull(e4);
365	–
364		}
365
366		/**
#	Line 381 | Line 379 | public class ConcurrentSkipListSubMapTes
379
380		Map.Entry e4 = map.higherEntry(six);
381		assertNull(e4);
384	–
382		}
383
384		/**
#	Line 400 | Line 397 | public class ConcurrentSkipListSubMapTes
397
398		Map.Entry e4 = map.floorEntry(zero);
399		assertNull(e4);
403	–
400		}
401
402		/**
#	Line 419 | Line 415 | public class ConcurrentSkipListSubMapTes
415
416		Map.Entry e4 = map.ceilingEntry(six);
417		assertNull(e4);
422	–
418		}
419
420		/**
#	Line 444 | Line 439 | public class ConcurrentSkipListSubMapTes
439		try {
440		e.setValue("A");
441		shouldThrow();
442	<	} catch (Exception ok) {
448	<	}
442	>	} catch (UnsupportedOperationException success) {}
443		e = map.pollFirstEntry();
444		assertNull(e);
445		}
#	Line 472 | Line 466 | public class ConcurrentSkipListSubMapTes
466		try {
467		e.setValue("E");
468		shouldThrow();
469	<	} catch (Exception ok) {
476	<	}
469	>	} catch (UnsupportedOperationException success) {}
470		e = map.pollLastEntry();
471		assertNull(e);
472		}
#	Line 509 | Line 502 | public class ConcurrentSkipListSubMapTes
502		ConcurrentNavigableMap c = map5();
503		c.get(null);
504		shouldThrow();
505	<	} catch (NullPointerException e) {}
505	>	} catch (NullPointerException success) {}
506		}
507
508		/**
#	Line 520 | Line 513 | public class ConcurrentSkipListSubMapTes
513		ConcurrentNavigableMap c = map5();
514		c.containsKey(null);
515		shouldThrow();
516	<	} catch (NullPointerException e) {}
516	>	} catch (NullPointerException success) {}
517		}
518
519		/**
#	Line 531 | Line 524 | public class ConcurrentSkipListSubMapTes
524		ConcurrentNavigableMap c = map0();
525		c.containsValue(null);
526		shouldThrow();
527	<	} catch (NullPointerException e) {}
527	>	} catch (NullPointerException success) {}
528		}
529
530
#	Line 543 | Line 536 | public class ConcurrentSkipListSubMapTes
536		ConcurrentNavigableMap c = map5();
537		c.put(null, "whatever");
538		shouldThrow();
539	<	} catch (NullPointerException e) {}
539	>	} catch (NullPointerException success) {}
540		}
541
542		/**
#	Line 554 | Line 547 | public class ConcurrentSkipListSubMapTes
547		ConcurrentNavigableMap c = map5();
548		c.putIfAbsent(null, "whatever");
549		shouldThrow();
550	<	} catch (NullPointerException e) {}
550	>	} catch (NullPointerException success) {}
551		}
552
553		/**
#	Line 565 | Line 558 | public class ConcurrentSkipListSubMapTes
558		ConcurrentNavigableMap c = map5();
559		c.replace(null, "whatever");
560		shouldThrow();
561	<	} catch (NullPointerException e) {}
561	>	} catch (NullPointerException success) {}
562		}
563
564		/**
#	Line 576 | Line 569 | public class ConcurrentSkipListSubMapTes
569		ConcurrentNavigableMap c = map5();
570		c.replace(null, one, "whatever");
571		shouldThrow();
572	<	} catch (NullPointerException e) {}
572	>	} catch (NullPointerException success) {}
573		}
574
575		/**
#	Line 587 | Line 580 | public class ConcurrentSkipListSubMapTes
580		ConcurrentNavigableMap c = map5();
581		c.remove(null);
582		shouldThrow();
583	<	} catch (NullPointerException e) {}
583	>	} catch (NullPointerException success) {}
584		}
585
586		/**
#	Line 598 | Line 591 | public class ConcurrentSkipListSubMapTes
591		ConcurrentNavigableMap c = map5();
592		c.remove(null, "whatever");
593		shouldThrow();
594	<	} catch (NullPointerException e) {}
594	>	} catch (NullPointerException success) {}
595		}
596
597		/**
598		* A deserialized map equals original
599		*/
600	<	public void testSerialization() {
600	>	public void testSerialization() throws Exception {
601		ConcurrentNavigableMap q = map5();
602
603	<	try {
604	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
605	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
606	<	out.writeObject(q);
607	<	out.close();
608	<
609	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
610	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
611	<	ConcurrentNavigableMap r = (ConcurrentNavigableMap)in.readObject();
612	<	assertEquals(q.size(), r.size());
613	<	assertTrue(q.equals(r));
621	<	assertTrue(r.equals(q));
622	<	} catch (Exception e) {
623	<	e.printStackTrace();
624	<	unexpectedException();
625	<	}
603	>	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
604	>	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
605	>	out.writeObject(q);
606	>	out.close();
607	>
608	>	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
609	>	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
610	>	ConcurrentNavigableMap r = (ConcurrentNavigableMap)in.readObject();
611	>	assertEquals(q.size(), r.size());
612	>	assertTrue(q.equals(r));
613	>	assertTrue(r.equals(q));
614		}
615
616
#	Line 656 | Line 644 | public class ConcurrentSkipListSubMapTes
644		assertEquals(1, sm.size());
645		assertEquals(three, sm.firstKey());
646		assertEquals(three, sm.lastKey());
647	<	assertTrue(sm.remove(three) != null);
647	>	assertEquals("C", sm.remove(three));
648		assertTrue(sm.isEmpty());
649		assertEquals(3, map.size());
650		}
#	Line 684 | Line 672 | public class ConcurrentSkipListSubMapTes
672		assertEquals(4, map.size());
673		assertEquals(0, sm.size());
674		assertTrue(sm.isEmpty());
675	<	assertTrue(sm.remove(three) == null);
675	>	assertSame(sm.remove(three), null);
676		assertEquals(4, map.size());
677		}
678
#	Line 756 | Line 744 | public class ConcurrentSkipListSubMapTes
744		SortedMap ssm = sm.tailMap(four);
745		assertEquals(four, ssm.firstKey());
746		assertEquals(five, ssm.lastKey());
747	<	assertTrue(ssm.remove(four) != null);
747	>	assertEquals("D", ssm.remove(four));
748		assertEquals(1, ssm.size());
749		assertEquals(3, sm.size());
750		assertEquals(4, map.size());
#	Line 1042 | Line 1030 | public class ConcurrentSkipListSubMapTes
1030		map.remove(m4, "A");
1031		assertEquals(4, map.size());
1032		assertTrue(map.containsKey(m4));
1045	–
1033		}
1034
1035		/**
#	Line 1061 | Line 1048 | public class ConcurrentSkipListSubMapTes
1048
1049		Map.Entry e4 = map.lowerEntry(zero);
1050		assertNull(e4);
1064	–
1051		}
1052
1053		/**
#	Line 1080 | Line 1066 | public class ConcurrentSkipListSubMapTes
1066
1067		Map.Entry e4 = map.higherEntry(m6);
1068		assertNull(e4);
1083	–
1069		}
1070
1071		/**
#	Line 1099 | Line 1084 | public class ConcurrentSkipListSubMapTes
1084
1085		Map.Entry e4 = map.floorEntry(zero);
1086		assertNull(e4);
1102	–
1087		}
1088
1089		/**
#	Line 1118 | Line 1102 | public class ConcurrentSkipListSubMapTes
1102
1103		Map.Entry e4 = map.ceilingEntry(m6);
1104		assertNull(e4);
1121	–
1105		}
1106
1107		/**
#	Line 1143 | Line 1126 | public class ConcurrentSkipListSubMapTes
1126		try {
1127		e.setValue("A");
1128		shouldThrow();
1129	<	} catch (Exception ok) {
1147	<	}
1129	>	} catch (UnsupportedOperationException success) {}
1130		e = map.pollFirstEntry();
1131		assertNull(e);
1132		}
#	Line 1171 | Line 1153 | public class ConcurrentSkipListSubMapTes
1153		try {
1154		e.setValue("E");
1155		shouldThrow();
1156	<	} catch (Exception ok) {
1175	<	}
1156	>	} catch (UnsupportedOperationException success) {}
1157		e = map.pollLastEntry();
1158		assertNull(e);
1159		}
#	Line 1201 | Line 1182 | public class ConcurrentSkipListSubMapTes
1182		// Exception testDescendings
1183
1184		/**
1185	<	* get(null) of nm1mpty map throws NPE
1185	>	* get(null) of empty map throws NPE
1186		*/
1187		public void testDescendingGet_NullPointerException() {
1188		try {
1189		ConcurrentNavigableMap c = dmap5();
1190		c.get(null);
1191		shouldThrow();
1192	<	} catch (NullPointerException e) {}
1192	>	} catch (NullPointerException success) {}
1193		}
1194
1195		/**
1196	<	* containsKey(null) of nm1mpty map throws NPE
1196	>	* containsKey(null) of empty map throws NPE
1197		*/
1198		public void testDescendingContainsKey_NullPointerException() {
1199		try {
1200		ConcurrentNavigableMap c = dmap5();
1201		c.containsKey(null);
1202		shouldThrow();
1203	<	} catch (NullPointerException e) {}
1203	>	} catch (NullPointerException success) {}
1204		}
1205
1206		/**
#	Line 1230 | Line 1211 | public class ConcurrentSkipListSubMapTes
1211		ConcurrentNavigableMap c = dmap0();
1212		c.containsValue(null);
1213		shouldThrow();
1214	<	} catch (NullPointerException e) {}
1214	>	} catch (NullPointerException success) {}
1215		}
1216
1217
#	Line 1242 | Line 1223 | public class ConcurrentSkipListSubMapTes
1223		ConcurrentNavigableMap c = dmap5();
1224		c.put(null, "whatever");
1225		shouldThrow();
1226	<	} catch (NullPointerException e) {}
1226	>	} catch (NullPointerException success) {}
1227		}
1228
1229		/**
#	Line 1253 | Line 1234 | public class ConcurrentSkipListSubMapTes
1234		ConcurrentNavigableMap c = dmap5();
1235		c.putIfAbsent(null, "whatever");
1236		shouldThrow();
1237	<	} catch (NullPointerException e) {}
1237	>	} catch (NullPointerException success) {}
1238		}
1239
1240		/**
#	Line 1264 | Line 1245 | public class ConcurrentSkipListSubMapTes
1245		ConcurrentNavigableMap c = dmap5();
1246		c.replace(null, "whatever");
1247		shouldThrow();
1248	<	} catch (NullPointerException e) {}
1248	>	} catch (NullPointerException success) {}
1249		}
1250
1251		/**
#	Line 1275 | Line 1256 | public class ConcurrentSkipListSubMapTes
1256		ConcurrentNavigableMap c = dmap5();
1257		c.replace(null, m1, "whatever");
1258		shouldThrow();
1259	<	} catch (NullPointerException e) {}
1259	>	} catch (NullPointerException success) {}
1260		}
1261
1262		/**
#	Line 1286 | Line 1267 | public class ConcurrentSkipListSubMapTes
1267		ConcurrentNavigableMap c = dmap5();
1268		c.remove(null);
1269		shouldThrow();
1270	<	} catch (NullPointerException e) {}
1270	>	} catch (NullPointerException success) {}
1271		}
1272
1273		/**
#	Line 1297 | Line 1278 | public class ConcurrentSkipListSubMapTes
1278		ConcurrentNavigableMap c = dmap5();
1279		c.remove(null, "whatever");
1280		shouldThrow();
1281	<	} catch (NullPointerException e) {}
1281	>	} catch (NullPointerException success) {}
1282		}
1283
1284		/**
1285		* A deserialized map equals original
1286		*/
1287	<	public void testDescendingSerialization() {
1287	>	public void testDescendingSerialization() throws Exception {
1288		ConcurrentNavigableMap q = dmap5();
1289
1290	<	try {
1291	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
1292	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
1293	<	out.writeObject(q);
1294	<	out.close();
1295	<
1296	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
1297	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
1298	<	ConcurrentNavigableMap r = (ConcurrentNavigableMap)in.readObject();
1299	<	assertEquals(q.size(), r.size());
1300	<	assertTrue(q.equals(r));
1320	<	assertTrue(r.equals(q));
1321	<	} catch (Exception e) {
1322	<	e.printStackTrace();
1323	<	unexpectedException();
1324	<	}
1290	>	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
1291	>	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
1292	>	out.writeObject(q);
1293	>	out.close();
1294	>
1295	>	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
1296	>	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
1297	>	ConcurrentNavigableMap r = (ConcurrentNavigableMap)in.readObject();
1298	>	assertEquals(q.size(), r.size());
1299	>	assertTrue(q.equals(r));
1300	>	assertTrue(r.equals(q));
1301		}
1302
1303
1328	–
1304		/**
1305		* subMap returns map with keys in requested range
1306		*/
#	Line 1355 | Line 1330 | public class ConcurrentSkipListSubMapTes
1330		assertEquals(1, sm.size());
1331		assertEquals(m3, sm.firstKey());
1332		assertEquals(m3, sm.lastKey());
1333	<	assertTrue(sm.remove(m3) != null);
1333	>	assertEquals("C", sm.remove(m3));
1334		assertTrue(sm.isEmpty());
1335		assertEquals(3, map.size());
1336		}
#	Line 1383 | Line 1358 | public class ConcurrentSkipListSubMapTes
1358		assertEquals(4, map.size());
1359		assertEquals(0, sm.size());
1360		assertTrue(sm.isEmpty());
1361	<	assertTrue(sm.remove(m3) == null);
1361	>	assertSame(sm.remove(m3), null);
1362		assertEquals(4, map.size());
1363		}
1364
#	Line 1455 | Line 1430 | public class ConcurrentSkipListSubMapTes
1430		SortedMap ssm = sm.tailMap(m4);
1431		assertEquals(m4, ssm.firstKey());
1432		assertEquals(m5, ssm.lastKey());
1433	<	assertTrue(ssm.remove(m4) != null);
1433	>	assertEquals("D", ssm.remove(m4));
1434		assertEquals(1, ssm.size());
1435		assertEquals(3, sm.size());
1436		assertEquals(4, map.size());

Diff Legend

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