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.12 by jsr166, Fri Feb 27 21:54:13 2015 UTC vs.
Revision 1.21 by jsr166, Tue Jun 7 22:10:33 2016 UTC

# Line 16 | Line 16 | import junit.framework.TestSuite;
16  
17   public class StampedLockTest extends JSR166TestCase {
18      public static void main(String[] args) {
19 <        junit.textui.TestRunner.run(suite());
19 >        main(suite(), args);
20      }
21      public static Test suite() {
22          return new TestSuite(StampedLockTest.class);
# Line 166 | Line 166 | public class StampedLockTest extends JSR
166       */
167      public void testWriteUnlock_IMSE2() {
168          StampedLock lock = new StampedLock();
169 +        long s = lock.writeLock();
170 +        lock.unlockWrite(s);
171          try {
170 –            long s = lock.writeLock();
171 –            lock.unlockWrite(s);
172              lock.unlockWrite(s);
173              shouldThrow();
174          } catch (IllegalMonitorStateException success) {}
# Line 179 | Line 179 | public class StampedLockTest extends JSR
179       */
180      public void testWriteUnlock_IMSE3() {
181          StampedLock lock = new StampedLock();
182 +        long s = lock.readLock();
183          try {
183 –            long s = lock.readLock();
184              lock.unlockWrite(s);
185              shouldThrow();
186          } catch (IllegalMonitorStateException success) {}
# Line 191 | Line 191 | public class StampedLockTest extends JSR
191       */
192      public void testReadUnlock_IMSE() {
193          StampedLock lock = new StampedLock();
194 +        long s = lock.readLock();
195 +        lock.unlockRead(s);
196          try {
195 –            long s = lock.readLock();
196 –            lock.unlockRead(s);
197              lock.unlockRead(s);
198              shouldThrow();
199          } catch (IllegalMonitorStateException success) {}
# Line 215 | Line 215 | public class StampedLockTest extends JSR
215       */
216      public void testReadUnlock_IMSE3() {
217          StampedLock lock = new StampedLock();
218 +        long s = lock.writeLock();
219          try {
219 –            long s = lock.writeLock();
220              lock.unlockRead(s);
221              shouldThrow();
222          } catch (IllegalMonitorStateException success) {}
# Line 718 | Line 718 | public class StampedLockTest extends JSR
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);
721 >        assertEquals(0L, lock.tryConvertToOptimisticRead(0L));
722 >
723          assertTrue((s = lock.tryOptimisticRead()) != 0L);
724 <        assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
724 >        assertEquals(s, lock.tryConvertToOptimisticRead(s));
725 >        assertTrue(lock.validate(s));
726 >
727 >        assertTrue((p = lock.readLock()) != 0L);
728 >        assertTrue((s = lock.tryOptimisticRead()) != 0L);
729 >        assertEquals(s, lock.tryConvertToOptimisticRead(s));
730 >        assertTrue(lock.validate(s));
731 >        lock.unlockRead(p);
732 >
733          assertTrue((s = lock.writeLock()) != 0L);
734          assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
735          assertTrue(lock.validate(p));
736 +
737          assertTrue((s = lock.readLock()) != 0L);
738          assertTrue(lock.validate(s));
739          assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
740          assertTrue(lock.validate(p));
741 +
742          assertTrue((s = lock.tryWriteLock()) != 0L);
743          assertTrue(lock.validate(s));
744          assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
745          assertTrue(lock.validate(p));
746 +
747          assertTrue((s = lock.tryReadLock()) != 0L);
748          assertTrue(lock.validate(s));
749          assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
750          assertTrue(lock.validate(p));
751 +
752          assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
753          assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
754          assertTrue(lock.validate(p));
755 +
756          assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
757          assertTrue(lock.validate(s));
758          assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
# Line 795 | Line 808 | public class StampedLockTest extends JSR
808      public void testTryConvertToWriteLock() throws InterruptedException {
809          StampedLock lock = new StampedLock();
810          long s, p;
811 <        s = 0L;
812 <        assertFalse((p = lock.tryConvertToWriteLock(s)) != 0L);
811 >
812 >        assertFalse((p = lock.tryConvertToWriteLock(0L)) != 0L);
813 >
814          assertTrue((s = lock.tryOptimisticRead()) != 0L);
815          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
816          lock.unlockWrite(p);
817 +
818          assertTrue((s = lock.writeLock()) != 0L);
819 <        assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
820 <        assertTrue(lock.validate(p));
821 <        lock.unlockWrite(p);
819 >        assertEquals(s, lock.tryConvertToWriteLock(s));
820 >        assertTrue(lock.validate(s));
821 >        lock.unlockWrite(s);
822 >
823          assertTrue((s = lock.readLock()) != 0L);
824          assertTrue(lock.validate(s));
825          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
826          assertTrue(lock.validate(p));
827          lock.unlockWrite(p);
828 +
829          assertTrue((s = lock.tryWriteLock()) != 0L);
830          assertTrue(lock.validate(s));
831 <        assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
832 <        assertTrue(lock.validate(p));
833 <        lock.unlockWrite(p);
831 >        assertEquals(s, lock.tryConvertToWriteLock(s));
832 >        assertTrue(lock.validate(s));
833 >        lock.unlockWrite(s);
834 >
835          assertTrue((s = lock.tryReadLock()) != 0L);
836          assertTrue(lock.validate(s));
837          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
838          assertTrue(lock.validate(p));
839          lock.unlockWrite(p);
840 +
841          assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
842          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
843          assertTrue(lock.validate(p));
844          lock.unlockWrite(p);
845 +
846          assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
847          assertTrue(lock.validate(s));
848          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
# Line 876 | Line 896 | public class StampedLockTest extends JSR
896          assertTrue(lock.tryLock());
897      }
898  
899 +    /**
900 +     * Lock.newCondition throws UnsupportedOperationException
901 +     */
902 +    public void testLockViewsDoNotSupportConditions() {
903 +        StampedLock sl = new StampedLock();
904 +        assertThrows(UnsupportedOperationException.class,
905 +                     () -> sl.asWriteLock().newCondition(),
906 +                     () -> sl.asReadLock().newCondition(),
907 +                     () -> sl.asReadWriteLock().writeLock().newCondition(),
908 +                     () -> sl.asReadWriteLock().readLock().newCondition());
909 +    }
910 +
911 +    /**
912 +     * Passing optimistic read stamps to unlock operations result in
913 +     * IllegalMonitorStateException
914 +     */
915 +    public void testCannotUnlockOptimisticReadStamps() {
916 +        Runnable[] actions = {
917 +            () -> {
918 +                StampedLock sl = new StampedLock();
919 +                long stamp = sl.tryOptimisticRead();
920 +                assertTrue(stamp != 0);
921 +                sl.unlockRead(stamp);
922 +            },
923 +            () -> {
924 +                StampedLock sl = new StampedLock();
925 +                long stamp = sl.tryOptimisticRead();
926 +                sl.unlock(stamp);
927 +            },
928 +
929 +            () -> {
930 +                StampedLock sl = new StampedLock();
931 +                long stamp = sl.tryOptimisticRead();
932 +                sl.writeLock();
933 +                sl.unlock(stamp);
934 +            },
935 +            () -> {
936 +                StampedLock sl = new StampedLock();
937 +                long stamp = sl.tryOptimisticRead();
938 +                sl.readLock();
939 +                sl.unlockRead(stamp);
940 +            },
941 +            () -> {
942 +                StampedLock sl = new StampedLock();
943 +                long stamp = sl.tryOptimisticRead();
944 +                sl.readLock();
945 +                sl.unlock(stamp);
946 +            },
947 +
948 +            () -> {
949 +                StampedLock sl = new StampedLock();
950 +                long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
951 +                assertTrue(stamp != 0);
952 +                sl.writeLock();
953 +                sl.unlockWrite(stamp);
954 +            },
955 +            () -> {
956 +                StampedLock sl = new StampedLock();
957 +                long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
958 +                sl.writeLock();
959 +                sl.unlock(stamp);
960 +            },
961 +            () -> {
962 +                StampedLock sl = new StampedLock();
963 +                long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
964 +                sl.readLock();
965 +                sl.unlockRead(stamp);
966 +            },
967 +            () -> {
968 +                StampedLock sl = new StampedLock();
969 +                long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
970 +                sl.readLock();
971 +                sl.unlock(stamp);
972 +            },
973 +
974 +            () -> {
975 +                StampedLock sl = new StampedLock();
976 +                long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
977 +                assertTrue(stamp != 0);
978 +                sl.writeLock();
979 +                sl.unlockWrite(stamp);
980 +            },
981 +            () -> {
982 +                StampedLock sl = new StampedLock();
983 +                long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
984 +                sl.writeLock();
985 +                sl.unlock(stamp);
986 +            },
987 +            () -> {
988 +                StampedLock sl = new StampedLock();
989 +                long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
990 +                sl.readLock();
991 +                sl.unlockRead(stamp);
992 +            },
993 +            () -> {
994 +                StampedLock sl = new StampedLock();
995 +                sl.readLock();
996 +                long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
997 +                assertTrue(stamp != 0);
998 +                sl.readLock();
999 +                sl.unlockRead(stamp);
1000 +            },
1001 +            () -> {
1002 +                StampedLock sl = new StampedLock();
1003 +                long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1004 +                sl.readLock();
1005 +                sl.unlock(stamp);
1006 +            },
1007 +            () -> {
1008 +                StampedLock sl = new StampedLock();
1009 +                sl.readLock();
1010 +                long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1011 +                sl.readLock();
1012 +                sl.unlock(stamp);
1013 +            },
1014 +        };
1015 +
1016 +        assertThrows(IllegalMonitorStateException.class, actions);
1017 +    }
1018 +
1019   }

Diff Legend

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