//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(timeout = 10_000) public void shouldWaitForCompletionInHalt() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldWaitForCompletionInHalt()
{
// GIVEN
PageCache pageCache = mock(typeof(PageCache));
Org.Neo4j.Test.Barrier_Control barrier = new Org.Neo4j.Test.Barrier_Control();
doAnswer(invocation =>
{
barrier.Reached();
return(null);
}).when(pageCache).flushAndForce();
PageCacheFlusher flusher = new PageCacheFlusher(pageCache);
flusher.Start();
// WHEN
barrier.Await();
Future <object> halt = T2.execute(state =>
{
flusher.Halt();
return(null);
});
T2.get().waitUntilWaiting(details => details.isAt(typeof(PageCacheFlusher), "halt"));
barrier.Release();
// THEN halt call exits normally after (confirmed) ongoing flushAndForce call completed.
halt.get();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldAwaitCompletionOfAllTasks() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
internal virtual void ShouldAwaitCompletionOfAllTasks()
{
// given
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final TaskCoordinator coordinator = new TaskCoordinator(1, java.util.concurrent.TimeUnit.MILLISECONDS);
TaskCoordinator coordinator = new TaskCoordinator(1, TimeUnit.MILLISECONDS);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicReference<String> state = new java.util.concurrent.atomic.AtomicReference<>();
AtomicReference <string> state = new AtomicReference <string>();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.List<String> states = new java.util.ArrayList<>();
IList <string> states = new List <string>();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.test.Barrier_Control phaseA = new org.neo4j.test.Barrier_Control();
Org.Neo4j.Test.Barrier_Control phaseA = new Org.Neo4j.Test.Barrier_Control();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.test.Barrier_Control phaseB = new org.neo4j.test.Barrier_Control();
Org.Neo4j.Test.Barrier_Control phaseB = new Org.Neo4j.Test.Barrier_Control();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.test.Barrier_Control phaseC = new org.neo4j.test.Barrier_Control();
Org.Neo4j.Test.Barrier_Control phaseC = new Org.Neo4j.Test.Barrier_Control();
state.set("A");
new Thread("awaitCompletion" () =>
{
try
{
states.Add(state.get()); // expects A
phaseA.Reached();
states.Add(state.get()); // expects B
phaseB.Await();
phaseB.Release();
coordinator.AwaitCompletion();
states.Add(state.get()); // expects C
phaseC.Reached();
}
catch (InterruptedException e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
});
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void givenDatabaseAndStartedTxWhenShutdownThenWaitForTxToFinish() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void GivenDatabaseAndStartedTxWhenShutdownThenWaitForTxToFinish()
{
// Given
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final GraphDatabaseService db = getTemporaryDatabase();
GraphDatabaseService db = TemporaryDatabase;
// When
Org.Neo4j.Test.Barrier_Control barrier = new Org.Neo4j.Test.Barrier_Control();
Future <object> txFuture = _t2.execute(state =>
{
using (Transaction tx = Db.beginTx())
{
barrier.Reached();
Db.createNode();
tx.Success();
}
return(null);
});
// i.e. wait for transaction to start
barrier.Await();
// now there's a transaction open, blocked on continueTxSignal
Future <object> shutdownFuture = _t3.execute(state =>
{
Db.shutdown();
return(null);
});
_t3.get().waitUntilWaiting(location => location.isAt(typeof(DatabaseAvailability), "stop"));
barrier.Release();
try
{
txFuture.get();
}
catch (ExecutionException)
{
// expected
}
shutdownFuture.get();
}
//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 org.neo4j.test.OtherThreadExecutor.WorkerCommand<Void,Void> barrierControlledReadTransaction(final org.neo4j.graphdb.GraphDatabaseService slave, final org.neo4j.test.Barrier_Control barrier)
private WorkerCommand <Void, Void> BarrierControlledReadTransaction(GraphDatabaseService slave, Org.Neo4j.Test.Barrier_Control barrier)
{
return(state =>
{
try
{
using (Transaction tx = slave.BeginTx())
{
barrier.Reached();
tx.success();
}
}
catch (Exception)
{
// This is OK, we expect this transaction to fail after role switch
}
finally
{
barrier.Release();
}
return null;
});
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void givenDatabaseAndStartedTxWhenShutdownAndStartNewTxThenBeginTxTimesOut() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void GivenDatabaseAndStartedTxWhenShutdownAndStartNewTxThenBeginTxTimesOut()
{
// Given
GraphDatabaseService db = TemporaryDatabase;
// When
Org.Neo4j.Test.Barrier_Control barrier = new Org.Neo4j.Test.Barrier_Control();
_t2.execute(state =>
{
using (Transaction tx = Db.beginTx())
{
barrier.Reached(); // <-- this triggers t3 to start a db.shutdown()
}
return(null);
});
barrier.Await();
Future <object> shutdownFuture = _t3.execute(state =>
{
Db.shutdown();
return(null);
});
_t3.get().waitUntilWaiting(location => location.isAt(typeof(DatabaseAvailability), "stop"));
barrier.Release(); // <-- this triggers t2 to continue its transaction
shutdownFuture.get();
try
{
Db.beginTx();
fail("Should fail");
}
catch (DatabaseShutdownException)
{
//THEN good
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldPropagateStoreCopyActionFailureToOtherStoreCopyRequests() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldPropagateStoreCopyActionFailureToOtherStoreCopyRequests()
{
// GIVEN
Org.Neo4j.Test.Barrier_Control barrier = new Org.Neo4j.Test.Barrier_Control();
IOException controlledFailure = new IOException("My own fault");
AtomicReference <Future <object> > secondRequest = new AtomicReference <Future <object> >();
ThrowingAction <IOException> controllableAndFailingAction = () =>
{
// Now that we know we're first, start the second request...
secondRequest.set(T3.execute(state => _mutex.storeCopy(_assertNotCalled)));
// ...and wait for it to reach its destination
barrier.AwaitUninterruptibly();
try
{
// OK, second request has made progress into the request, so we can now produce our failure
throw controlledFailure;
}
finally
{
barrier.Release();
}
};
Future <object> firstRequest = T2.execute(state => _mutex.storeCopy(controllableAndFailingAction));
while (secondRequest.get() == null)
{
ParkARandomWhile();
}
T3.get().waitUntilWaiting(details => details.isAt(typeof(StoreCopyCheckPointMutex), "waitForFirstStoreCopyActionToComplete"));
// WHEN
barrier.Reached();
// THEN
try
{
firstRequest.get();
}
catch (ExecutionException e)
{
assertSame(controlledFailure, e.InnerException);
}
try
{
secondRequest.get().get();
}
catch (ExecutionException e)
{
Exception cooperativeActionFailure = e.InnerException;
assertThat(cooperativeActionFailure.Message, containsString("Co-operative"));
assertSame(controlledFailure, cooperativeActionFailure.InnerException);
}
// WHEN afterwards trying another store-copy
CountingAction action = new CountingAction();
using (Resource @lock = _mutex.storeCopy(action))
{
// THEN
assertEquals(1, action.Count());
}
}