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.21 by jsr166, Tue Jun 7 22:10:33 2016 UTC vs.
Revision 1.25 by jsr166, Sun Jul 17 02:30:53 2016 UTC

# Line 5 | Line 5
5   * http://creativecommons.org/publicdomain/zero/1.0/
6   */
7  
8 + import static java.util.concurrent.TimeUnit.DAYS;
9   import static java.util.concurrent.TimeUnit.MILLISECONDS;
10  
11 + import java.util.ArrayList;
12 + import java.util.List;
13   import java.util.concurrent.CountDownLatch;
14 + import java.util.concurrent.TimeUnit;
15   import java.util.concurrent.locks.Lock;
16   import java.util.concurrent.locks.StampedLock;
17 + import java.util.function.BiConsumer;
18 + import java.util.function.Consumer;
19 + import java.util.function.Function;
20  
21   import junit.framework.Test;
22   import junit.framework.TestSuite;
# Line 766 | Line 773 | public class StampedLockTest extends JSR
773      public void testTryConvertToReadLock() throws InterruptedException {
774          StampedLock lock = new StampedLock();
775          long s, p;
776 <        s = 0L;
777 <        assertFalse((p = lock.tryConvertToReadLock(s)) != 0L);
776 >
777 >        assertFalse((p = lock.tryConvertToReadLock(0L)) != 0L);
778 >
779 >        assertTrue((s = lock.tryOptimisticRead()) != 0L);
780 >        assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
781 >        assertTrue(lock.isReadLocked());
782 >        assertEquals(1, lock.getReadLockCount());
783 >        lock.unlockRead(p);
784 >
785          assertTrue((s = lock.tryOptimisticRead()) != 0L);
786 +        lock.readLock();
787          assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
788 +        assertTrue(lock.isReadLocked());
789 +        assertEquals(2, lock.getReadLockCount());
790 +        lock.unlockRead(p);
791          lock.unlockRead(p);
792 +
793          assertTrue((s = lock.writeLock()) != 0L);
794          assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
795          assertTrue(lock.validate(p));
796 +        assertTrue(lock.isReadLocked());
797 +        assertEquals(1, lock.getReadLockCount());
798          lock.unlockRead(p);
799 +
800          assertTrue((s = lock.readLock()) != 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()) != 0L);
809          assertTrue(lock.validate(s));
810          assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
811          assertTrue(lock.validate(p));
812 +        assertEquals(1, lock.getReadLockCount());
813          lock.unlockRead(p);
814 +
815          assertTrue((s = lock.tryReadLock()) != 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          assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
824          assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
825          assertTrue(lock.validate(p));
826 +        assertTrue(lock.isReadLocked());
827 +        assertEquals(1, lock.getReadLockCount());
828          lock.unlockRead(p);
829 +
830          assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
831          assertTrue(lock.validate(s));
832 <        assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
833 <        assertTrue(lock.validate(p));
834 <        lock.unlockRead(p);
832 >        assertEquals(s, lock.tryConvertToReadLock(s));
833 >        assertTrue(lock.validate(s));
834 >        assertTrue(lock.isReadLocked());
835 >        assertEquals(1, lock.getReadLockCount());
836 >        lock.unlockRead(s);
837      }
838  
839      /**
# Line 813 | Line 848 | public class StampedLockTest extends JSR
848  
849          assertTrue((s = lock.tryOptimisticRead()) != 0L);
850          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
851 +        assertTrue(lock.isWriteLocked());
852          lock.unlockWrite(p);
853  
854          assertTrue((s = lock.writeLock()) != 0L);
855          assertEquals(s, lock.tryConvertToWriteLock(s));
856          assertTrue(lock.validate(s));
857 +        assertTrue(lock.isWriteLocked());
858          lock.unlockWrite(s);
859  
860          assertTrue((s = lock.readLock()) != 0L);
861          assertTrue(lock.validate(s));
862          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
863          assertTrue(lock.validate(p));
864 +        assertTrue(lock.isWriteLocked());
865          lock.unlockWrite(p);
866  
867          assertTrue((s = lock.tryWriteLock()) != 0L);
868          assertTrue(lock.validate(s));
869          assertEquals(s, lock.tryConvertToWriteLock(s));
870          assertTrue(lock.validate(s));
871 +        assertTrue(lock.isWriteLocked());
872          lock.unlockWrite(s);
873  
874          assertTrue((s = lock.tryReadLock()) != 0L);
875          assertTrue(lock.validate(s));
876          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
877          assertTrue(lock.validate(p));
878 +        assertTrue(lock.isWriteLocked());
879          lock.unlockWrite(p);
880  
881          assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
882          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
883          assertTrue(lock.validate(p));
884 +        assertTrue(lock.isWriteLocked());
885          lock.unlockWrite(p);
886  
887          assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
888          assertTrue(lock.validate(s));
889          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
890          assertTrue(lock.validate(p));
891 +        assertTrue(lock.isWriteLocked());
892          lock.unlockWrite(p);
893      }
894  
# Line 1016 | Line 1058 | public class StampedLockTest extends JSR
1058          assertThrows(IllegalMonitorStateException.class, actions);
1059      }
1060  
1061 +    static long writeLockInterruptiblyUninterrupted(StampedLock sl) {
1062 +        try { return sl.writeLockInterruptibly(); }
1063 +        catch (InterruptedException ex) { throw new AssertionError(ex); }
1064 +    }
1065 +
1066 +    static long tryWriteLockUninterrupted(StampedLock sl, long time, TimeUnit unit) {
1067 +        try { return sl.tryWriteLock(time, unit); }
1068 +        catch (InterruptedException ex) { throw new AssertionError(ex); }
1069 +    }
1070 +
1071 +    /**
1072 +     * Invalid write stamps result in IllegalMonitorStateException
1073 +     */
1074 +    public void testInvalidWriteStampsThrowIllegalMonitorStateException() {
1075 +        List<Function<StampedLock, Long>> writeLockers = new ArrayList<>();
1076 +        writeLockers.add((sl) -> sl.writeLock());
1077 +        writeLockers.add((sl) -> writeLockInterruptiblyUninterrupted(sl));
1078 +        writeLockers.add((sl) -> tryWriteLockUninterrupted(sl, Long.MIN_VALUE, DAYS));
1079 +        writeLockers.add((sl) -> tryWriteLockUninterrupted(sl, 0, DAYS));
1080 +
1081 +        List<Consumer<StampedLock>> mutaters = new ArrayList<>();
1082 +        mutaters.add((sl) -> {});
1083 +        mutaters.add((sl) -> sl.readLock());
1084 +        for (Function<StampedLock, Long> writeLocker : writeLockers)
1085 +            mutaters.add((sl) -> writeLocker.apply(sl));
1086 +
1087 +        List<BiConsumer<StampedLock, Long>> writeUnlockers = new ArrayList<>();
1088 +        writeUnlockers.add((sl, stamp) -> sl.unlockWrite(stamp));
1089 +        writeUnlockers.add((sl, stamp) -> assertTrue(sl.tryUnlockWrite()));
1090 +        writeUnlockers.add((sl, stamp) -> sl.asWriteLock().unlock());
1091 +        writeUnlockers.add((sl, stamp) -> sl.unlock(stamp));
1092 +
1093 +        for (Function<StampedLock, Long> writeLocker : writeLockers)
1094 +        for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers)
1095 +        for (Consumer<StampedLock> mutater : mutaters) {
1096 +            StampedLock sl = new StampedLock();
1097 +            long stamp = writeLocker.apply(sl);
1098 +            assertTrue(stamp != 0L);
1099 +            assertThrows(IllegalMonitorStateException.class,
1100 +                         () -> sl.unlockRead(stamp));
1101 +            writeUnlocker.accept(sl, stamp);
1102 +            mutater.accept(sl);
1103 +            assertThrows(IllegalMonitorStateException.class,
1104 +                         () -> sl.unlock(stamp),
1105 +                         () -> sl.unlockRead(stamp),
1106 +                         () -> sl.unlockWrite(stamp));
1107 +        }
1108 +    }
1109 +
1110   }

Diff Legend

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