ViewVC Help

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

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

Comparing jsr166/src/test/tck/StampedLockTest.java (file contents):
Revision 1.10 by jsr166, Wed Dec 31 19:05:43 2014 UTC vs.
Revision 1.11 by jsr166, Fri Feb 27 21:43:18 2015 UTC

#	Line 233 | Line 233 | public class StampedLockTest extends JSR
233		/**
234		* A stamp obtained from a successful lock operation validates
235		*/
236	<	public void testValidate() {
237	<	try {
238	<	StampedLock lock = new StampedLock();
239	<	long s = lock.writeLock();
240	<	assertTrue(lock.validate(s));
241	<	lock.unlockWrite(s);
242	<	s = lock.readLock();
243	<	assertTrue(lock.validate(s));
244	<	lock.unlockRead(s);
245	<	assertTrue((s = lock.tryWriteLock()) != 0L);
246	<	assertTrue(lock.validate(s));
247	<	lock.unlockWrite(s);
248	<	assertTrue((s = lock.tryReadLock()) != 0L);
249	<	assertTrue(lock.validate(s));
250	<	lock.unlockRead(s);
251	<	assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
252	<	assertTrue(lock.validate(s));
253	<	lock.unlockWrite(s);
254	<	assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
255	<	assertTrue(lock.validate(s));
256	<	lock.unlockRead(s);
257	<	assertTrue((s = lock.tryOptimisticRead()) != 0L);
258	<	} catch (InterruptedException ie) {
259	<	threadUnexpectedException(ie);
260	<	}
236	>	public void testValidate() throws InterruptedException {
237	>	StampedLock lock = new StampedLock();
238	>	long s = lock.writeLock();
239	>	assertTrue(lock.validate(s));
240	>	lock.unlockWrite(s);
241	>	s = lock.readLock();
242	>	assertTrue(lock.validate(s));
243	>	lock.unlockRead(s);
244	>	assertTrue((s = lock.tryWriteLock()) != 0L);
245	>	assertTrue(lock.validate(s));
246	>	lock.unlockWrite(s);
247	>	assertTrue((s = lock.tryReadLock()) != 0L);
248	>	assertTrue(lock.validate(s));
249	>	lock.unlockRead(s);
250	>	assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
251	>	assertTrue(lock.validate(s));
252	>	lock.unlockWrite(s);
253	>	assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
254	>	assertTrue(lock.validate(s));
255	>	lock.unlockRead(s);
256	>	assertTrue((s = lock.tryOptimisticRead()) != 0L);
257		}
258
259		/**
260		* A stamp obtained from an unsuccessful lock operation does not validate
261		*/
262	<	public void testValidate2() {
263	<	try {
264	<	StampedLock lock = new StampedLock();
265	<	long s;
266	<	assertTrue((s = lock.writeLock()) != 0L);
267	<	assertTrue(lock.validate(s));
268	<	assertFalse(lock.validate(lock.tryWriteLock()));
269	<	assertFalse(lock.validate(lock.tryWriteLock(10L, MILLISECONDS)));
270	<	assertFalse(lock.validate(lock.tryReadLock()));
271	<	assertFalse(lock.validate(lock.tryReadLock(10L, MILLISECONDS)));
272	<	assertFalse(lock.validate(lock.tryOptimisticRead()));
277	<	lock.unlockWrite(s);
278	<	} catch (InterruptedException ie) {
279	<	threadUnexpectedException(ie);
280	<	}
262	>	public void testValidate2() throws InterruptedException {
263	>	StampedLock lock = new StampedLock();
264	>	long s;
265	>	assertTrue((s = lock.writeLock()) != 0L);
266	>	assertTrue(lock.validate(s));
267	>	assertFalse(lock.validate(lock.tryWriteLock()));
268	>	assertFalse(lock.validate(lock.tryWriteLock(10L, MILLISECONDS)));
269	>	assertFalse(lock.validate(lock.tryReadLock()));
270	>	assertFalse(lock.validate(lock.tryReadLock(10L, MILLISECONDS)));
271	>	assertFalse(lock.validate(lock.tryOptimisticRead()));
272	>	lock.unlockWrite(s);
273		}
274
275		/**
276		* writeLockInterruptibly is interruptible
277		*/
278	<	public void testWriteLockInterruptibly_Interruptible() {
278	>	public void testWriteLockInterruptibly_Interruptible()
279	>	throws InterruptedException {
280		final CountDownLatch running = new CountDownLatch(1);
281		final StampedLock lock = new StampedLock();
282		long s = lock.writeLock();
#	Line 292 | Line 285 | public class StampedLockTest extends JSR
285		running.countDown();
286		lock.writeLockInterruptibly();
287		}});
288	<	try {
289	<	running.await();
290	<	waitForThreadToEnterWaitState(t, 100);
291	<	t.interrupt();
292	<	awaitTermination(t);
293	<	releaseWriteLock(lock, s);
301	<	} catch (InterruptedException ie) {
302	<	threadUnexpectedException(ie);
303	<	}
288	>
289	>	running.await();
290	>	waitForThreadToEnterWaitState(t, 100);
291	>	t.interrupt();
292	>	awaitTermination(t);
293	>	releaseWriteLock(lock, s);
294		}
295
296		/**
297		* timed tryWriteLock is interruptible
298		*/
299	<	public void testWriteTryLock_Interruptible() {
299	>	public void testWriteTryLock_Interruptible() throws InterruptedException {
300		final CountDownLatch running = new CountDownLatch(1);
301		final StampedLock lock = new StampedLock();
302		long s = lock.writeLock();
#	Line 315 | Line 305 | public class StampedLockTest extends JSR
305		running.countDown();
306		lock.tryWriteLock(2 * LONG_DELAY_MS, MILLISECONDS);
307		}});
308	<	try {
309	<	running.await();
310	<	waitForThreadToEnterWaitState(t, 100);
311	<	t.interrupt();
312	<	awaitTermination(t);
313	<	releaseWriteLock(lock, s);
324	<	} catch (InterruptedException ie) {
325	<	threadUnexpectedException(ie);
326	<	}
308	>
309	>	running.await();
310	>	waitForThreadToEnterWaitState(t, 100);
311	>	t.interrupt();
312	>	awaitTermination(t);
313	>	releaseWriteLock(lock, s);
314		}
315
316		/**
317		* readLockInterruptibly is interruptible
318		*/
319	<	public void testReadLockInterruptibly_Interruptible() {
319	>	public void testReadLockInterruptibly_Interruptible()
320	>	throws InterruptedException {
321		final CountDownLatch running = new CountDownLatch(1);
322		final StampedLock lock = new StampedLock();
323		long s = lock.writeLock();
#	Line 338 | Line 326 | public class StampedLockTest extends JSR
326		running.countDown();
327		lock.readLockInterruptibly();
328		}});
329	<	try {
330	<	running.await();
331	<	waitForThreadToEnterWaitState(t, 100);
332	<	t.interrupt();
333	<	awaitTermination(t);
334	<	releaseWriteLock(lock, s);
347	<	} catch (InterruptedException ie) {
348	<	threadUnexpectedException(ie);
349	<	}
329	>
330	>	running.await();
331	>	waitForThreadToEnterWaitState(t, 100);
332	>	t.interrupt();
333	>	awaitTermination(t);
334	>	releaseWriteLock(lock, s);
335		}
336
337		/**
338		* timed tryReadLock is interruptible
339		*/
340	<	public void testReadTryLock_Interruptible() {
340	>	public void testReadTryLock_Interruptible() throws InterruptedException {
341		final CountDownLatch running = new CountDownLatch(1);
342		final StampedLock lock = new StampedLock();
343		long s = lock.writeLock();
#	Line 361 | Line 346 | public class StampedLockTest extends JSR
346		running.countDown();
347		lock.tryReadLock(2 * LONG_DELAY_MS, MILLISECONDS);
348		}});
349	<	try {
350	<	running.await();
351	<	waitForThreadToEnterWaitState(t, 100);
352	<	t.interrupt();
353	<	awaitTermination(t);
354	<	releaseWriteLock(lock, s);
370	<	} catch (InterruptedException ie) {
371	<	threadUnexpectedException(ie);
372	<	}
349	>
350	>	running.await();
351	>	waitForThreadToEnterWaitState(t, 100);
352	>	t.interrupt();
353	>	awaitTermination(t);
354	>	releaseWriteLock(lock, s);
355		}
356
357		/**
#	Line 396 | Line 378 | public class StampedLockTest extends JSR
378		long ws = lock.tryWriteLock();
379		assertTrue(ws == 0L);
380		}});
381	<
381	>
382		awaitTermination(t);
383		releaseWriteLock(lock, s);
384		}
#	Line 412 | Line 394 | public class StampedLockTest extends JSR
394		long rs = lock.tryReadLock();
395		assertEquals(rs, 0L);
396		}});
397	<
397	>
398		awaitTermination(t);
399		releaseWriteLock(lock, s);
400		}
#	Line 434 | Line 416 | public class StampedLockTest extends JSR
416		long s4 = lock.readLock();
417		lock.unlockRead(s4);
418		}});
419	<
419	>
420		awaitTermination(t);
421		lock.unlockRead(s);
422		}
#	Line 442 | Line 424 | public class StampedLockTest extends JSR
424		/**
425		* A writelock succeeds only after a reading thread unlocks
426		*/
427	<	public void testWriteAfterReadLock() {
427	>	public void testWriteAfterReadLock() throws InterruptedException {
428		final CountDownLatch running = new CountDownLatch(1);
429		final StampedLock lock = new StampedLock();
430		long rs = lock.readLock();
#	Line 452 | Line 434 | public class StampedLockTest extends JSR
434		long s = lock.writeLock();
435		lock.unlockWrite(s);
436		}});
437	<	try {
438	<	running.await();
439	<	waitForThreadToEnterWaitState(t, 100);
440	<	assertFalse(lock.isWriteLocked());
441	<	lock.unlockRead(rs);
442	<	awaitTermination(t);
443	<	assertFalse(lock.isWriteLocked());
462	<	} catch (InterruptedException ie) {
463	<	threadUnexpectedException(ie);
464	<	}
437	>
438	>	running.await();
439	>	waitForThreadToEnterWaitState(t, 100);
440	>	assertFalse(lock.isWriteLocked());
441	>	lock.unlockRead(rs);
442	>	awaitTermination(t);
443	>	assertFalse(lock.isWriteLocked());
444		}
445
446		/**
#	Line 475 | Line 454 | public class StampedLockTest extends JSR
454		long rs = lock.readLock();
455		lock.unlockRead(rs);
456		}});
457	+
458		awaitTermination(t1);
459
460		Thread t2 = newStartedThread(new CheckedRunnable() {
#	Line 482 | Line 462 | public class StampedLockTest extends JSR
462		long ws = lock.writeLock();
463		lock.unlockWrite(ws);
464		}});
465	+
466		assertFalse(lock.isWriteLocked());
467		lock.unlockRead(s);
468		awaitTermination(t2);
#	Line 585 | Line 566 | public class StampedLockTest extends JSR
566		/**
567		* writeLockInterruptibly succeeds if unlocked, else is interruptible
568		*/
569	<	public void testWriteLockInterruptibly() {
569	>	public void testWriteLockInterruptibly() throws InterruptedException {
570		final CountDownLatch running = new CountDownLatch(1);
571		final StampedLock lock = new StampedLock();
572	<	long s = 0L;
592	<	try {
593	<	s = lock.writeLockInterruptibly();
594	<	} catch (InterruptedException ie) {
595	<	threadUnexpectedException(ie);
596	<	}
572	>	long s = lock.writeLockInterruptibly();
573		Thread t = newStartedThread(new CheckedInterruptedRunnable() {
574		public void realRun() throws InterruptedException {
575		running.countDown();
576		lock.writeLockInterruptibly();
577		}});
578
579	<	try {
580	<	running.await();
581	<	waitForThreadToEnterWaitState(t, 100);
582	<	t.interrupt();
583	<	assertTrue(lock.isWriteLocked());
584	<	awaitTermination(t);
609	<	releaseWriteLock(lock, s);
610	<	} catch (InterruptedException ie) {
611	<	threadUnexpectedException(ie);
612	<	}
613	<
579	>	running.await();
580	>	waitForThreadToEnterWaitState(t, 100);
581	>	t.interrupt();
582	>	assertTrue(lock.isWriteLocked());
583	>	awaitTermination(t);
584	>	releaseWriteLock(lock, s);
585		}
586
587		/**
588		* readLockInterruptibly succeeds if lock free else is interruptible
589		*/
590	<	public void testReadLockInterruptibly() {
590	>	public void testReadLockInterruptibly() throws InterruptedException {
591		final CountDownLatch running = new CountDownLatch(1);
592		final StampedLock lock = new StampedLock();
593	<	long s = 0L;
594	<	try {
595	<	s = lock.readLockInterruptibly();
596	<	lock.unlockRead(s);
626	<	s = lock.writeLockInterruptibly();
627	<	} catch (InterruptedException ie) {
628	<	threadUnexpectedException(ie);
629	<	}
593	>	long s;
594	>	s = lock.readLockInterruptibly();
595	>	lock.unlockRead(s);
596	>	s = lock.writeLockInterruptibly();
597		Thread t = newStartedThread(new CheckedInterruptedRunnable() {
598		public void realRun() throws InterruptedException {
599		running.countDown();
600		lock.readLockInterruptibly();
601		}});
602	<	try {
603	<	running.await();
604	<	waitForThreadToEnterWaitState(t, 100);
605	<	t.interrupt();
606	<	awaitTermination(t);
607	<	releaseWriteLock(lock, s);
641	<	} catch (InterruptedException ie) {
642	<	threadUnexpectedException(ie);
643	<	}
602	>
603	>	running.await();
604	>	waitForThreadToEnterWaitState(t, 100);
605	>	t.interrupt();
606	>	awaitTermination(t);
607	>	releaseWriteLock(lock, s);
608		}
609
610		/**
#	Line 674 | Line 638 | public class StampedLockTest extends JSR
638		/**
639		* tryOptimisticRead succeeds and validates if unlocked, fails if locked
640		*/
641	<	public void testValidateOptimistic() {
642	<	try {
643	<	StampedLock lock = new StampedLock();
644	<	long s, p;
645	<	assertTrue((p = lock.tryOptimisticRead()) != 0L);
646	<	assertTrue(lock.validate(p));
647	<	assertTrue((s = lock.writeLock()) != 0L);
648	<	assertFalse((p = lock.tryOptimisticRead()) != 0L);
649	<	assertTrue(lock.validate(s));
650	<	lock.unlockWrite(s);
651	<	assertTrue((p = lock.tryOptimisticRead()) != 0L);
652	<	assertTrue(lock.validate(p));
653	<	assertTrue((s = lock.readLock()) != 0L);
654	<	assertTrue(lock.validate(s));
655	<	assertTrue((p = lock.tryOptimisticRead()) != 0L);
656	<	assertTrue(lock.validate(p));
657	<	lock.unlockRead(s);
658	<	assertTrue((s = lock.tryWriteLock()) != 0L);
659	<	assertTrue(lock.validate(s));
660	<	assertFalse((p = lock.tryOptimisticRead()) != 0L);
661	<	lock.unlockWrite(s);
662	<	assertTrue((s = lock.tryReadLock()) != 0L);
663	<	assertTrue(lock.validate(s));
664	<	assertTrue((p = lock.tryOptimisticRead()) != 0L);
665	<	lock.unlockRead(s);
666	<	assertTrue(lock.validate(p));
667	<	assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
668	<	assertFalse((p = lock.tryOptimisticRead()) != 0L);
669	<	assertTrue(lock.validate(s));
670	<	lock.unlockWrite(s);
671	<	assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
672	<	assertTrue(lock.validate(s));
673	<	assertTrue((p = lock.tryOptimisticRead()) != 0L);
674	<	lock.unlockRead(s);
711	<	assertTrue((p = lock.tryOptimisticRead()) != 0L);
712	<	} catch (InterruptedException ie) {
713	<	threadUnexpectedException(ie);
714	<	}
641	>	public void testValidateOptimistic() throws InterruptedException {
642	>	StampedLock lock = new StampedLock();
643	>	long s, p;
644	>	assertTrue((p = lock.tryOptimisticRead()) != 0L);
645	>	assertTrue(lock.validate(p));
646	>	assertTrue((s = lock.writeLock()) != 0L);
647	>	assertFalse((p = lock.tryOptimisticRead()) != 0L);
648	>	assertTrue(lock.validate(s));
649	>	lock.unlockWrite(s);
650	>	assertTrue((p = lock.tryOptimisticRead()) != 0L);
651	>	assertTrue(lock.validate(p));
652	>	assertTrue((s = lock.readLock()) != 0L);
653	>	assertTrue(lock.validate(s));
654	>	assertTrue((p = lock.tryOptimisticRead()) != 0L);
655	>	assertTrue(lock.validate(p));
656	>	lock.unlockRead(s);
657	>	assertTrue((s = lock.tryWriteLock()) != 0L);
658	>	assertTrue(lock.validate(s));
659	>	assertFalse((p = lock.tryOptimisticRead()) != 0L);
660	>	lock.unlockWrite(s);
661	>	assertTrue((s = lock.tryReadLock()) != 0L);
662	>	assertTrue(lock.validate(s));
663	>	assertTrue((p = lock.tryOptimisticRead()) != 0L);
664	>	lock.unlockRead(s);
665	>	assertTrue(lock.validate(p));
666	>	assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
667	>	assertFalse((p = lock.tryOptimisticRead()) != 0L);
668	>	assertTrue(lock.validate(s));
669	>	lock.unlockWrite(s);
670	>	assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
671	>	assertTrue(lock.validate(s));
672	>	assertTrue((p = lock.tryOptimisticRead()) != 0L);
673	>	lock.unlockRead(s);
674	>	assertTrue((p = lock.tryOptimisticRead()) != 0L);
675		}
676
677		/**
#	Line 732 | Line 692 | public class StampedLockTest extends JSR
692		* tryOptimisticRead stamp does not validate if a write lock
693		* intervenes in another thread
694		*/
695	<	public void testValidateOptimisticWriteLocked2() {
695	>	public void testValidateOptimisticWriteLocked2()
696	>	throws InterruptedException {
697		final CountDownLatch running = new CountDownLatch(1);
698		final StampedLock lock = new StampedLock();
699		long s, p;
700		assertTrue((p = lock.tryOptimisticRead()) != 0L);
701		Thread t = newStartedThread(new CheckedInterruptedRunnable() {
702	<	public void realRun() throws InterruptedException {
703	<	lock.writeLockInterruptibly();
704	<	running.countDown();
705	<	lock.writeLockInterruptibly();
706	<	}});
707	<	try {
708	<	running.await();
709	<	assertFalse(lock.validate(p));
710	<	assertFalse((p = lock.tryOptimisticRead()) != 0L);
711	<	t.interrupt();
712	<	awaitTermination(t);
752	<	} catch (InterruptedException ie) {
753	<	threadUnexpectedException(ie);
754	<	}
702	>	public void realRun() throws InterruptedException {
703	>	lock.writeLockInterruptibly();
704	>	running.countDown();
705	>	lock.writeLockInterruptibly();
706	>	}});
707	>
708	>	running.await();
709	>	assertFalse(lock.validate(p));
710	>	assertFalse((p = lock.tryOptimisticRead()) != 0L);
711	>	t.interrupt();
712	>	awaitTermination(t);
713		}
714
715		/**
716		* tryConvertToOptimisticRead succeeds and validates if successfully locked,
717		*/
718	<	public void testTryConvertToOptimisticRead() {
719	<	try {
720	<	StampedLock lock = new StampedLock();
721	<	long s, p;
722	<	s = 0L;
723	<	assertFalse((p = lock.tryConvertToOptimisticRead(s)) != 0L);
724	<	assertTrue((s = lock.tryOptimisticRead()) != 0L);
725	<	assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
726	<	assertTrue((s = lock.writeLock()) != 0L);
727	<	assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
728	<	assertTrue(lock.validate(p));
729	<	assertTrue((s = lock.readLock()) != 0L);
730	<	assertTrue(lock.validate(s));
731	<	assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
732	<	assertTrue(lock.validate(p));
733	<	assertTrue((s = lock.tryWriteLock()) != 0L);
734	<	assertTrue(lock.validate(s));
735	<	assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
736	<	assertTrue(lock.validate(p));
737	<	assertTrue((s = lock.tryReadLock()) != 0L);
738	<	assertTrue(lock.validate(s));
739	<	assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
740	<	assertTrue(lock.validate(p));
741	<	assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
742	<	assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
743	<	assertTrue(lock.validate(p));
744	<	assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
745	<	assertTrue(lock.validate(s));
746	<	assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
789	<	assertTrue(lock.validate(p));
790	<	} catch (InterruptedException ie) {
791	<	threadUnexpectedException(ie);
792	<	}
718	>	public void testTryConvertToOptimisticRead() throws InterruptedException {
719	>	StampedLock lock = new StampedLock();
720	>	long s, p;
721	>	s = 0L;
722	>	assertFalse((p = lock.tryConvertToOptimisticRead(s)) != 0L);
723	>	assertTrue((s = lock.tryOptimisticRead()) != 0L);
724	>	assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
725	>	assertTrue((s = lock.writeLock()) != 0L);
726	>	assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
727	>	assertTrue(lock.validate(p));
728	>	assertTrue((s = lock.readLock()) != 0L);
729	>	assertTrue(lock.validate(s));
730	>	assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
731	>	assertTrue(lock.validate(p));
732	>	assertTrue((s = lock.tryWriteLock()) != 0L);
733	>	assertTrue(lock.validate(s));
734	>	assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
735	>	assertTrue(lock.validate(p));
736	>	assertTrue((s = lock.tryReadLock()) != 0L);
737	>	assertTrue(lock.validate(s));
738	>	assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
739	>	assertTrue(lock.validate(p));
740	>	assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
741	>	assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
742	>	assertTrue(lock.validate(p));
743	>	assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
744	>	assertTrue(lock.validate(s));
745	>	assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
746	>	assertTrue(lock.validate(p));
747		}
748
749		/**
750		* tryConvertToReadLock succeeds and validates if successfully locked
751		* or lock free;
752		*/
753	<	public void testTryConvertToReadLock() {
754	<	try {
755	<	StampedLock lock = new StampedLock();
756	<	long s, p;
757	<	s = 0L;
758	<	assertFalse((p = lock.tryConvertToReadLock(s)) != 0L);
759	<	assertTrue((s = lock.tryOptimisticRead()) != 0L);
760	<	assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
761	<	lock.unlockRead(p);
762	<	assertTrue((s = lock.writeLock()) != 0L);
763	<	assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
764	<	assertTrue(lock.validate(p));
765	<	lock.unlockRead(p);
766	<	assertTrue((s = lock.readLock()) != 0L);
767	<	assertTrue(lock.validate(s));
768	<	assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
769	<	assertTrue(lock.validate(p));
770	<	lock.unlockRead(p);
771	<	assertTrue((s = lock.tryWriteLock()) != 0L);
772	<	assertTrue(lock.validate(s));
773	<	assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
774	<	assertTrue(lock.validate(p));
775	<	lock.unlockRead(p);
776	<	assertTrue((s = lock.tryReadLock()) != 0L);
777	<	assertTrue(lock.validate(s));
778	<	assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
779	<	assertTrue(lock.validate(p));
780	<	lock.unlockRead(p);
781	<	assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
782	<	assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
783	<	assertTrue(lock.validate(p));
784	<	lock.unlockRead(p);
785	<	assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
786	<	assertTrue(lock.validate(s));
787	<	assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
788	<	assertTrue(lock.validate(p));
835	<	lock.unlockRead(p);
836	<	} catch (InterruptedException ie) {
837	<	threadUnexpectedException(ie);
838	<	}
753	>	public void testTryConvertToReadLock() throws InterruptedException {
754	>	StampedLock lock = new StampedLock();
755	>	long s, p;
756	>	s = 0L;
757	>	assertFalse((p = lock.tryConvertToReadLock(s)) != 0L);
758	>	assertTrue((s = lock.tryOptimisticRead()) != 0L);
759	>	assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
760	>	lock.unlockRead(p);
761	>	assertTrue((s = lock.writeLock()) != 0L);
762	>	assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
763	>	assertTrue(lock.validate(p));
764	>	lock.unlockRead(p);
765	>	assertTrue((s = lock.readLock()) != 0L);
766	>	assertTrue(lock.validate(s));
767	>	assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
768	>	assertTrue(lock.validate(p));
769	>	lock.unlockRead(p);
770	>	assertTrue((s = lock.tryWriteLock()) != 0L);
771	>	assertTrue(lock.validate(s));
772	>	assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
773	>	assertTrue(lock.validate(p));
774	>	lock.unlockRead(p);
775	>	assertTrue((s = lock.tryReadLock()) != 0L);
776	>	assertTrue(lock.validate(s));
777	>	assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
778	>	assertTrue(lock.validate(p));
779	>	lock.unlockRead(p);
780	>	assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
781	>	assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
782	>	assertTrue(lock.validate(p));
783	>	lock.unlockRead(p);
784	>	assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
785	>	assertTrue(lock.validate(s));
786	>	assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
787	>	assertTrue(lock.validate(p));
788	>	lock.unlockRead(p);
789		}
790
791		/**
792		* tryConvertToWriteLock succeeds and validates if successfully locked
793		* or lock free;
794		*/
795	<	public void testTryConvertToWriteLock() {
796	<	try {
797	<	StampedLock lock = new StampedLock();
798	<	long s, p;
799	<	s = 0L;
800	<	assertFalse((p = lock.tryConvertToWriteLock(s)) != 0L);
801	<	assertTrue((s = lock.tryOptimisticRead()) != 0L);
802	<	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
803	<	lock.unlockWrite(p);
804	<	assertTrue((s = lock.writeLock()) != 0L);
805	<	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
806	<	assertTrue(lock.validate(p));
807	<	lock.unlockWrite(p);
808	<	assertTrue((s = lock.readLock()) != 0L);
809	<	assertTrue(lock.validate(s));
810	<	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
811	<	assertTrue(lock.validate(p));
812	<	lock.unlockWrite(p);
813	<	assertTrue((s = lock.tryWriteLock()) != 0L);
814	<	assertTrue(lock.validate(s));
815	<	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
816	<	assertTrue(lock.validate(p));
817	<	lock.unlockWrite(p);
818	<	assertTrue((s = lock.tryReadLock()) != 0L);
819	<	assertTrue(lock.validate(s));
820	<	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
821	<	assertTrue(lock.validate(p));
822	<	lock.unlockWrite(p);
823	<	assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
824	<	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
825	<	assertTrue(lock.validate(p));
826	<	lock.unlockWrite(p);
827	<	assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
828	<	assertTrue(lock.validate(s));
829	<	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
830	<	assertTrue(lock.validate(p));
881	<	lock.unlockWrite(p);
882	<	} catch (InterruptedException ie) {
883	<	threadUnexpectedException(ie);
884	<	}
795	>	public void testTryConvertToWriteLock() throws InterruptedException {
796	>	StampedLock lock = new StampedLock();
797	>	long s, p;
798	>	s = 0L;
799	>	assertFalse((p = lock.tryConvertToWriteLock(s)) != 0L);
800	>	assertTrue((s = lock.tryOptimisticRead()) != 0L);
801	>	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
802	>	lock.unlockWrite(p);
803	>	assertTrue((s = lock.writeLock()) != 0L);
804	>	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
805	>	assertTrue(lock.validate(p));
806	>	lock.unlockWrite(p);
807	>	assertTrue((s = lock.readLock()) != 0L);
808	>	assertTrue(lock.validate(s));
809	>	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
810	>	assertTrue(lock.validate(p));
811	>	lock.unlockWrite(p);
812	>	assertTrue((s = lock.tryWriteLock()) != 0L);
813	>	assertTrue(lock.validate(s));
814	>	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
815	>	assertTrue(lock.validate(p));
816	>	lock.unlockWrite(p);
817	>	assertTrue((s = lock.tryReadLock()) != 0L);
818	>	assertTrue(lock.validate(s));
819	>	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
820	>	assertTrue(lock.validate(p));
821	>	lock.unlockWrite(p);
822	>	assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
823	>	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
824	>	assertTrue(lock.validate(p));
825	>	lock.unlockWrite(p);
826	>	assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
827	>	assertTrue(lock.validate(s));
828	>	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
829	>	assertTrue(lock.validate(p));
830	>	lock.unlockWrite(p);
831		}
832
833		/**

Diff Legend

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