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); }