ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/StampedLockTest.java
(Generate patch)

Comparing jsr166/src/test/tck/StampedLockTest.java (file contents):
Revision 1.20 by jsr166, Tue Jun 7 07:20:09 2016 UTC vs.
Revision 1.23 by jsr166, Tue Jun 7 22:21:05 2016 UTC

# Line 766 | Line 766 | public class StampedLockTest extends JSR
766      public void testTryConvertToReadLock() throws InterruptedException {
767          StampedLock lock = new StampedLock();
768          long s, p;
769 <        s = 0L;
770 <        assertFalse((p = lock.tryConvertToReadLock(s)) != 0L);
769 >
770 >        assertFalse((p = lock.tryConvertToReadLock(0L)) != 0L);
771 >
772          assertTrue((s = lock.tryOptimisticRead()) != 0L);
773          assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
774 +        assertTrue(lock.isReadLocked());
775 +        assertEquals(1, lock.getReadLockCount());
776          lock.unlockRead(p);
777 +
778          assertTrue((s = lock.writeLock()) != 0L);
779          assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
780          assertTrue(lock.validate(p));
781 +        assertTrue(lock.isReadLocked());
782 +        assertEquals(1, lock.getReadLockCount());
783          lock.unlockRead(p);
784 +
785          assertTrue((s = lock.readLock()) != 0L);
786          assertTrue(lock.validate(s));
787 <        assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
788 <        assertTrue(lock.validate(p));
789 <        lock.unlockRead(p);
787 >        assertEquals(s, lock.tryConvertToReadLock(s));
788 >        assertTrue(lock.validate(s));
789 >        assertTrue(lock.isReadLocked());
790 >        assertEquals(1, lock.getReadLockCount());
791 >        lock.unlockRead(s);
792 >
793          assertTrue((s = lock.tryWriteLock()) != 0L);
794          assertTrue(lock.validate(s));
795          assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
796          assertTrue(lock.validate(p));
797 +        assertEquals(1, lock.getReadLockCount());
798          lock.unlockRead(p);
799 +
800          assertTrue((s = lock.tryReadLock()) != 0L);
801          assertTrue(lock.validate(s));
802 <        assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
803 <        assertTrue(lock.validate(p));
804 <        lock.unlockRead(p);
802 >        assertEquals(s, lock.tryConvertToReadLock(s));
803 >        assertTrue(lock.validate(s));
804 >        assertTrue(lock.isReadLocked());
805 >        assertEquals(1, lock.getReadLockCount());
806 >        lock.unlockRead(s);
807 >
808          assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
809          assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
810          assertTrue(lock.validate(p));
811 +        assertTrue(lock.isReadLocked());
812 +        assertEquals(1, lock.getReadLockCount());
813          lock.unlockRead(p);
814 +
815          assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
816          assertTrue(lock.validate(s));
817 <        assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
818 <        assertTrue(lock.validate(p));
819 <        lock.unlockRead(p);
817 >        assertEquals(s, lock.tryConvertToReadLock(s));
818 >        assertTrue(lock.validate(s));
819 >        assertTrue(lock.isReadLocked());
820 >        assertEquals(1, lock.getReadLockCount());
821 >        lock.unlockRead(s);
822      }
823  
824      /**
# Line 808 | Line 828 | public class StampedLockTest extends JSR
828      public void testTryConvertToWriteLock() throws InterruptedException {
829          StampedLock lock = new StampedLock();
830          long s, p;
831 <        s = 0L;
832 <        assertFalse((p = lock.tryConvertToWriteLock(s)) != 0L);
831 >
832 >        assertFalse((p = lock.tryConvertToWriteLock(0L)) != 0L);
833 >
834          assertTrue((s = lock.tryOptimisticRead()) != 0L);
835          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
836 +        assertTrue(lock.isWriteLocked());
837          lock.unlockWrite(p);
838 +
839          assertTrue((s = lock.writeLock()) != 0L);
840 <        assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
841 <        assertTrue(lock.validate(p));
842 <        lock.unlockWrite(p);
840 >        assertEquals(s, lock.tryConvertToWriteLock(s));
841 >        assertTrue(lock.validate(s));
842 >        assertTrue(lock.isWriteLocked());
843 >        lock.unlockWrite(s);
844 >
845          assertTrue((s = lock.readLock()) != 0L);
846          assertTrue(lock.validate(s));
847          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
848          assertTrue(lock.validate(p));
849 +        assertTrue(lock.isWriteLocked());
850          lock.unlockWrite(p);
851 +
852          assertTrue((s = lock.tryWriteLock()) != 0L);
853          assertTrue(lock.validate(s));
854 <        assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
855 <        assertTrue(lock.validate(p));
856 <        lock.unlockWrite(p);
854 >        assertEquals(s, lock.tryConvertToWriteLock(s));
855 >        assertTrue(lock.validate(s));
856 >        assertTrue(lock.isWriteLocked());
857 >        lock.unlockWrite(s);
858 >
859          assertTrue((s = lock.tryReadLock()) != 0L);
860          assertTrue(lock.validate(s));
861          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
862          assertTrue(lock.validate(p));
863 +        assertTrue(lock.isWriteLocked());
864          lock.unlockWrite(p);
865 +
866          assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
867          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
868          assertTrue(lock.validate(p));
869 +        assertTrue(lock.isWriteLocked());
870          lock.unlockWrite(p);
871 +
872          assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
873          assertTrue(lock.validate(s));
874          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
875          assertTrue(lock.validate(p));
876 +        assertTrue(lock.isWriteLocked());
877          lock.unlockWrite(p);
878      }
879  

Diff Legend

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