private Locks_Client NewLockClient(LockAcquisition lockAcquisition)
{
Locks_Client client = Locks.newClient();
lockAcquisition.Client = client;
return(client);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void assertThreadIsWaitingForLock(LockAcquisition lockAcquisition) throws Exception
private void AssertThreadIsWaitingForLock(LockAcquisition lockAcquisition)
{
for (int i = 0; i < 30 && !Suite.isAwaitingLockAcquisition(lockAcquisition.Executor.waitUntilWaiting()); i++)
{
LockSupport.parkNanos(MILLISECONDS.toNanos(100));
}
assertFalse("locking thread completed", lockAcquisition.Completed());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void exclusiveLockCanBeStopped() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ExclusiveLockCanBeStopped()
{
AcquireExclusiveLockInThisThread();
LockAcquisition exclusiveLockAcquisition = AcquireExclusiveLockInAnotherThread();
AssertThreadIsWaitingForLock(exclusiveLockAcquisition);
exclusiveLockAcquisition.Stop();
AssertLockAcquisitionFailed(exclusiveLockAcquisition);
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: private LockAcquisition acquireTwoLocksInAnotherThread(final boolean firstShared, final boolean secondShared, final java.util.concurrent.CountDownLatch firstLockFailed, final java.util.concurrent.CountDownLatch startSecondLock)
private LockAcquisition AcquireTwoLocksInAnotherThread(bool firstShared, bool secondShared, System.Threading.CountdownEvent firstLockFailed, System.Threading.CountdownEvent startSecondLock)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LockAcquisition lockAcquisition = new LockAcquisition();
LockAcquisition lockAcquisition = new LockAcquisition();
Future <Void> future = ThreadA.execute(state =>
{
using (Locks_Client client = NewLockClient(lockAcquisition))
{
try
{
if (firstShared)
{
client.AcquireShared(_tracer, NODE, FIRST_NODE_ID);
}
else
{
client.AcquireExclusive(_tracer, NODE, FIRST_NODE_ID);
}
fail("Transaction termination expected");
}
catch (Exception e)
{
assertThat(e, instanceOf(typeof(LockClientStoppedException)));
}
}
lockAcquisition.Client = null;
firstLockFailed.Signal();
Await(startSecondLock);
using (Locks_Client client = NewLockClient(lockAcquisition))
{
if (secondShared)
{
client.AcquireShared(_tracer, NODE, FIRST_NODE_ID);
}
else
{
client.AcquireExclusive(_tracer, NODE, FIRST_NODE_ID);
}
}
return(null);
});
lockAcquisition.SetFuture(future, ThreadA.get());
return(lockAcquisition);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void acquireExclusiveLockAfterSharedLockStoppedOtherThread() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void AcquireExclusiveLockAfterSharedLockStoppedOtherThread()
{
AcquiredLock thisThreadsExclusiveLock = AcquireExclusiveLockInThisThread();
LockAcquisition sharedLockAcquisition = AcquireSharedLockInAnotherThread();
AssertThreadIsWaitingForLock(sharedLockAcquisition);
sharedLockAcquisition.Stop();
AssertLockAcquisitionFailed(sharedLockAcquisition);
thisThreadsExclusiveLock.Release();
LockAcquisition exclusiveLockAcquisition = AcquireExclusiveLockInAnotherThread();
AssertLockAcquisitionSucceeded(exclusiveLockAcquisition);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void assertLockAcquisitionSucceeded(LockAcquisition lockAcquisition) throws Exception
private void AssertLockAcquisitionSucceeded(LockAcquisition lockAcquisition)
{
bool completed = false;
for (int i = 0; i < 30; i++)
{
try
{
assertNull(lockAcquisition.Result());
completed = true;
}
catch (TimeoutException)
{
}
}
assertTrue("lock was not acquired in time", completed);
assertTrue("locking thread seem to be still in progress", lockAcquisition.Completed());
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void acquireLockAfterOtherLockStoppedSameThread(boolean firstLockShared, boolean secondLockShared) throws Exception
private void AcquireLockAfterOtherLockStoppedSameThread(bool firstLockShared, bool secondLockShared)
{
AcquiredLock thisThreadsExclusiveLock = AcquireExclusiveLockInThisThread();
System.Threading.CountdownEvent firstLockFailed = new System.Threading.CountdownEvent(1);
System.Threading.CountdownEvent startSecondLock = new System.Threading.CountdownEvent(1);
LockAcquisition lockAcquisition = AcquireTwoLocksInAnotherThread(firstLockShared, secondLockShared, firstLockFailed, startSecondLock);
AssertThreadIsWaitingForLock(lockAcquisition);
lockAcquisition.Stop();
Await(firstLockFailed);
thisThreadsExclusiveLock.Release();
startSecondLock.Signal();
AssertLockAcquisitionSucceeded(lockAcquisition);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void closeClientAfterLockStopped(boolean shared) throws Exception
private void CloseClientAfterLockStopped(bool shared)
{
AcquiredLock thisThreadsExclusiveLock = AcquireExclusiveLockInThisThread();
System.Threading.CountdownEvent firstLockAcquired = new System.Threading.CountdownEvent(1);
LockAcquisition acquisition = TryAcquireTwoLocksLockInAnotherThread(shared, firstLockAcquired);
Await(firstLockAcquired);
AssertThreadIsWaitingForLock(acquisition);
AssertLocksHeld(FIRST_NODE_ID, SECOND_NODE_ID);
acquisition.Stop();
AssertLockAcquisitionFailed(acquisition);
AssertLocksHeld(FIRST_NODE_ID);
thisThreadsExclusiveLock.Release();
AssertNoLocksHeld();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void acquireExclusiveLockWhileHoldingSharedLockCanBeStopped() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void AcquireExclusiveLockWhileHoldingSharedLockCanBeStopped()
{
AcquiredLock thisThreadsSharedLock = AcquireSharedLockInThisThread();
System.Threading.CountdownEvent sharedLockAcquired = new System.Threading.CountdownEvent(1);
System.Threading.CountdownEvent startExclusiveLock = new System.Threading.CountdownEvent(1);
LockAcquisition acquisition = AcquireSharedAndExclusiveLocksInAnotherThread(sharedLockAcquired, startExclusiveLock);
Await(sharedLockAcquired);
startExclusiveLock.Signal();
AssertThreadIsWaitingForLock(acquisition);
acquisition.Stop();
AssertLockAcquisitionFailed(acquisition);
thisThreadsSharedLock.Release();
AssertNoLocksHeld();
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void assertLockAcquisitionFailed(LockAcquisition lockAcquisition) throws Exception
private void AssertLockAcquisitionFailed(LockAcquisition lockAcquisition)
{
ExecutionException executionException = null;
for (int i = 0; i < 30; i++)
{
try
{
lockAcquisition.Result();
fail("Transaction termination expected");
}
catch (ExecutionException e)
{
executionException = e;
}
catch (TimeoutException)
{
}
}
assertNotNull("execution should fail", executionException);
assertThat(executionException.InnerException, instanceOf(typeof(LockClientStoppedException)));
assertTrue("locking thread seem to be still in progress", lockAcquisition.Completed());
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: private LockAcquisition tryAcquireTwoLocksLockInAnotherThread(final boolean shared, final java.util.concurrent.CountDownLatch firstLockAcquired)
private LockAcquisition TryAcquireTwoLocksLockInAnotherThread(bool shared, System.Threading.CountdownEvent firstLockAcquired)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LockAcquisition lockAcquisition = new LockAcquisition();
LockAcquisition lockAcquisition = new LockAcquisition();
Future <Void> future = ThreadA.execute(state =>
{
using (Locks_Client client = NewLockClient(lockAcquisition))
{
if (shared)
{
client.AcquireShared(_tracer, NODE, SECOND_NODE_ID);
}
else
{
client.AcquireExclusive(_tracer, NODE, SECOND_NODE_ID);
}
firstLockAcquired.Signal();
if (shared)
{
client.AcquireShared(_tracer, NODE, FIRST_NODE_ID);
}
else
{
client.AcquireExclusive(_tracer, NODE, FIRST_NODE_ID);
}
}
return(null);
});
lockAcquisition.SetFuture(future, ThreadA.get());
return(lockAcquisition);
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: private LockAcquisition acquireSharedAndExclusiveLocksInAnotherThread(final java.util.concurrent.CountDownLatch sharedLockAcquired, final java.util.concurrent.CountDownLatch startExclusiveLock)
private LockAcquisition AcquireSharedAndExclusiveLocksInAnotherThread(System.Threading.CountdownEvent sharedLockAcquired, System.Threading.CountdownEvent startExclusiveLock)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LockAcquisition lockAcquisition = new LockAcquisition();
LockAcquisition lockAcquisition = new LockAcquisition();
Future <Void> future = ThreadA.execute(state =>
{
using (Locks_Client client = NewLockClient(lockAcquisition))
{
client.AcquireShared(_tracer, NODE, FIRST_NODE_ID);
sharedLockAcquired.Signal();
Await(startExclusiveLock);
client.AcquireExclusive(_tracer, NODE, FIRST_NODE_ID);
}
return(null);
});
lockAcquisition.SetFuture(future, ThreadA.get());
return(lockAcquisition);
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: private LockAcquisition acquireLockInAnotherThread(final boolean shared)
private LockAcquisition AcquireLockInAnotherThread(bool shared)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LockAcquisition lockAcquisition = new LockAcquisition();
LockAcquisition lockAcquisition = new LockAcquisition();
Future <Void> future = ThreadA.execute(state =>
{
Locks_Client client = NewLockClient(lockAcquisition);
if (shared)
{
client.AcquireShared(_tracer, NODE, FIRST_NODE_ID);
}
else
{
client.AcquireExclusive(_tracer, NODE, FIRST_NODE_ID);
}
return(null);
});
lockAcquisition.SetFuture(future, ThreadA.get());
return(lockAcquisition);
}
