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.11 by jsr166, Fri Feb 27 21:43:18 2015 UTC vs.
Revision 1.23 by jsr166, Tue Jun 7 22:21:05 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 285 | Line 285 | public class StampedLockTest extends JSR
285                  running.countDown();
286                  lock.writeLockInterruptibly();
287              }});
288 <        
288 >
289          running.await();
290          waitForThreadToEnterWaitState(t, 100);
291          t.interrupt();
# Line 305 | Line 305 | public class StampedLockTest extends JSR
305                  running.countDown();
306                  lock.tryWriteLock(2 * LONG_DELAY_MS, MILLISECONDS);
307              }});
308 <        
308 >
309          running.await();
310          waitForThreadToEnterWaitState(t, 100);
311          t.interrupt();
# Line 326 | Line 326 | public class StampedLockTest extends JSR
326                  running.countDown();
327                  lock.readLockInterruptibly();
328              }});
329 <        
329 >
330          running.await();
331          waitForThreadToEnterWaitState(t, 100);
332          t.interrupt();
# Line 346 | Line 346 | public class StampedLockTest extends JSR
346                  running.countDown();
347                  lock.tryReadLock(2 * LONG_DELAY_MS, MILLISECONDS);
348              }});
349 <        
349 >
350          running.await();
351          waitForThreadToEnterWaitState(t, 100);
352          t.interrupt();
# Line 378 | 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 394 | 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 416 | 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 434 | Line 434 | public class StampedLockTest extends JSR
434                  long s = lock.writeLock();
435                  lock.unlockWrite(s);
436              }});
437 <        
437 >
438          running.await();
439          waitForThreadToEnterWaitState(t, 100);
440          assertFalse(lock.isWriteLocked());
# Line 454 | Line 454 | public class StampedLockTest extends JSR
454                  long rs = lock.readLock();
455                  lock.unlockRead(rs);
456              }});
457 <        
457 >
458          awaitTermination(t1);
459  
460          Thread t2 = newStartedThread(new CheckedRunnable() {
# Line 462 | Line 462 | public class StampedLockTest extends JSR
462                  long ws = lock.writeLock();
463                  lock.unlockWrite(ws);
464              }});
465 <        
465 >
466          assertFalse(lock.isWriteLocked());
467          lock.unlockRead(s);
468          awaitTermination(t2);
# Line 599 | Line 599 | public class StampedLockTest extends JSR
599                  running.countDown();
600                  lock.readLockInterruptibly();
601              }});
602 <        
602 >
603          running.await();
604          waitForThreadToEnterWaitState(t, 100);
605          t.interrupt();
# Line 704 | Line 704 | public class StampedLockTest extends JSR
704                  running.countDown();
705                  lock.writeLockInterruptibly();
706              }});
707 <        
707 >
708          running.await();
709          assertFalse(lock.validate(p));
710          assertFalse((p = lock.tryOptimisticRead()) != 0L);
# 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 753 | 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 795 | 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  
# Line 876 | Line 923 | public class StampedLockTest extends JSR
923          assertTrue(lock.tryLock());
924      }
925  
926 +    /**
927 +     * Lock.newCondition throws UnsupportedOperationException
928 +     */
929 +    public void testLockViewsDoNotSupportConditions() {
930 +        StampedLock sl = new StampedLock();
931 +        assertThrows(UnsupportedOperationException.class,
932 +                     () -> sl.asWriteLock().newCondition(),
933 +                     () -> sl.asReadLock().newCondition(),
934 +                     () -> sl.asReadWriteLock().writeLock().newCondition(),
935 +                     () -> sl.asReadWriteLock().readLock().newCondition());
936 +    }
937 +
938 +    /**
939 +     * Passing optimistic read stamps to unlock operations result in
940 +     * IllegalMonitorStateException
941 +     */
942 +    public void testCannotUnlockOptimisticReadStamps() {
943 +        Runnable[] actions = {
944 +            () -> {
945 +                StampedLock sl = new StampedLock();
946 +                long stamp = sl.tryOptimisticRead();
947 +                assertTrue(stamp != 0);
948 +                sl.unlockRead(stamp);
949 +            },
950 +            () -> {
951 +                StampedLock sl = new StampedLock();
952 +                long stamp = sl.tryOptimisticRead();
953 +                sl.unlock(stamp);
954 +            },
955 +
956 +            () -> {
957 +                StampedLock sl = new StampedLock();
958 +                long stamp = sl.tryOptimisticRead();
959 +                sl.writeLock();
960 +                sl.unlock(stamp);
961 +            },
962 +            () -> {
963 +                StampedLock sl = new StampedLock();
964 +                long stamp = sl.tryOptimisticRead();
965 +                sl.readLock();
966 +                sl.unlockRead(stamp);
967 +            },
968 +            () -> {
969 +                StampedLock sl = new StampedLock();
970 +                long stamp = sl.tryOptimisticRead();
971 +                sl.readLock();
972 +                sl.unlock(stamp);
973 +            },
974 +
975 +            () -> {
976 +                StampedLock sl = new StampedLock();
977 +                long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
978 +                assertTrue(stamp != 0);
979 +                sl.writeLock();
980 +                sl.unlockWrite(stamp);
981 +            },
982 +            () -> {
983 +                StampedLock sl = new StampedLock();
984 +                long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
985 +                sl.writeLock();
986 +                sl.unlock(stamp);
987 +            },
988 +            () -> {
989 +                StampedLock sl = new StampedLock();
990 +                long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
991 +                sl.readLock();
992 +                sl.unlockRead(stamp);
993 +            },
994 +            () -> {
995 +                StampedLock sl = new StampedLock();
996 +                long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
997 +                sl.readLock();
998 +                sl.unlock(stamp);
999 +            },
1000 +
1001 +            () -> {
1002 +                StampedLock sl = new StampedLock();
1003 +                long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1004 +                assertTrue(stamp != 0);
1005 +                sl.writeLock();
1006 +                sl.unlockWrite(stamp);
1007 +            },
1008 +            () -> {
1009 +                StampedLock sl = new StampedLock();
1010 +                long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1011 +                sl.writeLock();
1012 +                sl.unlock(stamp);
1013 +            },
1014 +            () -> {
1015 +                StampedLock sl = new StampedLock();
1016 +                long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1017 +                sl.readLock();
1018 +                sl.unlockRead(stamp);
1019 +            },
1020 +            () -> {
1021 +                StampedLock sl = new StampedLock();
1022 +                sl.readLock();
1023 +                long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1024 +                assertTrue(stamp != 0);
1025 +                sl.readLock();
1026 +                sl.unlockRead(stamp);
1027 +            },
1028 +            () -> {
1029 +                StampedLock sl = new StampedLock();
1030 +                long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1031 +                sl.readLock();
1032 +                sl.unlock(stamp);
1033 +            },
1034 +            () -> {
1035 +                StampedLock sl = new StampedLock();
1036 +                sl.readLock();
1037 +                long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1038 +                sl.readLock();
1039 +                sl.unlock(stamp);
1040 +            },
1041 +        };
1042 +
1043 +        assertThrows(IllegalMonitorStateException.class, actions);
1044 +    }
1045 +
1046   }

Diff Legend

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