@Override public boolean trySharedLock( ResourceType resourceType, long resourceId ) { return localClient.trySharedLock( resourceType, resourceId ); }
@Override public boolean trySharedLock( ResourceType resourceType, long resourceId ) { return localClient.trySharedLock( resourceType, resourceId ); }
@Test public void releaseMultipleExclusiveLocksWhileHavingSomeSharedLocks() { clientA.acquireShared( LockTracer.NONE, NODE, 100, 1000, 10000 ); clientA.acquireExclusive( LockTracer.NONE, NODE, 10, 100, 1000 ); assertFalse( clientB.trySharedLock( NODE, 10 ) ); assertFalse( clientB.trySharedLock( NODE, 100 ) ); assertFalse( clientB.trySharedLock( NODE, 1000 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 10000 ) ); assertEquals( 4, lockCount() ); clientA.releaseExclusive( NODE, 100, 1000 ); assertFalse( clientB.trySharedLock( NODE, 10 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 100 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 1000 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 10000 ) ); assertEquals( 4, lockCount() ); }
@Test public void releaseExclusiveLocksAcquiredSeparately() { clientA.acquireExclusive( LockTracer.NONE, NODE, 1 ); clientA.acquireExclusive( LockTracer.NONE, NODE, 2 ); clientA.acquireExclusive( LockTracer.NONE, NODE, 3 ); assertEquals( 3, lockCount() ); assertFalse( clientB.trySharedLock( NODE, 1 ) ); assertFalse( clientB.trySharedLock( NODE, 2 ) ); assertFalse( clientB.trySharedLock( NODE, 3 ) ); clientA.releaseExclusive( NODE, 1, 2, 3 ); assertEquals( 0, lockCount() ); assertTrue( clientB.trySharedLock( NODE, 1 ) ); assertTrue( clientB.trySharedLock( NODE, 2 ) ); assertTrue( clientB.trySharedLock( NODE, 3 ) ); }
@Test public void releaseMultipleSharedLocksWhileHavingSomeExclusiveLocks() { clientA.acquireExclusive( LockTracer.NONE, NODE, 10, 100, 1000 ); clientA.acquireShared( LockTracer.NONE, NODE, 100, 1000, 10000 ); assertFalse( clientB.trySharedLock( NODE, 10 ) ); assertFalse( clientB.trySharedLock( NODE, 100 ) ); assertFalse( clientB.trySharedLock( NODE, 1000 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 10000 ) ); assertEquals( 4, lockCount() ); clientA.releaseShared( NODE, 100, 1000 ); assertFalse( clientB.trySharedLock( NODE, 10 ) ); assertFalse( clientB.trySharedLock( NODE, 100 ) ); assertFalse( clientB.trySharedLock( NODE, 1000 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 10000 ) ); assertEquals( 4, lockCount() ); }
@Test public void releaseMultipleExclusiveLocks() { clientA.acquireExclusive( LockTracer.NONE, NODE, 10, 100, 1000 ); assertFalse( clientB.trySharedLock( NODE, 10 ) ); assertFalse( clientB.trySharedLock( NODE, 100 ) ); assertFalse( clientB.trySharedLock( NODE, 1000 ) ); assertEquals( 3, lockCount() ); clientA.releaseExclusive( NODE, 10, 100 ); assertEquals( 1, lockCount() ); assertTrue( clientB.trySharedLock( NODE, 10 ) ); assertTrue( clientB.trySharedLock( NODE, 100 ) ); assertFalse( clientB.trySharedLock( NODE, 1000 ) ); }
@Test public void releaseMultipleAlreadyAcquiredExclusiveLocks() { clientA.acquireExclusive( LockTracer.NONE, NODE, 10, 100, 1000 ); clientA.acquireExclusive( LockTracer.NONE, NODE, 100, 1000, 10000 ); clientA.releaseExclusive( NODE, 100, 1000 ); assertEquals( 4, lockCount() ); assertFalse( clientB.trySharedLock( NODE, 10 ) ); assertFalse( clientB.trySharedLock( NODE, 100 ) ); assertFalse( clientB.trySharedLock( NODE, 1000 ) ); assertFalse( clientB.trySharedLock( NODE, 10000 ) ); clientA.releaseExclusive( NODE, 100, 1000 ); assertEquals( 2, lockCount() ); }
@Test public void shouldAcquireMultipleAlreadyAcquiredExclusiveLocks() { clientA.acquireExclusive( LockTracer.NONE, NODE, 10, 100, 1000 ); clientA.acquireExclusive( LockTracer.NONE, NODE, 100, 1000, 10000 ); assertFalse( clientB.trySharedLock( NODE, 10 ) ); assertFalse( clientB.trySharedLock( NODE, 100 ) ); assertFalse( clientB.trySharedLock( NODE, 1000 ) ); assertFalse( clientB.trySharedLock( NODE, 10000 ) ); assertEquals( 4, lockCount() ); }
@Test public void shouldTryExclusiveLock() { // Given I've grabbed an exclusive lock assertTrue( clientA.tryExclusiveLock( NODE, 1L ) ); // Then other clients can't have exclusive locks assertFalse( clientB.tryExclusiveLock( NODE, 1L ) ); // Nor can they have share locks assertFalse( clientB.trySharedLock( NODE, 1L ) ); }
@Test public void shouldTrySharedLock() { // Given I've grabbed a share lock assertTrue( clientA.trySharedLock( NODE, 1L ) ); // Then other clients can't have exclusive locks assertFalse( clientB.tryExclusiveLock( NODE, 1L ) ); // But they are allowed share locks assertTrue( clientB.trySharedLock( NODE, 1L ) ); }
@Test public void shouldAcquireMultipleExclusiveLocks() { clientA.acquireExclusive( LockTracer.NONE, NODE, 10, 100, 1000 ); assertFalse( clientB.trySharedLock( NODE, 10 ) ); assertFalse( clientB.trySharedLock( NODE, 100 ) ); assertFalse( clientB.trySharedLock( NODE, 1000 ) ); assertEquals( 3, lockCount() ); }
@Test( expected = LockClientStoppedException.class ) public void shouldNotBeAbleToTryAcquireSharedLockFromClosedClient() { clientA.close(); clientA.trySharedLock( NODE, 1L ); }
@Test public void shouldAcquireMultipleSharedLocksWhileHavingSomeExclusiveLocks() { clientA.acquireExclusive( LockTracer.NONE, NODE, 10, 100, 1000 ); clientA.acquireShared( LockTracer.NONE, NODE, 100, 1000, 10000 ); assertFalse( clientB.trySharedLock( NODE, 10 ) ); assertFalse( clientB.trySharedLock( NODE, 100 ) ); assertFalse( clientB.trySharedLock( NODE, 1000 ) ); assertFalse( clientB.tryExclusiveLock( NODE, 10000 ) ); assertEquals( 4, lockCount() ); }
@Test( expected = LockClientStoppedException.class ) public void trySharedLockThrowsWhenClientStopped() { stoppedClient().trySharedLock( NODE, 1 ); }
@Test public void releaseTryLocksOnClose() { assertTrue( clientA.trySharedLock( ResourceTypes.NODE, 1L ) ); assertTrue( clientB.tryExclusiveLock( ResourceTypes.NODE, 2L ) ); clientA.close(); clientB.close(); LockCountVisitor lockCountVisitor = new LockCountVisitor(); locks.accept( lockCountVisitor ); assertEquals( 0, lockCountVisitor.getLockCount() ); } }
@Test public void shouldTryUpgradeSharedToExclusive() { // Given I've grabbed an exclusive lock assertTrue( clientA.trySharedLock( NODE, 1L ) ); // Then I can upgrade it to exclusive assertTrue( clientA.tryExclusiveLock( NODE, 1L ) ); // And other clients are denied it assertFalse( clientB.trySharedLock( NODE, 1L ) ); }