//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldDisposeTransactionsWhenAsked() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldDisposeTransactionsWhenAsked()
{
// Given
KernelTransactions transactions = NewKernelTransactions();
transactions.DisposeAll();
KernelTransaction first = GetKernelTransaction(transactions);
KernelTransaction second = GetKernelTransaction(transactions);
KernelTransaction leftOpen = GetKernelTransaction(transactions);
first.Close();
second.Close();
// When
transactions.DisposeAll();
// Then
KernelTransaction postDispose = GetKernelTransaction(transactions);
assertThat(postDispose, not(equalTo(first)));
assertThat(postDispose, not(equalTo(second)));
assertNotNull(leftOpen.ReasonIfTerminated);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(timeout = TEST_TIMEOUT) public void unblockNewTransactionsFromWrongThreadThrows() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void UnblockNewTransactionsFromWrongThreadThrows()
{
KernelTransactions kernelTransactions = NewKernelTransactions();
kernelTransactions.BlockNewTransactions();
Future <KernelTransaction> txOpener = T2.execute(state => kernelTransactions.NewInstance(@explicit, AnonymousContext.write(), 0L));
T2.get().waitUntilWaiting(location => location.isAt(typeof(KernelTransactions), "newInstance"));
AssertNotDone(txOpener);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.concurrent.Future<?> wrongUnblocker = unblockTxsInSeparateThread(kernelTransactions);
Future <object> wrongUnblocker = UnblockTxsInSeparateThread(kernelTransactions);
try
{
wrongUnblocker.get();
}
catch (Exception e)
{
assertThat(e, instanceOf(typeof(ExecutionException)));
assertThat(e.InnerException, instanceOf(typeof(System.InvalidOperationException)));
}
AssertNotDone(txOpener);
kernelTransactions.UnblockNewTransactions();
assertNotNull(txOpener.get());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @BeforeEach void setUp()
internal virtual void SetUp()
{
_kernelTransactions = mock(typeof(KernelTransactions));
_fakeClock = Clocks.fakeClock();
_logProvider = new AssertableLogProvider();
_logService = new SimpleLogService(_logProvider, _logProvider);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldTellWhenTransactionsFromSnapshotHaveBeenClosed() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldTellWhenTransactionsFromSnapshotHaveBeenClosed()
{
// GIVEN
KernelTransactions transactions = NewKernelTransactions();
KernelTransaction a = GetKernelTransaction(transactions);
KernelTransaction b = GetKernelTransaction(transactions);
KernelTransaction c = GetKernelTransaction(transactions);
KernelTransactionsSnapshot snapshot = transactions.Get();
assertFalse(snapshot.AllClosed());
// WHEN a gets closed
a.Close();
assertFalse(snapshot.AllClosed());
// WHEN c gets closed and (test knowing too much) that instance getting reused in another transaction "d".
c.Close();
KernelTransaction d = GetKernelTransaction(transactions);
assertFalse(snapshot.AllClosed());
// WHEN b finally gets closed
b.Close();
assertTrue(snapshot.AllClosed());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void startNewTransactionOnRestartedKErnelTransactions() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void StartNewTransactionOnRestartedKErnelTransactions()
{
KernelTransactions kernelTransactions = NewKernelTransactions();
kernelTransactions.Stop();
kernelTransactions.Start();
assertNotNull("New transaction created by restarted kernel transactions component.", kernelTransactions.NewInstance(KernelTransaction.Type.@explicit, AUTH_DISABLED, 0L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void exceptionWhenStartingNewTransactionOnShutdownInstance() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ExceptionWhenStartingNewTransactionOnShutdownInstance()
{
KernelTransactions kernelTransactions = NewKernelTransactions();
_databaseAvailabilityGuard.shutdown();
ExpectedException.expect(typeof(DatabaseShutdownException));
kernelTransactions.NewInstance(KernelTransaction.Type.@explicit, AUTH_DISABLED, 0L);
}
public KernelImpl( KernelTransactions transactionFactory, TransactionHooks hooks, DatabaseHealth health, TransactionMonitor transactionMonitor, Procedures procedures, Config config )
{
this._transactions = transactionFactory;
this._hooks = hooks;
this._health = health;
this._transactionMonitor = transactionMonitor;
this._procedures = procedures;
this._config = config;
}
private static void StopKernelTransactions(KernelTransactions kernelTransactions)
{
try
{
kernelTransactions.Stop();
}
catch (Exception t)
{
throw new Exception(t);
}
}
private static void StartAndCloseTransaction(KernelTransactions kernelTransactions)
{
try
{
kernelTransactions.NewInstance(KernelTransaction.Type.@explicit, AUTH_DISABLED, 0L).close();
}
catch (TransactionFailureException e)
{
throw new Exception(e);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotLeakTransactionOnSecurityContextFreezeFailure() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldNotLeakTransactionOnSecurityContextFreezeFailure()
{
KernelTransactions kernelTransactions = NewKernelTransactions();
LoginContext loginContext = mock(typeof(LoginContext));
when(loginContext.Authorize(any(), any())).thenThrow(new AuthorizationExpiredException("Freeze failed."));
assertException(() => kernelTransactions.NewInstance(KernelTransaction.Type.@explicit, loginContext, 0L), typeof(AuthorizationExpiredException), "Freeze failed.");
assertThat("We should not have any transaction", kernelTransactions.ActiveTransactions(), @is(empty()));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void exceptionWhenStartingNewTransactionOnStoppedKernelTransactions() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ExceptionWhenStartingNewTransactionOnStoppedKernelTransactions()
{
KernelTransactions kernelTransactions = NewKernelTransactions();
T2.execute((OtherThreadExecutor.WorkerCommand <Void, Void>)state =>
{
StopKernelTransactions(kernelTransactions);
return(null);
}).get();
ExpectedException.expect(typeof(System.InvalidOperationException));
kernelTransactions.NewInstance(KernelTransaction.Type.@explicit, AUTH_DISABLED, 0L);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldReuseClosedTransactionObjects() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldReuseClosedTransactionObjects()
{
// GIVEN
KernelTransactions transactions = NewKernelTransactions();
KernelTransaction a = GetKernelTransaction(transactions);
// WHEN
a.Close();
KernelTransaction b = GetKernelTransaction(transactions);
// THEN
assertSame(a, b);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void transactionCloseRemovesTxFromActiveTransactions() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void TransactionCloseRemovesTxFromActiveTransactions()
{
KernelTransactions kernelTransactions = NewTestKernelTransactions();
KernelTransaction tx1 = GetKernelTransaction(kernelTransactions);
KernelTransaction tx2 = GetKernelTransaction(kernelTransactions);
KernelTransaction tx3 = GetKernelTransaction(kernelTransactions);
tx1.Close();
tx3.Close();
assertEquals(asSet(NewHandle(tx2)), kernelTransactions.ActiveTransactions());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void disposeAllMarksAllTransactionsForTermination() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void DisposeAllMarksAllTransactionsForTermination()
{
KernelTransactions kernelTransactions = NewKernelTransactions();
KernelTransaction tx1 = GetKernelTransaction(kernelTransactions);
KernelTransaction tx2 = GetKernelTransaction(kernelTransactions);
KernelTransaction tx3 = GetKernelTransaction(kernelTransactions);
kernelTransactions.DisposeAll();
assertEquals(Org.Neo4j.Kernel.Api.Exceptions.Status_General.DatabaseUnavailable, tx1.ReasonIfTerminated.get());
assertEquals(Org.Neo4j.Kernel.Api.Exceptions.Status_General.DatabaseUnavailable, tx2.ReasonIfTerminated.get());
assertEquals(Org.Neo4j.Kernel.Api.Exceptions.Status_General.DatabaseUnavailable, tx3.ReasonIfTerminated.get());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldListActiveTransactions() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldListActiveTransactions()
{
// Given
KernelTransactions transactions = NewTestKernelTransactions();
// When
KernelTransaction first = GetKernelTransaction(transactions);
KernelTransaction second = GetKernelTransaction(transactions);
KernelTransaction third = GetKernelTransaction(transactions);
first.Close();
// Then
assertThat(transactions.ActiveTransactions(), equalTo(asSet(NewHandle(second), NewHandle(third))));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(timeout = TEST_TIMEOUT) public void blockNewTransactions() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void BlockNewTransactions()
{
KernelTransactions kernelTransactions = NewKernelTransactions();
kernelTransactions.BlockNewTransactions();
Future <KernelTransaction> txOpener = T2.execute(state => kernelTransactions.NewInstance(@explicit, AnonymousContext.write(), 0L));
T2.get().waitUntilWaiting(location => location.isAt(typeof(KernelTransactions), "newInstance"));
AssertNotDone(txOpener);
kernelTransactions.UnblockNewTransactions();
assertNotNull(txOpener.get());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void threadThatBlocksNewTxsCantStartNewTxs() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ThreadThatBlocksNewTxsCantStartNewTxs()
{
KernelTransactions kernelTransactions = NewKernelTransactions();
kernelTransactions.BlockNewTransactions();
try
{
kernelTransactions.NewInstance(KernelTransaction.Type.@implicit, AnonymousContext.write(), 0L);
fail("Exception expected");
}
catch (Exception e)
{
assertThat(e, instanceOf(typeof(System.InvalidOperationException)));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void incrementalUserTransactionId() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void IncrementalUserTransactionId()
{
KernelTransactions kernelTransactions = NewKernelTransactions();
using (KernelTransaction kernelTransaction = kernelTransactions.NewInstance(KernelTransaction.Type.@explicit, AnonymousContext.none(), 0L))
{
assertEquals(1, kernelTransactions.ActiveTransactions().GetEnumerator().next().UserTransactionId);
}
using (KernelTransaction kernelTransaction = kernelTransactions.NewInstance(KernelTransaction.Type.@explicit, AnonymousContext.none(), 0L))
{
assertEquals(2, kernelTransactions.ActiveTransactions().GetEnumerator().next().UserTransactionId);
}
using (KernelTransaction kernelTransaction = kernelTransactions.NewInstance(KernelTransaction.Type.@explicit, AnonymousContext.none(), 0L))
{
assertEquals(3, kernelTransactions.ActiveTransactions().GetEnumerator().next().UserTransactionId);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void transactionClosesUnderlyingStoreReaderWhenDisposed() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void TransactionClosesUnderlyingStoreReaderWhenDisposed()
{
StorageReader storeStatement1 = mock(typeof(StorageReader));
StorageReader storeStatement2 = mock(typeof(StorageReader));
StorageReader storeStatement3 = mock(typeof(StorageReader));
KernelTransactions kernelTransactions = newKernelTransactions(mock(typeof(TransactionCommitProcess)), storeStatement1, storeStatement2, storeStatement3);
// start and close 3 transactions from different threads
StartAndCloseTransaction(kernelTransactions);
Executors.newSingleThreadExecutor().submit(() => startAndCloseTransaction(kernelTransactions)).get();
Executors.newSingleThreadExecutor().submit(() => startAndCloseTransaction(kernelTransactions)).get();
kernelTransactions.DisposeAll();
verify(storeStatement1).close();
verify(storeStatement2).close();
verify(storeStatement3).close();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldIncludeRandomBytesInAdditionalHeader() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldIncludeRandomBytesInAdditionalHeader()
{
// Given
TransactionRepresentation[] transactionRepresentation = new TransactionRepresentation[1];
KernelTransactions registry = NewKernelTransactions(NewRememberingCommitProcess(transactionRepresentation));
// When
using (KernelTransaction transaction = GetKernelTransaction(registry))
{
// Just pick anything that can flag that changes have been made to this transaction
(( KernelTransactionImplementation )transaction).TxState().nodeDoCreate(0);
transaction.Success();
}
// Then
sbyte[] additionalHeader = transactionRepresentation[0].AdditionalHeader();
assertNotNull(additionalHeader);
assertTrue(additionalHeader.Length > 0);
}
internal KernelTransactionImplementationFactory(KernelTransactions outerInstance, ISet <KernelTransactionImplementation> transactions)
{
this._outerInstance = outerInstance;
this.Transactions = transactions;
}
private static KernelTransaction GetKernelTransaction(KernelTransactions transactions)
{
return(transactions.NewInstance(KernelTransaction.Type.@implicit, AnonymousContext.none(), 0L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldBeAbleToSnapshotDuringHeavyLoad() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldBeAbleToSnapshotDuringHeavyLoad()
{
// GIVEN
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final KernelTransactions transactions = newKernelTransactions();
KernelTransactions transactions = NewKernelTransactions();
Race race = new Race();
const int threads = 50;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicBoolean end = new java.util.concurrent.atomic.AtomicBoolean();
AtomicBoolean end = new AtomicBoolean();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicReferenceArray<KernelTransactionsSnapshot> snapshots = new java.util.concurrent.atomic.AtomicReferenceArray<>(threads);
AtomicReferenceArray <KernelTransactionsSnapshot> snapshots = new AtomicReferenceArray <KernelTransactionsSnapshot>(threads);
// Representing "transaction" threads
for (int i = 0; i < threads; i++)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int threadIndex = i;
int threadIndex = i;
race.AddContestant(() =>
{
ThreadLocalRandom random = ThreadLocalRandom.current();
while (!end.get())
{
try
{
using (KernelTransaction transaction = GetKernelTransaction(transactions))
{
KernelTransactionsSnapshot snapshot = null;
try
{
parkNanos(MILLISECONDS.toNanos(random.Next(3)));
if (snapshots.get(threadIndex) == null)
{
requireNonNull(transactions, "transactions is null");
snapshot = requireNonNull(transactions.Get(), "transactions.get() returned null");
snapshots.set(threadIndex, snapshot);
parkNanos(MILLISECONDS.toNanos(random.Next(3)));
}
}
catch (Exception e)
{
StringBuilder sb = (new StringBuilder("Gotcha!\n")).Append("threadIndex=").Append(threadIndex).Append('\n').Append("transaction=").Append(transaction).Append('\n').Append("snapshots=").Append(snapshots).Append('\n').Append("snapshot=").Append(snapshot).Append('\n').Append("end=").Append(end);
throw new Exception(sb.ToString(), e);
}
}
}
catch (TransactionFailureException e)
{
throw new Exception(e);
}
}
});
}
// Just checks snapshots
race.AddContestant(() =>
{
ThreadLocalRandom random = ThreadLocalRandom.current();
int snapshotsLeft = 1_000;
while (snapshotsLeft > 0)
{
int threadIndex = random.Next(threads);
KernelTransactionsSnapshot snapshot = snapshots.get(threadIndex);
if (snapshot != null && snapshot.AllClosed())
{
snapshotsLeft--;
snapshots.set(threadIndex, null);
}
}
// End condition of this test can be described as:
// when 1000 snapshots have been seen as closed.
// setting this boolean to true will have all other threads end as well so that race.go() will end
end.set(true);
});
// WHEN
race.Go();
}
//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 static java.util.concurrent.Future<?> unblockTxsInSeparateThread(final KernelTransactions kernelTransactions)
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
private static Future <object> UnblockTxsInSeparateThread(KernelTransactions kernelTransactions)
{
return(Executors.newSingleThreadExecutor().submit(kernelTransactions.unblockNewTransactions));
}
