//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldAcquireMultipleExclusiveLocks() public virtual 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()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldListLocksHeldByTheCurrentClient() public virtual void ShouldListLocksHeldByTheCurrentClient() { // given ClientA.acquireExclusive(LockTracer.NONE, NODE, 1, 2, 3); ClientA.acquireShared(LockTracer.NONE, NODE, 3, 4, 5); // when //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.stream.Stream<? extends ActiveLock> locks = clientA.activeLocks(); Stream <ActiveLock> locks = ClientA.activeLocks(); // then assertEquals(new HashSet <>(asList(exclusiveLock(NODE, 1), exclusiveLock(NODE, 2), exclusiveLock(NODE, 3), sharedLock(NODE, 3), sharedLock(NODE, 4), sharedLock(NODE, 5))), locks.collect(toSet())); }
//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 mustReleaseUnpreparedLocksOnStop() public virtual void MustReleaseUnpreparedLocksOnStop() { // Given ClientA.acquireShared(_tracer, NODE, 1L); ClientA.acquireExclusive(_tracer, NODE, 2L); // When ClientA.stop(); // The client was stopped before it could enter the prepare phase, so all of its locks are released LockCountVisitor lockCountVisitor = new LockCountVisitor(); Locks.accept(lockCountVisitor); assertEquals(0, lockCountVisitor.LockCount); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void prepareMustAllowAcquiringNewLocksAfterStop() public virtual void PrepareMustAllowAcquiringNewLocksAfterStop() { // Given ClientA.prepare(); ClientA.stop(); // When ClientA.acquireShared(_tracer, NODE, 1); ClientA.acquireExclusive(_tracer, NODE, 2); // Stopped essentially has no effect when it comes after the client has entered the prepare phase LockCountVisitor lockCountVisitor = new LockCountVisitor(); Locks.accept(lockCountVisitor); assertEquals(2, lockCountVisitor.LockCount); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void mustNotReleaseLocksAfterPrepareOnStop() public virtual void MustNotReleaseLocksAfterPrepareOnStop() { // Given ClientA.acquireShared(_tracer, NODE, 1L); ClientA.acquireExclusive(_tracer, NODE, 2L); ClientA.prepare(); // When ClientA.stop(); // The client entered the prepare phase, so it gets to keep its locks LockCountVisitor lockCountVisitor = new LockCountVisitor(); Locks.accept(lockCountVisitor); assertEquals(2, lockCountVisitor.LockCount); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void releaseMultipleAlreadyAcquiredExclusiveLocks() public virtual 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()); }
//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 mustReleaseReadLockWaitersOnStop() public virtual void MustReleaseReadLockWaitersOnStop() { // Given ClientA.acquireExclusive(_tracer, NODE, 1L); ClientB.acquireExclusive(_tracer, NODE, 2L); AcquireShared(ClientB, _tracer, NODE, 1L).callAndAssertWaiting(); // When ClientB.stop(); ClientA.stop(); // All locks clients should be stopped at this point, and all all locks should be released because none of the // clients entered the prepare phase LockCountVisitor lockCountVisitor = new LockCountVisitor(); Locks.accept(lockCountVisitor); assertEquals(0, lockCountVisitor.LockCount); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void releaseMultipleExclusiveLocksWhileHavingSomeSharedLocks() public virtual 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()); }
//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(expected = LockClientStoppedException.class) public void shouldNotBeAbleToAcquireExclusiveLockFromClosedClient() public virtual void ShouldNotBeAbleToAcquireExclusiveLockFromClosedClient() { ClientA.close(); ClientA.acquireExclusive(LockTracer.NONE, NODE, 1L); }
//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); } } }