ViewVC Help

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

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

Comparing jsr166/src/test/tck/JSR166TestCase.java (file contents):
Revision 1.242 by jsr166, Mon Feb 19 16:12:11 2018 UTC vs.
Revision 1.247 by jsr166, Sun Jul 22 21:37:31 2018 UTC

#	Line 66 | Line 66 | import java.util.Arrays;
66		import java.util.Collection;
67		import java.util.Collections;
68		import java.util.Date;
69	+	import java.util.Deque;
70		import java.util.Enumeration;
71	+	import java.util.HashSet;
72		import java.util.Iterator;
73		import java.util.List;
74		import java.util.NoSuchElementException;
75		import java.util.PropertyPermission;
76	+	import java.util.Set;
77		import java.util.concurrent.BlockingQueue;
78		import java.util.concurrent.Callable;
79		import java.util.concurrent.CountDownLatch;
#	Line 448 | Line 451 | public class JSR166TestCase extends Test
451		public static boolean atLeastJava8()  { return JAVA_CLASS_VERSION >= 52.0; }
452		public static boolean atLeastJava9()  { return JAVA_CLASS_VERSION >= 53.0; }
453		public static boolean atLeastJava10() { return JAVA_CLASS_VERSION >= 54.0; }
454	+	public static boolean atLeastJava11() { return JAVA_CLASS_VERSION >= 55.0; }
455
456		/**
457		* Collects all JSR166 unit tests as one suite.
#	Line 1384 | Line 1388 | public class JSR166TestCase extends Test
1388		*/
1389		<T> void checkTimedGet(Future<T> f, T expectedValue, long timeoutMillis) {
1390		long startTime = System.nanoTime();
1391	+	T actual = null;
1392		try {
1393	<	assertEquals(expectedValue, f.get(timeoutMillis, MILLISECONDS));
1393	>	actual = f.get(timeoutMillis, MILLISECONDS);
1394		} catch (Throwable fail) { threadUnexpectedException(fail); }
1395	+	assertEquals(expectedValue, actual);
1396		if (millisElapsedSince(startTime) > timeoutMillis/2)
1397		throw new AssertionError("timed get did not return promptly");
1398		}
#	Line 1565 | Line 1571 | public class JSR166TestCase extends Test
1571		}
1572
1573		public void await(CountDownLatch latch, long timeoutMillis) {
1574	+	boolean timedOut = false;
1575		try {
1576	<	if (!latch.await(timeoutMillis, MILLISECONDS))
1570	<	fail("timed out waiting for CountDownLatch for "
1571	<	+ (timeoutMillis/1000) + " sec");
1576	>	timedOut = !latch.await(timeoutMillis, MILLISECONDS);
1577		} catch (Throwable fail) {
1578		threadUnexpectedException(fail);
1579		}
1580	+	if (timedOut)
1581	+	fail("timed out waiting for CountDownLatch for "
1582	+	+ (timeoutMillis/1000) + " sec");
1583		}
1584
1585		public void await(CountDownLatch latch) {
#	Line 1579 | Line 1587 | public class JSR166TestCase extends Test
1587		}
1588
1589		public void await(Semaphore semaphore) {
1590	+	boolean timedOut = false;
1591		try {
1592	<	if (!semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS))
1584	<	fail("timed out waiting for Semaphore for "
1585	<	+ (LONG_DELAY_MS/1000) + " sec");
1592	>	timedOut = !semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS);
1593		} catch (Throwable fail) {
1594		threadUnexpectedException(fail);
1595		}
1596	+	if (timedOut)
1597	+	fail("timed out waiting for Semaphore for "
1598	+	+ (LONG_DELAY_MS/1000) + " sec");
1599		}
1600
1601		public void await(CyclicBarrier barrier) {
#	Line 1771 | Line 1781 | public class JSR166TestCase extends Test
1781
1782		@SuppressWarnings("unchecked")
1783		<T> T serialClone(T o) {
1784	+	T clone = null;
1785		try {
1786		ObjectInputStream ois = new ObjectInputStream
1787		(new ByteArrayInputStream(serialBytes(o)));
1788	<	T clone = (T) ois.readObject();
1778	<	if (o == clone) assertImmutable(o);
1779	<	assertSame(o.getClass(), clone.getClass());
1780	<	return clone;
1788	>	clone = (T) ois.readObject();
1789		} catch (Throwable fail) {
1790		threadUnexpectedException(fail);
1783	–	return null;
1791		}
1792	+	if (o == clone) assertImmutable(o);
1793	+	else assertSame(o.getClass(), clone.getClass());
1794	+	return clone;
1795		}
1796
1797		/**
#	Line 1800 | Line 1810 | public class JSR166TestCase extends Test
1810		(new ByteArrayInputStream(bos.toByteArray()));
1811		T clone = (T) ois.readObject();
1812		if (o == clone) assertImmutable(o);
1813	<	assertSame(o.getClass(), clone.getClass());
1813	>	else assertSame(o.getClass(), clone.getClass());
1814		return clone;
1815		}
1816
#	Line 2051 | Line 2061 | public class JSR166TestCase extends Test
2061		assertEquals(savedCompletedTaskCount, p.getCompletedTaskCount());
2062		assertEquals(savedQueueSize, p.getQueue().size());
2063		}
2064	+
2065	+	void assertCollectionsEquals(Collection<?> x, Collection<?> y) {
2066	+	assertEquals(x, y);
2067	+	assertEquals(y, x);
2068	+	assertEquals(x.isEmpty(), y.isEmpty());
2069	+	assertEquals(x.size(), y.size());
2070	+	if (x instanceof List) {
2071	+	assertEquals(x.toString(), y.toString());
2072	+	}
2073	+	if (x instanceof List || x instanceof Set) {
2074	+	assertEquals(x.hashCode(), y.hashCode());
2075	+	}
2076	+	if (x instanceof List || x instanceof Deque) {
2077	+	assertTrue(Arrays.equals(x.toArray(), y.toArray()));
2078	+	assertTrue(Arrays.equals(x.toArray(new Object[0]),
2079	+	y.toArray(new Object[0])));
2080	+	}
2081	+	}
2082	+
2083	+	/**
2084	+	* A weaker form of assertCollectionsEquals which does not insist
2085	+	* that the two collections satisfy Object#equals(Object), since
2086	+	* they may use identity semantics as Deques do.
2087	+	*/
2088	+	void assertCollectionsEquivalent(Collection<?> x, Collection<?> y) {
2089	+	if (x instanceof List || x instanceof Set)
2090	+	assertCollectionsEquals(x, y);
2091	+	else {
2092	+	assertEquals(x.isEmpty(), y.isEmpty());
2093	+	assertEquals(x.size(), y.size());
2094	+	assertEquals(new HashSet(x), new HashSet(y));
2095	+	if (x instanceof Deque) {
2096	+	assertTrue(Arrays.equals(x.toArray(), y.toArray()));
2097	+	assertTrue(Arrays.equals(x.toArray(new Object[0]),
2098	+	y.toArray(new Object[0])));
2099	+	}
2100	+	}
2101	+	}
2102		}

Diff Legend

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