//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(expected = IllegalStateException.class) public void shouldNotDropWhileCreating() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldNotDropWhileCreating() { // GIVEN //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.test.DoubleLatch latch = new org.neo4j.test.DoubleLatch(); DoubleLatch latch = new DoubleLatch(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final IndexProxy inner = new IndexProxyAdapter() IndexProxy inner = new IndexProxyAdapterAnonymousInnerClass2(this, latch); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final IndexProxy outer = newContractCheckingIndexProxy(inner); IndexProxy outer = NewContractCheckingIndexProxy(inner); // WHEN RunInSeparateThread(outer.start); try { latch.WaitForAllToStart(); outer.Drop(); } finally { latch.Finish(); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldNotStartOtherSamplingWhenSamplingAllTheIndexes() public virtual void ShouldNotStartOtherSamplingWhenSamplingAllTheIndexes() { // given //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.atomic.AtomicInteger totalCount = new java.util.concurrent.atomic.AtomicInteger(0); AtomicInteger totalCount = new AtomicInteger(0); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.atomic.AtomicInteger concurrentCount = new java.util.concurrent.atomic.AtomicInteger(0); AtomicInteger concurrentCount = new AtomicInteger(0); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.test.DoubleLatch jobLatch = new org.neo4j.test.DoubleLatch(); DoubleLatch jobLatch = new DoubleLatch(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.test.DoubleLatch testLatch = new org.neo4j.test.DoubleLatch(); DoubleLatch testLatch = new DoubleLatch(); IndexSamplingJobFactory jobFactory = (_indexId, proxy) => { if (!concurrentCount.compareAndSet(0, 1)) { throw new System.InvalidOperationException("count !== 0 on create"); } totalCount.incrementAndGet(); jobLatch.WaitForAllToStart(); testLatch.StartAndWaitForAllToStart(); jobLatch.WaitForAllToFinish(); concurrentCount.decrementAndGet(); testLatch.Finish(); return(null); }; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final IndexSamplingController controller = new IndexSamplingController(samplingConfig, jobFactory, jobQueue, tracker, snapshotProvider, scheduler, always(true)); IndexSamplingController controller = new IndexSamplingController(_samplingConfig, jobFactory, _jobQueue, _tracker, _snapshotProvider, _scheduler, Always(true)); when(_tracker.canExecuteMoreSamplingJobs()).thenReturn(true); when(_indexProxy.State).thenReturn(ONLINE); // when running once (new Thread(RunController(controller, TRIGGER_REBUILD_UPDATED))).Start(); jobLatch.StartAndWaitForAllToStart(); testLatch.WaitForAllToStart(); // then blocking on first job assertEquals(1, concurrentCount.get()); // when running a second time controller.SampleIndexes(BACKGROUND_REBUILD_UPDATED); // then no concurrent job execution jobLatch.Finish(); testLatch.WaitForAllToFinish(); // and finally exactly one job has run to completion assertEquals(0, concurrentCount.get()); assertEquals(1, totalCount.get()); }
// Timeout as fallback safety if test deadlocks //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(timeout = 60_000) public void shouldWaitOnStopUntilTheRunningCheckpointIsDone() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldWaitOnStopUntilTheRunningCheckpointIsDone() { // given //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.atomic.AtomicReference<Throwable> ex = new java.util.concurrent.atomic.AtomicReference<>(); AtomicReference <Exception> ex = new AtomicReference <Exception>(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.atomic.AtomicBoolean stoppedCompleted = new java.util.concurrent.atomic.AtomicBoolean(); AtomicBoolean stoppedCompleted = new AtomicBoolean(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.test.DoubleLatch checkPointerLatch = new org.neo4j.test.DoubleLatch(1); DoubleLatch checkPointerLatch = new DoubleLatch(1); OtherThreadExecutor <Void> otherThreadExecutor = new OtherThreadExecutor <Void>("scheduler stopper", null); CheckPointer checkPointer = new CheckPointerAnonymousInnerClass(this, checkPointerLatch); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final CheckPointScheduler scheduler = new CheckPointScheduler(checkPointer, ioLimiter, jobScheduler, 20L, health); CheckPointScheduler scheduler = new CheckPointScheduler(checkPointer, _ioLimiter, _jobScheduler, 20L, _health); // when scheduler.Start(); Thread runCheckPointer = new Thread(_jobScheduler.runJob); runCheckPointer.Start(); checkPointerLatch.WaitForAllToStart(); otherThreadExecutor.ExecuteDontWait((OtherThreadExecutor.WorkerCommand <Void, Void>)state => { try { scheduler.Stop(); stoppedCompleted.set(true); } catch (Exception throwable) { ex.set(throwable); } return(null); }); otherThreadExecutor.WaitUntilWaiting(details => details.isAt(typeof(CheckPointScheduler), "waitOngoingCheckpointCompletion")); // then assertFalse(stoppedCompleted.get()); checkPointerLatch.Finish(); runCheckPointer.Join(); while (!stoppedCompleted.get()) { Thread.Sleep(1); } otherThreadExecutor.Dispose(); assertNull(ex.get()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldNotAcceptMoreJobsThanAllowed() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldNotAcceptMoreJobsThanAllowed() { // given when(_config.jobLimit()).thenReturn(1); JobScheduler jobScheduler = createInitialisedScheduler(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final IndexSamplingJobTracker jobTracker = new IndexSamplingJobTracker(config, jobScheduler); IndexSamplingJobTracker jobTracker = new IndexSamplingJobTracker(_config, jobScheduler); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.test.DoubleLatch latch = new org.neo4j.test.DoubleLatch(); DoubleLatch latch = new DoubleLatch(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.test.DoubleLatch waitingLatch = new org.neo4j.test.DoubleLatch(); DoubleLatch waitingLatch = new DoubleLatch(); // when assertTrue(jobTracker.CanExecuteMoreSamplingJobs()); jobTracker.ScheduleSamplingJob(new IndexSamplingJobAnonymousInnerClass2(this, latch)); // then latch.WaitForAllToStart(); assertFalse(jobTracker.CanExecuteMoreSamplingJobs()); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.atomic.AtomicBoolean waiting = new java.util.concurrent.atomic.AtomicBoolean(false); AtomicBoolean waiting = new AtomicBoolean(false); (new Thread(() => { waiting.set(true); waitingLatch.StartAndWaitForAllToStart(); jobTracker.WaitUntilCanExecuteMoreSamplingJobs(); waiting.set(false); waitingLatch.Finish(); })).Start(); waitingLatch.WaitForAllToStart(); assertTrue(waiting.get()); latch.Finish(); waitingLatch.WaitForAllToFinish(); assertFalse(waiting.get()); // eventually we accept new jobs while (!jobTracker.CanExecuteMoreSamplingJobs()) { Thread.yield(); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldThrowSpecificExceptionOnConcurrentTransactionAccess() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldThrowSpecificExceptionOnConcurrentTransactionAccess() { // given TransactionRegistry registry = new TransactionHandleRegistry(mock(typeof(Clock)), 0, NullLogProvider.Instance); TransitionalPeriodTransactionMessContainer kernel = mock(typeof(TransitionalPeriodTransactionMessContainer)); GraphDatabaseQueryService queryService = mock(typeof(GraphDatabaseQueryService)); TransitionalTxManagementKernelTransaction kernelTransaction = mock(typeof(TransitionalTxManagementKernelTransaction)); when(kernel.NewTransaction(any(typeof(KernelTransaction.Type)), any(typeof(LoginContext)), anyLong())).thenReturn(kernelTransaction); TransactionFacade actions = new TransactionFacade(kernel, null, queryService, registry, NullLogProvider.Instance); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final TransactionHandle transactionHandle = actions.newTransactionHandle(new DisgustingUriScheme(), true, org.neo4j.internal.kernel.api.security.LoginContext.AUTH_DISABLED, -1); TransactionHandle transactionHandle = actions.NewTransactionHandle(new DisgustingUriScheme(), true, LoginContext.AUTH_DISABLED, -1); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.test.DoubleLatch latch = new org.neo4j.test.DoubleLatch(); DoubleLatch latch = new DoubleLatch(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final StatementDeserializer statements = mock(StatementDeserializer.class); StatementDeserializer statements = mock(typeof(StatementDeserializer)); //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: when(statements.HasNext()).thenAnswer(invocation => { latch.StartAndWaitForAllToStartAndFinish(); return(false); }); (new Thread(() => { // start and block until finish transactionHandle.Execute(statements, mock(typeof(ExecutionResultSerializer)), mock(typeof(HttpServletRequest))); })).Start(); latch.WaitForAllToStart(); try { // when actions.FindTransactionHandle(DisgustingUriScheme.ParseTxId(transactionHandle.Uri())); fail("should have thrown exception"); } catch (InvalidConcurrentTransactionAccess) { // then we get here } finally { latch.Finish(); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(timeout = 5000) public void shouldWaitOnStopUntilTheRunningCheckpointIsDone() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldWaitOnStopUntilTheRunningCheckpointIsDone() { // given //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.atomic.AtomicReference<Throwable> ex = new java.util.concurrent.atomic.AtomicReference<>(); AtomicReference <Exception> ex = new AtomicReference <Exception>(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.test.DoubleLatch checkPointerLatch = new org.neo4j.test.DoubleLatch(1); DoubleLatch checkPointerLatch = new DoubleLatch(1); RaftLogPruner logPruner = new RaftLogPrunerAnonymousInnerClass(this, Clock.systemUTC(), checkPointerLatch); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final PruningScheduler scheduler = new PruningScheduler(logPruner, jobScheduler, 20L, org.neo4j.logging.NullLogProvider.getInstance()); PruningScheduler scheduler = new PruningScheduler(logPruner, _jobScheduler, 20L, NullLogProvider.Instance); // when scheduler.Start(); Thread runCheckPointer = new Thread(_jobScheduler.runJob); runCheckPointer.Start(); checkPointerLatch.WaitForAllToStart(); Thread stopper = new Thread(() => { try { scheduler.Stop(); } catch (Exception throwable) { ex.set(throwable); } }); stopper.Start(); checkPointerLatch.Finish(); runCheckPointer.Join(); stopper.Join(); assertNull(ex.get()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldAllowTerminatingFromADifferentThread() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldAllowTerminatingFromADifferentThread() { // GIVEN //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.test.DoubleLatch latch = new org.neo4j.test.DoubleLatch(1); DoubleLatch latch = new DoubleLatch(1); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.kernel.api.KernelTransaction transaction = newTransaction(loginContext()); KernelTransaction transaction = NewTransaction(LoginContext()); TransactionInitializer.accept(transaction); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.concurrent.Future<?> terminationFuture = java.util.concurrent.Executors.newSingleThreadExecutor().submit(() -> Future <object> terminationFuture = Executors.newSingleThreadExecutor().submit(() => { latch.WaitForAllToStart(); transaction.MarkForTermination(Status.General.UnknownError); latch.Finish(); }); // WHEN transaction.Success(); latch.StartAndWaitForAllToStartAndFinish(); assertNull(terminationFuture.get(1, TimeUnit.MINUTES)); try { transaction.Close(); fail("Exception expected"); } catch (Exception e) { assertThat(e, instanceOf(typeof(TransactionTerminatedException))); } // THEN verify(TransactionMonitor, times(1)).transactionFinished(false, IsWriteTx); verify(TransactionMonitor, times(1)).transactionTerminated(IsWriteTx); VerifyExtraInteractionWithTheMonitor(TransactionMonitor, IsWriteTx); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(timeout = 10_000) public void shouldBlockUniqueIndexSeekFromCompetingTransaction() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldBlockUniqueIndexSeekFromCompetingTransaction() { // This is the interleaving that we are trying to verify works correctly: // ---------------------------------------------------------------------- // Thread1 (main) : Thread2 // create unique node : // lookup(node) : // open start latch -----> // | : lookup(node) // wait for T2 to block : | // : *block* // commit ---------------> *unblock* // wait for T2 end latch : | // : finish transaction // : open end latch // *unblock* <-------------‘ // assert that we complete before timeout //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.test.DoubleLatch latch = new org.neo4j.test.DoubleLatch(); DoubleLatch latch = new DoubleLatch(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.internal.kernel.api.IndexReference index = createUniquenessConstraint(labelId, propertyId1); IndexReference index = CreateUniquenessConstraint(_labelId, _propertyId1); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.values.storable.Value value = org.neo4j.values.storable.Values.of("value"); Value value = Values.of("value"); Write write = DataWriteInNewTransaction(); long nodeId = write.NodeCreate(); write.NodeAddLabel(nodeId, _labelId); // This adds the node to the unique index and should take an index write lock write.NodeSetProperty(nodeId, _propertyId1, value); ThreadStart runnableForThread2 = () => { latch.WaitForAllToStart(); try { using (Transaction tx = Kernel.beginTransaction(Transaction.Type.@implicit, LoginContext.AUTH_DISABLED)) { tx.dataRead().lockingNodeUniqueIndexSeek(index, exact(_propertyId1, value)); tx.success(); } } catch (KernelException e) { throw new Exception(e); } finally { latch.Finish(); } }; Thread thread2 = new Thread(runnableForThread2, "Transaction Thread 2"); thread2.Start(); latch.StartAndWaitForAllToStart(); while ((thread2.State != Thread.State.TIMED_WAITING) && (thread2.State != Thread.State.WAITING)) { Thread.yield(); } Commit(); latch.WaitForAllToFinish(); }