//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldUpgradeExclusiveOnTry() public virtual void ShouldUpgradeExclusiveOnTry() { // Given I've grabbed a shared lock ClientA.acquireShared(LockTracer.NONE, NODE, 1L); // When assertTrue(ClientA.tryExclusiveLock(NODE, 1L)); // Then I should be able to release it ClientA.releaseExclusive(NODE, 1L); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void sharedShouldWaitForExclusive() public virtual void SharedShouldWaitForExclusive() { // When ClientA.acquireExclusive(LockTracer.NONE, NODE, 1L); // Then shared locks should wait Future <object> clientBLock = AcquireShared(ClientB, LockTracer.NONE, NODE, 1L).callAndAssertWaiting(); // And when ClientA.releaseExclusive(NODE, 1L); // Then this should not block AssertNotWaiting(ClientB, clientBLock); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldReleaseExclusiveLocksAcquiredInABatch() public virtual void ShouldReleaseExclusiveLocksAcquiredInABatch() { ClientA.acquireExclusive(LockTracer.NONE, NODE, 1, 10, 100); assertEquals(3, LockCount()); ClientA.releaseExclusive(NODE, 1); assertEquals(2, LockCount()); ClientA.releaseExclusive(NODE, 10); assertEquals(1, LockCount()); ClientA.releaseExclusive(NODE, 100); assertEquals(0, LockCount()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void releaseMultipleExclusiveLocks() public virtual 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)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldTraceWaitTimeWhenTryingToAcquireSharedLockAndExclusiveIsHeld() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldTraceWaitTimeWhenTryingToAcquireSharedLockAndExclusiveIsHeld() { // given Tracer tracerA = new Tracer(); Tracer tracerB = new Tracer(); ClientA.acquireExclusive(tracerA, NODE, 17); // when Future <object> future = AcquireShared(ClientB, tracerB, NODE, 17).callAndAssertWaiting(); // then ClientA.releaseExclusive(NODE, 17); future.get(); tracerA.AssertCalls(0); tracerB.AssertCalls(1); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void releaseExclusiveLocksAcquiredSeparately() public virtual 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)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldRetainSharedLockWhenAcquiredAfterExclusiveLock() public virtual void ShouldRetainSharedLockWhenAcquiredAfterExclusiveLock() { // When ClientA.acquireExclusive(LockTracer.NONE, NODE, 1L); ClientA.acquireShared(LockTracer.NONE, NODE, 1L); // Then this should wait Future <object> clientBLock = AcquireExclusive(ClientB, LockTracer.NONE, NODE, 1L).callAndAssertWaiting(); // And when ClientA.releaseExclusive(NODE, 1L); // Then other thread should still wait AssertWaiting(ClientB, clientBLock); // But when ClientA.releaseShared(NODE, 1L); // Then AssertNotWaiting(ClientB, clientBLock); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldAcquireExclusiveIfClientIsOnlyOneHoldingShared() public virtual void ShouldAcquireExclusiveIfClientIsOnlyOneHoldingShared() { // When ClientA.acquireShared(LockTracer.NONE, NODE, 1L); ClientA.acquireExclusive(LockTracer.NONE, NODE, 1L); // Then shared locks should wait Future <object> clientBLock = AcquireExclusive(ClientB, LockTracer.NONE, NODE, 1L).callAndAssertWaiting(); // And when ClientA.releaseExclusive(NODE, 1L); // Then other thread should still wait AssertWaiting(ClientB, clientBLock); // But when ClientA.releaseShared(NODE, 1L); // Then AssertNotWaiting(ClientB, clientBLock); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void exclusiveLocksShouldBeReentrantAndBlockOtherSharedLocks() public virtual void ExclusiveLocksShouldBeReentrantAndBlockOtherSharedLocks() { // When ClientA.acquireExclusive(LockTracer.NONE, NODE, 1L); ClientA.acquireShared(LockTracer.NONE, NODE, 1L); ClientA.tryExclusiveLock(NODE, 1L); // Then exclusive locks should wait Future <object> clientBLock = AcquireShared(ClientB, LockTracer.NONE, NODE, 1L).callAndAssertWaiting(); // And when ClientA.releaseExclusive(NODE, 1L); ClientA.releaseShared(NODE, 1L); // Then other thread should still wait AssertWaiting(ClientB, clientBLock); // But when ClientA.releaseExclusive(NODE, 1L); // Then AssertNotWaiting(ClientB, clientBLock); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testSingleThread() public virtual void TestSingleThread() { try { ClientA.releaseExclusive(NODE, 1L); fail("Invalid release should throw exception"); } catch (Exception) { // good } try { ClientA.releaseShared(NODE, 1L); fail("Invalid release should throw exception"); } catch (Exception) { // good } ClientA.acquireShared(LockTracer.NONE, NODE, 1L); try { ClientA.releaseExclusive(NODE, 1L); fail("Invalid release should throw exception"); } catch (Exception) { // good } ClientA.releaseShared(NODE, 1L); ClientA.acquireExclusive(LockTracer.NONE, NODE, 1L); try { ClientA.releaseShared(NODE, 1L); fail("Invalid release should throw exception"); } catch (Exception) { // good } ClientA.releaseExclusive(NODE, 1L); ClientA.acquireShared(LockTracer.NONE, NODE, 1L); ClientA.acquireExclusive(LockTracer.NONE, NODE, 1L); ClientA.releaseExclusive(NODE, 1L); ClientA.releaseShared(NODE, 1L); ClientA.acquireExclusive(LockTracer.NONE, NODE, 1L); ClientA.acquireShared(LockTracer.NONE, NODE, 1L); ClientA.releaseShared(NODE, 1L); ClientA.releaseExclusive(NODE, 1L); for (int i = 0; i < 10; i++) { if ((i % 2) == 0) { ClientA.acquireExclusive(LockTracer.NONE, NODE, 1L); } else { ClientA.acquireShared(LockTracer.NONE, NODE, 1L); } } for (int i = 9; i >= 0; i--) { if ((i % 2) == 0) { ClientA.releaseExclusive(NODE, 1L); } else { ClientA.releaseShared(NODE, 1L); } } }