ViewVC Help

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

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

Comparing jsr166/src/test/tck/ReentrantReadWriteLockTest.java (file contents):
Revision 1.62 by jsr166, Sun May 15 17:30:21 2011 UTC vs.
Revision 1.81 by jsr166, Mon Jul 17 21:01:30 2017 UTC

#	Line 6 | Line 6
6		* Pat Fisher, Mike Judd.
7		*/
8
9	–	import junit.framework.*;
10	–	import java.util.concurrent.atomic.AtomicBoolean;
11	–	import java.util.concurrent.locks.*;
12	–	import java.util.concurrent.*;
9		import static java.util.concurrent.TimeUnit.MILLISECONDS;
14	–	import java.io.*;
15	–	import java.util.*;
10
11	+	import java.util.Arrays;
12	+	import java.util.Collection;
13	+	import java.util.HashSet;
14	+	import java.util.concurrent.CountDownLatch;
15	+	import java.util.concurrent.atomic.AtomicBoolean;
16	+	import java.util.concurrent.locks.Condition;
17	+	import java.util.concurrent.locks.Lock;
18	+	import java.util.concurrent.locks.ReentrantReadWriteLock;
19	+
20	+	import junit.framework.AssertionFailedError;
21	+	import junit.framework.Test;
22	+	import junit.framework.TestSuite;
23	+
24	+	@SuppressWarnings("WaitNotInLoop") // we implement spurious-wakeup freedom
25		public class ReentrantReadWriteLockTest extends JSR166TestCase {
26		public static void main(String[] args) {
27	<	junit.textui.TestRunner.run(suite());
27	>	main(suite(), args);
28		}
29		public static Test suite() {
30		return new TestSuite(ReentrantReadWriteLockTest.class);
#	Line 84 | Line 92 | public class ReentrantReadWriteLockTest
92		Thread.yield();
93		}
94		assertTrue(t.isAlive());
95	<	assertTrue(lock.getOwner() != t);
95	>	assertNotSame(t, lock.getOwner());
96		}
97
98		/**
#	Line 145 | Line 153 | public class ReentrantReadWriteLockTest
153		lock.writeLock().unlock();
154		}
155
156	<	enum AwaitMethod { await, awaitNanos, awaitUntil };
156	>	enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil }
157
158		/**
159	<	* Awaits condition using the specified AwaitMethod.
159	>	* Awaits condition "indefinitely" using the specified AwaitMethod.
160		*/
161		void await(Condition c, AwaitMethod awaitMethod)
162		throws InterruptedException {
163	+	long timeoutMillis = 2 * LONG_DELAY_MS;
164		switch (awaitMethod) {
165		case await:
166		c.await();
167		break;
168	+	case awaitTimed:
169	+	assertTrue(c.await(timeoutMillis, MILLISECONDS));
170	+	break;
171		case awaitNanos:
172	<	long nanosRemaining = c.awaitNanos(MILLISECONDS.toNanos(2 * LONG_DELAY_MS));
173	<	assertTrue(nanosRemaining > 0);
172	>	long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
173	>	long nanosRemaining = c.awaitNanos(timeoutNanos);
174	>	assertTrue(nanosRemaining > timeoutNanos / 2);
175	>	assertTrue(nanosRemaining <= timeoutNanos);
176		break;
177		case awaitUntil:
178	<	java.util.Date d = new java.util.Date();
165	<	assertTrue(c.awaitUntil(new java.util.Date(d.getTime() + 2 * LONG_DELAY_MS)));
178	>	assertTrue(c.awaitUntil(delayedDate(timeoutMillis)));
179		break;
180	+	default:
181	+	throw new AssertionError();
182		}
183		}
184
#	Line 217 | Line 232 | public class ReentrantReadWriteLockTest
232		public void testGetWriteHoldCount()      { testGetWriteHoldCount(false); }
233		public void testGetWriteHoldCount_fair() { testGetWriteHoldCount(true); }
234		public void testGetWriteHoldCount(boolean fair) {
235	<	ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
235	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
236		for (int i = 1; i <= SIZE; i++) {
237		lock.writeLock().lock();
238		assertEquals(i,lock.getWriteHoldCount());
239		}
240		for (int i = SIZE; i > 0; i--) {
241		lock.writeLock().unlock();
242	<	assertEquals(i-1,lock.getWriteHoldCount());
242	>	assertEquals(i - 1,lock.getWriteHoldCount());
243		}
244		}
245
#	Line 234 | Line 249 | public class ReentrantReadWriteLockTest
249		public void testGetHoldCount()      { testGetHoldCount(false); }
250		public void testGetHoldCount_fair() { testGetHoldCount(true); }
251		public void testGetHoldCount(boolean fair) {
252	<	ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
252	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
253		for (int i = 1; i <= SIZE; i++) {
254		lock.writeLock().lock();
255		assertEquals(i,lock.writeLock().getHoldCount());
256		}
257		for (int i = SIZE; i > 0; i--) {
258		lock.writeLock().unlock();
259	<	assertEquals(i-1,lock.writeLock().getHoldCount());
259	>	assertEquals(i - 1,lock.writeLock().getHoldCount());
260		}
261		}
262
#	Line 251 | Line 266 | public class ReentrantReadWriteLockTest
266		public void testGetReadHoldCount()      { testGetReadHoldCount(false); }
267		public void testGetReadHoldCount_fair() { testGetReadHoldCount(true); }
268		public void testGetReadHoldCount(boolean fair) {
269	<	ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
269	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
270		for (int i = 1; i <= SIZE; i++) {
271		lock.readLock().lock();
272		assertEquals(i,lock.getReadHoldCount());
273		}
274		for (int i = SIZE; i > 0; i--) {
275		lock.readLock().unlock();
276	<	assertEquals(i-1,lock.getReadHoldCount());
276	>	assertEquals(i - 1,lock.getReadHoldCount());
277		}
278		}
279
#	Line 268 | Line 283 | public class ReentrantReadWriteLockTest
283		public void testWriteUnlock_IMSE()      { testWriteUnlock_IMSE(false); }
284		public void testWriteUnlock_IMSE_fair() { testWriteUnlock_IMSE(true); }
285		public void testWriteUnlock_IMSE(boolean fair) {
286	<	ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
286	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
287		try {
288		lock.writeLock().unlock();
289		shouldThrow();
#	Line 281 | Line 296 | public class ReentrantReadWriteLockTest
296		public void testReadUnlock_IMSE()      { testReadUnlock_IMSE(false); }
297		public void testReadUnlock_IMSE_fair() { testReadUnlock_IMSE(true); }
298		public void testReadUnlock_IMSE(boolean fair) {
299	<	ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
299	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
300		try {
301		lock.readLock().unlock();
302		shouldThrow();
#	Line 504 | Line 519 | public class ReentrantReadWriteLockTest
519
520		/**
521		* A thread that tries to acquire a fair read lock (non-reentrantly)
522	<	* will block if there is a waiting writer thread.
522	>	* will block if there is a waiting writer thread
523		*/
524		public void testReaderWriterReaderFairFifo() {
525		final PublicReentrantReadWriteLock lock =
#	Line 581 | Line 596 | public class ReentrantReadWriteLockTest
596		}
597
598		/**
599	<	* Read trylock succeeds (barging) even in the presence of waiting readers and/or writers.
599	>	* Read trylock succeeds (barging) even in the presence of waiting
600	>	* readers and/or writers
601		*/
602		public void testReadTryLockBarging()      { testReadTryLockBarging(false); }
603		public void testReadTryLockBarging_fair() { testReadTryLockBarging(true); }
#	Line 773 | Line 789 | public class ReentrantReadWriteLockTest
789		public void testWriteTryLock_Timeout(boolean fair) {
790		final PublicReentrantReadWriteLock lock =
791		new PublicReentrantReadWriteLock(fair);
792	+	final long timeoutMillis = timeoutMillis();
793		lock.writeLock().lock();
794		Thread t = newStartedThread(new CheckedRunnable() {
795		public void realRun() throws InterruptedException {
796		long startTime = System.nanoTime();
780	–	long timeoutMillis = 10;
797		assertFalse(lock.writeLock().tryLock(timeoutMillis, MILLISECONDS));
798		assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
799		}});
#	Line 797 | Line 813 | public class ReentrantReadWriteLockTest
813		Thread t = newStartedThread(new CheckedRunnable() {
814		public void realRun() throws InterruptedException {
815		long startTime = System.nanoTime();
816	<	long timeoutMillis = 10;
816	>	long timeoutMillis = timeoutMillis();
817		assertFalse(lock.readLock().tryLock(timeoutMillis, MILLISECONDS));
818		assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
819		}});
#	Line 817 | Line 833 | public class ReentrantReadWriteLockTest
833		new PublicReentrantReadWriteLock(fair);
834		try {
835		lock.writeLock().lockInterruptibly();
836	<	} catch (InterruptedException ie) {
821	<	threadUnexpectedException(ie);
822	<	}
836	>	} catch (InterruptedException fail) { threadUnexpectedException(fail); }
837		Thread t = newStartedThread(new CheckedInterruptedRunnable() {
838		public void realRun() throws InterruptedException {
839		lock.writeLock().lockInterruptibly();
#	Line 844 | Line 858 | public class ReentrantReadWriteLockTest
858		lock.readLock().lockInterruptibly();
859		lock.readLock().unlock();
860		lock.writeLock().lockInterruptibly();
861	<	} catch (InterruptedException ie) {
848	<	threadUnexpectedException(ie);
849	<	}
861	>	} catch (InterruptedException fail) { threadUnexpectedException(fail); }
862		Thread t = newStartedThread(new CheckedInterruptedRunnable() {
863		public void realRun() throws InterruptedException {
864		lock.readLock().lockInterruptibly();
#	Line 866 | Line 878 | public class ReentrantReadWriteLockTest
878		public void testAwait_IMSE(boolean fair) {
879		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
880		final Condition c = lock.writeLock().newCondition();
881	<	long startTime = System.nanoTime();
882	<	try {
871	<	try {
872	<	c.await();
873	<	shouldThrow();
874	<	} catch (IllegalMonitorStateException success) {}
875	<	try {
876	<	c.await(LONG_DELAY_MS, MILLISECONDS);
877	<	shouldThrow();
878	<	} catch (IllegalMonitorStateException success) {}
879	<	try {
880	<	c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS));
881	<	shouldThrow();
882	<	} catch (IllegalMonitorStateException success) {}
881	>	for (AwaitMethod awaitMethod : AwaitMethod.values()) {
882	>	long startTime = System.nanoTime();
883		try {
884	<	c.awaitUninterruptibly();
884	>	await(c, awaitMethod);
885		shouldThrow();
886	<	} catch (IllegalMonitorStateException success) {}
887	<	} catch (InterruptedException ie) {
888	<	threadUnexpectedException(ie);
886	>	} catch (IllegalMonitorStateException success) {
887	>	} catch (InterruptedException fail) {
888	>	threadUnexpectedException(fail);
889	>	}
890	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
891		}
890	–	assertTrue(millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
892		}
893
894		/**
#	Line 924 | Line 925 | public class ReentrantReadWriteLockTest
925		public void testAwaitNanos_Timeout()      { testAwaitNanos_Timeout(false); }
926		public void testAwaitNanos_Timeout_fair() { testAwaitNanos_Timeout(true); }
927		public void testAwaitNanos_Timeout(boolean fair) {
928	+	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
929	+	final Condition c = lock.writeLock().newCondition();
930	+	final long timeoutMillis = timeoutMillis();
931	+	lock.writeLock().lock();
932	+	final long startTime = System.nanoTime();
933	+	final long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
934		try {
928	–	final ReentrantReadWriteLock lock =
929	–	new ReentrantReadWriteLock(fair);
930	–	final Condition c = lock.writeLock().newCondition();
931	–	lock.writeLock().lock();
932	–	long startTime = System.nanoTime();
933	–	long timeoutMillis = 10;
934	–	long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
935		long nanosRemaining = c.awaitNanos(timeoutNanos);
936		assertTrue(nanosRemaining <= 0);
937	<	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
938	<	lock.writeLock().unlock();
939	<	} catch (InterruptedException e) {
940	<	threadUnexpectedException(e);
941	<	}
937	>	} catch (InterruptedException fail) { threadUnexpectedException(fail); }
938	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
939	>	lock.writeLock().unlock();
940		}
941
942		/**
#	Line 947 | Line 945 | public class ReentrantReadWriteLockTest
945		public void testAwait_Timeout()      { testAwait_Timeout(false); }
946		public void testAwait_Timeout_fair() { testAwait_Timeout(true); }
947		public void testAwait_Timeout(boolean fair) {
948	+	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
949	+	final Condition c = lock.writeLock().newCondition();
950	+	final long timeoutMillis = timeoutMillis();
951	+	lock.writeLock().lock();
952	+	final long startTime = System.nanoTime();
953		try {
951	–	final ReentrantReadWriteLock lock =
952	–	new ReentrantReadWriteLock(fair);
953	–	final Condition c = lock.writeLock().newCondition();
954	–	lock.writeLock().lock();
955	–	long startTime = System.nanoTime();
956	–	long timeoutMillis = 10;
954		assertFalse(c.await(timeoutMillis, MILLISECONDS));
955	<	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
956	<	lock.writeLock().unlock();
957	<	} catch (InterruptedException e) {
961	<	threadUnexpectedException(e);
962	<	}
955	>	} catch (InterruptedException fail) { threadUnexpectedException(fail); }
956	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
957	>	lock.writeLock().unlock();
958		}
959
960		/**
#	Line 968 | Line 963 | public class ReentrantReadWriteLockTest
963		public void testAwaitUntil_Timeout()      { testAwaitUntil_Timeout(false); }
964		public void testAwaitUntil_Timeout_fair() { testAwaitUntil_Timeout(true); }
965		public void testAwaitUntil_Timeout(boolean fair) {
966	+	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
967	+	final Condition c = lock.writeLock().newCondition();
968	+	lock.writeLock().lock();
969	+	// We shouldn't assume that nanoTime and currentTimeMillis
970	+	// use the same time source, so don't use nanoTime here.
971	+	final java.util.Date delayedDate = delayedDate(timeoutMillis());
972		try {
973	<	final ReentrantReadWriteLock lock =
974	<	new ReentrantReadWriteLock(fair);
975	<	final Condition c = lock.writeLock().newCondition();
976	<	lock.writeLock().lock();
976	<	long startTime = System.nanoTime();
977	<	long timeoutMillis = 10;
978	<	java.util.Date d = new java.util.Date();
979	<	assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + timeoutMillis)));
980	<	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
981	<	lock.writeLock().unlock();
982	<	} catch (InterruptedException e) {
983	<	threadUnexpectedException(e);
984	<	}
973	>	assertFalse(c.awaitUntil(delayedDate));
974	>	} catch (InterruptedException fail) { threadUnexpectedException(fail); }
975	>	assertTrue(new java.util.Date().getTime() >= delayedDate.getTime());
976	>	lock.writeLock().unlock();
977		}
978
979		/**
#	Line 1013 | Line 1005 | public class ReentrantReadWriteLockTest
1005		}
1006
1007		/**
1008	<	* awaitUninterruptibly doesn't abort on interrupt
1008	>	* awaitUninterruptibly is uninterruptible
1009		*/
1010		public void testAwaitUninterruptibly()      { testAwaitUninterruptibly(false); }
1011		public void testAwaitUninterruptibly_fair() { testAwaitUninterruptibly(true); }
1012		public void testAwaitUninterruptibly(boolean fair) {
1013	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1014	<	final Condition c = lock.writeLock().newCondition();
1015	<	final CountDownLatch locked = new CountDownLatch(1);
1016	<	Thread t = newStartedThread(new CheckedRunnable() {
1013	>	final Lock lock = new ReentrantReadWriteLock(fair).writeLock();
1014	>	final Condition condition = lock.newCondition();
1015	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
1016	>
1017	>	Thread t1 = newStartedThread(new CheckedRunnable() {
1018		public void realRun() {
1019	<	lock.writeLock().lock();
1020	<	locked.countDown();
1021	<	c.awaitUninterruptibly();
1019	>	// Interrupt before awaitUninterruptibly
1020	>	lock.lock();
1021	>	pleaseInterrupt.countDown();
1022	>	Thread.currentThread().interrupt();
1023	>	condition.awaitUninterruptibly();
1024		assertTrue(Thread.interrupted());
1025	<	lock.writeLock().unlock();
1025	>	lock.unlock();
1026		}});
1027
1028	<	await(locked);
1029	<	lock.writeLock().lock();
1030	<	lock.writeLock().unlock();
1031	<	t.interrupt();
1032	<	long timeoutMillis = 10;
1033	<	assertThreadStaysAlive(t, timeoutMillis);
1034	<	lock.writeLock().lock();
1035	<	c.signal();
1036	<	lock.writeLock().unlock();
1037	<	awaitTermination(t);
1028	>	Thread t2 = newStartedThread(new CheckedRunnable() {
1029	>	public void realRun() {
1030	>	// Interrupt during awaitUninterruptibly
1031	>	lock.lock();
1032	>	pleaseInterrupt.countDown();
1033	>	condition.awaitUninterruptibly();
1034	>	assertTrue(Thread.interrupted());
1035	>	lock.unlock();
1036	>	}});
1037	>
1038	>	await(pleaseInterrupt);
1039	>	t2.interrupt();
1040	>	lock.lock();
1041	>	lock.unlock();
1042	>	assertThreadBlocks(t1, Thread.State.WAITING);
1043	>	assertThreadBlocks(t2, Thread.State.WAITING);
1044	>
1045	>	lock.lock();
1046	>	condition.signalAll();
1047	>	lock.unlock();
1048	>
1049	>	awaitTermination(t1);
1050	>	awaitTermination(t2);
1051		}
1052
1053		/**
#	Line 1047 | Line 1055 | public class ReentrantReadWriteLockTest
1055		*/
1056		public void testInterruptible_await()           { testInterruptible(false, AwaitMethod.await); }
1057		public void testInterruptible_await_fair()      { testInterruptible(true,  AwaitMethod.await); }
1058	+	public void testInterruptible_awaitTimed()      { testInterruptible(false, AwaitMethod.awaitTimed); }
1059	+	public void testInterruptible_awaitTimed_fair() { testInterruptible(true,  AwaitMethod.awaitTimed); }
1060		public void testInterruptible_awaitNanos()      { testInterruptible(false, AwaitMethod.awaitNanos); }
1061		public void testInterruptible_awaitNanos_fair() { testInterruptible(true,  AwaitMethod.awaitNanos); }
1062		public void testInterruptible_awaitUntil()      { testInterruptible(false, AwaitMethod.awaitUntil); }
#	Line 1084 | Line 1094 | public class ReentrantReadWriteLockTest
1094		*/
1095		public void testSignalAll_await()           { testSignalAll(false, AwaitMethod.await); }
1096		public void testSignalAll_await_fair()      { testSignalAll(true,  AwaitMethod.await); }
1097	+	public void testSignalAll_awaitTimed()      { testSignalAll(false, AwaitMethod.awaitTimed); }
1098	+	public void testSignalAll_awaitTimed_fair() { testSignalAll(true,  AwaitMethod.awaitTimed); }
1099		public void testSignalAll_awaitNanos()      { testSignalAll(false, AwaitMethod.awaitNanos); }
1100		public void testSignalAll_awaitNanos_fair() { testSignalAll(true,  AwaitMethod.awaitNanos); }
1101		public void testSignalAll_awaitUntil()      { testSignalAll(false, AwaitMethod.awaitUntil); }
#	Line 1117 | Line 1129 | public class ReentrantReadWriteLockTest
1129		}
1130
1131		/**
1132	<	* signal wakes up waiting threads in FIFO order.
1132	>	* signal wakes up waiting threads in FIFO order
1133		*/
1134		public void testSignalWakesFifo()      { testSignalWakesFifo(false); }
1135		public void testSignalWakesFifo_fair() { testSignalWakesFifo(true); }
#	Line 1216 | Line 1228 | public class ReentrantReadWriteLockTest
1228		public void testSerialization()      { testSerialization(false); }
1229		public void testSerialization_fair() { testSerialization(true); }
1230		public void testSerialization(boolean fair) {
1231	<	ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1231	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1232		lock.writeLock().lock();
1233		lock.readLock().lock();
1234
#	Line 1278 | Line 1290 | public class ReentrantReadWriteLockTest
1290		}
1291
1292		/**
1293	<	* hasQueuedThread reports whether a thread is queued.
1293	>	* hasQueuedThread reports whether a thread is queued
1294		*/
1295		public void testHasQueuedThread()      { testHasQueuedThread(false); }
1296		public void testHasQueuedThread_fair() { testHasQueuedThread(true); }
#	Line 1618 | Line 1630 | public class ReentrantReadWriteLockTest
1630		public void testToString()      { testToString(false); }
1631		public void testToString_fair() { testToString(true); }
1632		public void testToString(boolean fair) {
1633	<	ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1634	<	String us = lock.toString();
1635	<	assertTrue(us.indexOf("Write locks = 0") >= 0);
1636	<	assertTrue(us.indexOf("Read locks = 0") >= 0);
1637	<	lock.writeLock().lock();
1638	<	String ws = lock.toString();
1639	<	assertTrue(ws.indexOf("Write locks = 1") >= 0);
1640	<	assertTrue(ws.indexOf("Read locks = 0") >= 0);
1633	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1634	>	assertTrue(lock.toString().contains("Write locks = 0"));
1635	>	assertTrue(lock.toString().contains("Read locks = 0"));
1636	>	lock.writeLock().lock();
1637	>	assertTrue(lock.toString().contains("Write locks = 1"));
1638	>	assertTrue(lock.toString().contains("Read locks = 0"));
1639	>	lock.writeLock().lock();
1640	>	assertTrue(lock.toString().contains("Write locks = 2"));
1641	>	assertTrue(lock.toString().contains("Read locks = 0"));
1642	>	lock.writeLock().unlock();
1643		lock.writeLock().unlock();
1644		lock.readLock().lock();
1645	+	assertTrue(lock.toString().contains("Write locks = 0"));
1646	+	assertTrue(lock.toString().contains("Read locks = 1"));
1647		lock.readLock().lock();
1648	<	String rs = lock.toString();
1649	<	assertTrue(rs.indexOf("Write locks = 0") >= 0);
1634	<	assertTrue(rs.indexOf("Read locks = 2") >= 0);
1648	>	assertTrue(lock.toString().contains("Write locks = 0"));
1649	>	assertTrue(lock.toString().contains("Read locks = 2"));
1650		}
1651
1652		/**
#	Line 1640 | Line 1655 | public class ReentrantReadWriteLockTest
1655		public void testReadLockToString()      { testReadLockToString(false); }
1656		public void testReadLockToString_fair() { testReadLockToString(true); }
1657		public void testReadLockToString(boolean fair) {
1658	<	ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1659	<	String us = lock.readLock().toString();
1645	<	assertTrue(us.indexOf("Read locks = 0") >= 0);
1658	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1659	>	assertTrue(lock.readLock().toString().contains("Read locks = 0"));
1660		lock.readLock().lock();
1661	+	assertTrue(lock.readLock().toString().contains("Read locks = 1"));
1662		lock.readLock().lock();
1663	<	String rs = lock.readLock().toString();
1664	<	assertTrue(rs.indexOf("Read locks = 2") >= 0);
1663	>	assertTrue(lock.readLock().toString().contains("Read locks = 2"));
1664	>	lock.readLock().unlock();
1665	>	assertTrue(lock.readLock().toString().contains("Read locks = 1"));
1666	>	lock.readLock().unlock();
1667	>	assertTrue(lock.readLock().toString().contains("Read locks = 0"));
1668		}
1669
1670		/**
#	Line 1655 | Line 1673 | public class ReentrantReadWriteLockTest
1673		public void testWriteLockToString()      { testWriteLockToString(false); }
1674		public void testWriteLockToString_fair() { testWriteLockToString(true); }
1675		public void testWriteLockToString(boolean fair) {
1676	<	ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1677	<	String us = lock.writeLock().toString();
1660	<	assertTrue(us.indexOf("Unlocked") >= 0);
1676	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1677	>	assertTrue(lock.writeLock().toString().contains("Unlocked"));
1678		lock.writeLock().lock();
1679	<	String ls = lock.writeLock().toString();
1680	<	assertTrue(ls.indexOf("Locked") >= 0);
1679	>	assertTrue(lock.writeLock().toString().contains("Locked by"));
1680	>	lock.writeLock().unlock();
1681	>	assertTrue(lock.writeLock().toString().contains("Unlocked"));
1682		}
1683
1684		}

Diff Legend

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