/// <summary> /// Awaits completion of this population job, but waits maximum the given time. /// </summary> /// <param name="time"> time to wait at the most for completion. A value of 0 means indefinite wait. </param> /// <param name="unit"> <seealso cref="TimeUnit unit"/> of the {@code time}. </param> /// <returns> {@code true} if the job is still running when leaving this method, otherwise {@code false} meaning that the job is completed. </returns> /// <exception cref="InterruptedException"> if the wait got interrupted. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public boolean awaitCompletion(long time, java.util.concurrent.TimeUnit unit) throws InterruptedException public virtual bool AwaitCompletion(long time, TimeUnit unit) { if (time == 0) { _doneSignal.await(); return(false); } bool completed = _doneSignal.await(time, unit); return(!completed); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldKeepSmallPeakAndNeverDisposeIfAcquireAndReleaseContinuously() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldKeepSmallPeakAndNeverDisposeIfAcquireAndReleaseContinuously() { // given const int poolMinSize = 1; StatefulMonitor stateMonitor = new StatefulMonitor(this); FakeClock clock = FakeClocks; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final ResourcePool<Something> pool = getResourcePool(stateMonitor, clock, poolMinSize); ResourcePool <Something> pool = GetResourcePool(stateMonitor, clock, poolMinSize); // when for (int i = 0; i < 200; i++) { IList <ResourceHolder> newOnes = AcquireFromPool(pool, 1); System.Threading.CountdownEvent release = new System.Threading.CountdownEvent(newOnes.Count); foreach (ResourceHolder newOne in newOnes) { newOne.Release(release); } release.await(); } // then assertEquals(-1, stateMonitor.CurrentPeakSize.get()); // no alarm has rung, -1 is the default assertEquals(1, stateMonitor.CreatedConflict.get()); assertEquals(0, stateMonitor.DisposedConflict.get()); // we should always be below min size, so 0 dispose calls }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldRunWithDelay() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldRunWithDelay() { // Given _life.start(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.atomic.AtomicLong runTime = new java.util.concurrent.atomic.AtomicLong(); AtomicLong runTime = new AtomicLong(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.CountDownLatch latch = new java.util.concurrent.CountDownLatch(1); System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1); long time = System.nanoTime(); _scheduler.schedule(Group.INDEX_POPULATION, () => { runTime.set(System.nanoTime()); latch.Signal(); }, 100, TimeUnit.MILLISECONDS); latch.await(); assertTrue(time + TimeUnit.MILLISECONDS.toNanos(100) <= runTime.get()); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public void await(String message, long timeout, java.util.concurrent.TimeUnit timeUnit) throws InterruptedException public virtual void Await(string message, long timeout, TimeUnit timeUnit) { if (!ReaperLatch.await(timeout, timeUnit)) { throw new System.InvalidOperationException(message); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void rotationShouldNotDeadlockOnListener() internal virtual void RotationShouldNotDeadlockOnListener() { assertTimeout(ofMillis(TEST_TIMEOUT_MILLIS), () => { string logContent = "Output file created"; AtomicReference <Exception> listenerException = new AtomicReference <Exception>(null); System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1); RotationListener listener = new RotationListenerAnonymousInnerClass(this, listenerException, latch); ExecutorService executor = Executors.newSingleThreadExecutor(); DefaultFileSystemAbstraction defaultFileSystemAbstraction = new DefaultFileSystemAbstraction(); RotatingFileOutputStreamSupplier supplier = new RotatingFileOutputStreamSupplier(defaultFileSystemAbstraction, _logFile, 0, 0, 10, executor, listener); Stream outputStream = supplier.Get(); LockingPrintWriter lockingPrintWriter = new LockingPrintWriter(this, outputStream); lockingPrintWriter.WithLock(() => { supplier.Rotate(); latch.await(); return(Void.TYPE); }); ShutDownExecutor(executor); IList <string> strings = Files.readAllLines(_logFile.toPath()); string actual = string.join("", strings); assertEquals(logContent, actual); assertNull(listenerException.get()); }); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(timeout = 3_000) public void shouldGiveUpQueueingOnStop() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldGiveUpQueueingOnStop() { // given for (int i = 1; i <= _maxBatchSize; i++) // fell the queue { _txApplier.queue(CreateTxWithId(_startTxId + i)); } // when System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1); Thread thread = new Thread(() => { latch.Signal(); try { _txApplier.queue(CreateTxWithId(_startTxId + _maxBatchSize + 1)); } catch (Exception e) { throw new Exception(e); } }); thread.Start(); latch.await(); _txApplier.stop(); // then we don't get stuck thread.Join(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldNotifyListenerWhenNewLogIsCreated() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldNotifyListenerWhenNewLogIsCreated() { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.CountDownLatch allowRotationComplete = new java.util.concurrent.CountDownLatch(1); System.Threading.CountdownEvent allowRotationComplete = new System.Threading.CountdownEvent(1); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.CountDownLatch rotationComplete = new java.util.concurrent.CountDownLatch(1); System.Threading.CountdownEvent rotationComplete = new System.Threading.CountdownEvent(1); string outputFileCreatedMessage = "Output file created"; string rotationCompleteMessage = "Rotation complete"; RotationListener rotationListener = spy(new RotationListenerAnonymousInnerClass(this, allowRotationComplete, rotationComplete, outputFileCreatedMessage, rotationCompleteMessage)); ExecutorService rotationExecutor = Executors.newSingleThreadExecutor(); try { RotatingFileOutputStreamSupplier supplier = new RotatingFileOutputStreamSupplier(_fileSystem, _logFile, 10, 0, 10, rotationExecutor, rotationListener); Write(supplier, "A string longer than 10 bytes"); Write(supplier, "A string longer than 10 bytes"); allowRotationComplete.Signal(); rotationComplete.await(1L, TimeUnit.SECONDS); verify(rotationListener).outputFileCreated(any(typeof(Stream))); verify(rotationListener).rotationCompleted(any(typeof(Stream))); } finally { ShutDownExecutor(rotationExecutor); } }
public static void AwaitLatch(System.Threading.CountdownEvent latch, bool uninterruptedWaiting) { long now = DateTimeHelper.CurrentUnixTimeMillis(); long deadline = DateTimeHelper.CurrentUnixTimeMillis() + _fiveMinutes; while (now < deadline) { try { long waitingTime = Math.Min(Math.Max(0, deadline - now), 5000L); if (latch.await(waitingTime, TimeUnit.MILLISECONDS)) { return; } else { Thread.yield(); } } catch (InterruptedException e) { Thread.interrupted(); if (!uninterruptedWaiting) { throw new Exception("Thread interrupted while waiting on latch", e); } } now = DateTimeHelper.CurrentUnixTimeMillis(); } throw new AssertionError("Latch specified waiting time elapsed."); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(timeout = 5_000) public void shouldGiveUpAddingMessagesInTheQueueIfTheHandlerHasBeenStopped() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldGiveUpAddingMessagesInTheQueueIfTheHandlerHasBeenStopped() { // given BatchingMessageHandler batchHandler = new BatchingMessageHandler(_downstreamHandler, new BoundedPriorityQueue.Config(1, 1, 1024), _batchConfig, _jobSchedulerFactory, NullLogProvider.Instance); NewEntry.Request message = new NewEntry.Request(null, new ReplicatedString("dummy")); batchHandler.Handle(Wrap(message)); // fill the queue System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1); // when Thread thread = new Thread(() => { latch.Signal(); batchHandler.Handle(Wrap(message)); }); thread.Start(); latch.await(); batchHandler.Stop(); thread.Join(); // then we are not stuck and we terminate }
// Tests that a listener is only invoked by a single thread at any time even if multiple threads are // invoking the wrapper concurrently. //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void concurrentExecution() throws InterruptedException public virtual void concurrentExecution() { int nThreads = Runtime.Runtime.availableProcessors(); int resultsPerThread = 10; ConcurrentLinkedQueue <string> errors = new ConcurrentLinkedQueue <string>(); System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1); int expectedResultCount = nThreads * resultsPerThread; Listener listener = new Listener(errors, latch); System.Action <CalculationResults> wrapper = new ListenerWrapper(listener, expectedResultCount, ImmutableList.of(), ImmutableList.of()); ExecutorService executor = Executors.newFixedThreadPool(nThreads); CalculationResult result = CalculationResult.of(0, 0, Result.failure(FailureReason.ERROR, "foo")); CalculationTarget target = new CalculationTargetAnonymousInnerClass(this); CalculationResults results = CalculationResults.of(target, ImmutableList.of(result)); IntStream.range(0, expectedResultCount).forEach(i => executor.submit(() => wrapper(results))); latch.await(); executor.shutdown(); if (!errors.Empty) { //JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter: string allErrors = errors.collect(joining("\n")); fail(allErrors); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldSendAMessageFromAClientWhichIsReceivedByAServer() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldSendAMessageFromAClientWhichIsReceivedByAServer() { // given int port1 = PortAuthority.allocatePort(); int port2 = PortAuthority.allocatePort(); System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1); LifeSupport life = new LifeSupport(); Server server1 = new Server(latch, MapUtil.stringMap(ClusterSettings.cluster_server.name(), "localhost:" + port1, ClusterSettings.server_id.name(), "1", ClusterSettings.initial_hosts.name(), "localhost:" + port1 + ",localhost:" + port2)); life.Add(server1); Server server2 = new Server(latch, MapUtil.stringMap(ClusterSettings.cluster_server.name(), "localhost:" + port2, ClusterSettings.server_id.name(), "2", ClusterSettings.initial_hosts.name(), "localhost:" + port1 + ",localhost:" + port2)); life.Add(server2); life.Start(); // when server1.Process(Message.To(TestMessage.HelloWorld, URI.create("cluster://127.0.0.1:" + port2), "Hello World")); // then assertTrue(latch.await(5, TimeUnit.SECONDS)); assertTrue("server1 should have processed the message", server1.ProcessedMessage()); assertTrue("server2 should have processed the message", server2.ProcessedMessage()); life.Shutdown(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldReturnCorrectStatusCodeOnDeadlock() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldReturnCorrectStatusCodeOnDeadlock() { // Given using (Transaction tx = Graphdb().beginTx()) { Graphdb().createNode(Label.label("First")); Graphdb().createNode(Label.label("Second")); tx.Success(); } // When I lock node:First HTTP.Response begin = _http.POST("db/data/transaction", quotedJson("{ 'statements': [ { 'statement': 'MATCH (n:First) SET n.prop=1' } ] }")); // and I lock node:Second, and wait for a lock on node:First in another transaction OtherThread.execute(WriteToFirstAndSecond()); // and I wait for those locks to be pending assertTrue(_secondNodeLocked.await(10, TimeUnit.SECONDS)); Thread.Sleep(1000); // and I then try and lock node:Second in the first transaction HTTP.Response deadlock = _http.POST(begin.Location(), quotedJson("{ 'statements': [ { 'statement': 'MATCH (n:Second) SET n.prop=1' } ] }")); // Then assertThat(deadlock.Get("errors").get(0).get("code").TextValue, equalTo(DeadlockDetected.code().serialize())); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void runSetup(java.util.concurrent.ExecutorService executorService) throws InterruptedException private void runSetup(ExecutorService executorService) { System.Threading.CountdownEvent sync = new System.Threading.CountdownEvent(configuration.SetupTasks.Length); Console.Write("Running setup ... "); foreach (ThreadStart r in configuration.SetupTasks) { executorService.execute(wrap(r, sync)); } sync.await(); if (configuration.Color) { Console.Write(ANSI_GREEN); } Console.WriteLine("Done"); if (configuration.Color) { Console.Write(ANSI_RESET); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void awaitingShutdownMustBlockUntilAllMessagesHaveBeenProcessed() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void AwaitingShutdownMustBlockUntilAllMessagesHaveBeenProcessed() { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final Event specialShutdownObservedEvent = new Event(); Event specialShutdownObservedEvent = new Event(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.CountDownLatch awaitStartLatch = new java.util.concurrent.CountDownLatch(1); System.Threading.CountdownEvent awaitStartLatch = new System.Threading.CountdownEvent(1); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final EventConsumer consumer = new EventConsumer(); EventConsumer consumer = new EventConsumer(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final AsyncEvents<Event> asyncEvents = new AsyncEvents<>(consumer, AsyncEvents.Monitor_Fields.NONE); AsyncEvents <Event> asyncEvents = new AsyncEvents <Event>(consumer, AsyncEvents.Monitor_Fields.None); _executor.submit(asyncEvents); // Wait for the background thread to start processing events do { asyncEvents.Send(new Event()); } while (consumer.EventsProcessed.take().processedBy == Thread.CurrentThread); // Start a thread that awaits the termination //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.concurrent.Future<?> awaitShutdownFuture = executor.submit(() -> Future <object> awaitShutdownFuture = _executor.submit(() => { awaitStartLatch.Signal(); asyncEvents.AwaitTermination(); consumer.EventsProcessed.offer(specialShutdownObservedEvent); }); awaitStartLatch.await(); // Send 5 events asyncEvents.Send(new Event()); asyncEvents.Send(new Event()); asyncEvents.Send(new Event()); asyncEvents.Send(new Event()); asyncEvents.Send(new Event()); // Observe 5 events processed assertThat(consumer.EventsProcessed.take(), @is(notNullValue())); assertThat(consumer.EventsProcessed.take(), @is(notNullValue())); assertThat(consumer.EventsProcessed.take(), @is(notNullValue())); assertThat(consumer.EventsProcessed.take(), @is(notNullValue())); assertThat(consumer.EventsProcessed.take(), @is(notNullValue())); // Observe no events left assertThat(consumer.EventsProcessed.poll(20, TimeUnit.MILLISECONDS), @is(nullValue())); // Shutdown and await termination asyncEvents.Shutdown(); awaitShutdownFuture.get(); // Observe termination assertThat(consumer.EventsProcessed.take(), sameInstance(specialShutdownObservedEvent)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void mustNotApplyAsyncWorkInParallelUnderStress() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void MustNotApplyAsyncWorkInParallelUnderStress() { int workers = Runtime.Runtime.availableProcessors() * 5; int iterations = 1_000; int incrementValue = 42; System.Threading.CountdownEvent startLatch = new System.Threading.CountdownEvent(workers); System.Threading.CountdownEvent endLatch = new System.Threading.CountdownEvent(workers); AtomicBoolean start = new AtomicBoolean(); Callable <Void> work = () => { startLatch.Signal(); bool spin; do { spin = !start.get(); } while (spin); ThreadLocalRandom rng = ThreadLocalRandom.current(); IList <AsyncApply> asyncs = new List <AsyncApply>(); for (int i = 0; i < iterations; i++) { asyncs.add(_sync.applyAsync(new AddWork(incrementValue))); if (rng.Next(10) == 0) { foreach (AsyncApply async in asyncs) { async.Await(); } asyncs.clear(); } } foreach (AsyncApply async in asyncs) { async.Await(); } endLatch.Signal(); return(null); }; IList <Future <Void> > futureList = new List <Future <Void> >(); for (int i = 0; i < workers; i++) { futureList.Add(_executor.submit(work)); } startLatch.await(); start.set(true); endLatch.await(); foreach (Future <Void> future in futureList) { future.get(); // check for any exceptions } assertThat(_count.sum(), lessThan((long)(workers * iterations))); assertThat(_sum.sum(), @is((long)(incrementValue * workers * iterations))); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void concurrentlyPublishedEventsMustAllBeProcessed() internal virtual void ConcurrentlyPublishedEventsMustAllBeProcessed() { assertTimeout(ofSeconds(10), () => { EventConsumer consumer = new EventConsumer(); System.Threading.CountdownEvent startLatch = new System.Threading.CountdownEvent(1); const int threads = 10; const int iterations = 2_000; AsyncEvents <Event> asyncEvents = new AsyncEvents <Event>(consumer, AsyncEvents.Monitor_Fields.None); _executor.submit(asyncEvents); ExecutorService threadPool = Executors.newFixedThreadPool(threads); ThreadStart runner = () => { try { startLatch.await(); } catch (InterruptedException e) { throw new Exception(e); } for (int i = 0; i < iterations; i++) { asyncEvents.Send(new Event()); } }; for (int i = 0; i < threads; i++) { threadPool.submit(runner); } startLatch.countDown(); Thread thisThread = Thread.CurrentThread; int eventCount = threads * iterations; try { for (int i = 0; i < eventCount; i++) { Event @event = consumer.Poll(1, TimeUnit.SECONDS); if (@event == null) { i--; } else { assertThat(@event.ProcessedBy, @is(not(thisThread))); } } } finally { asyncEvents.Shutdown(); threadPool.shutdown(); } }); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void forceCheckPointShouldWaitTheCurrentCheckPointingToCompleteBeforeRunning() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ForceCheckPointShouldWaitTheCurrentCheckPointingToCompleteBeforeRunning() { // Given Lock @lock = new ReentrantLock(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.locks.Lock spyLock = spy(lock); Lock spyLock = spy(@lock); doAnswer(invocation => { verify(_appender).checkPoint(any(typeof(LogPosition)), any(typeof(LogCheckPointEvent))); reset(_appender); invocation.callRealMethod(); return(null); }).when(spyLock).unlock(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final CheckPointerImpl checkPointing = checkPointer(mutex(spyLock)); CheckPointerImpl checkPointing = CheckPointer(Mutex(spyLock)); MockTxIdStore(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.CountDownLatch startSignal = new java.util.concurrent.CountDownLatch(2); System.Threading.CountdownEvent startSignal = new System.Threading.CountdownEvent(2); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.CountDownLatch completed = new java.util.concurrent.CountDownLatch(2); System.Threading.CountdownEvent completed = new System.Threading.CountdownEvent(2); checkPointing.Start(); Thread checkPointerThread = new CheckPointerThread(checkPointing, startSignal, completed); Thread forceCheckPointThread = new Thread(() => { try { startSignal.Signal(); startSignal.await(); checkPointing.ForceCheckPoint(_info); completed.Signal(); } catch (Exception e) { throw new Exception(e); } }); // when checkPointerThread.Start(); forceCheckPointThread.Start(); completed.await(); verify(spyLock, times(2)).@lock(); verify(spyLock, times(2)).unlock(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void terminateNestedTransactionThrowsExceptionOnNextNestedOperationMultiThreadedVersionWithNestedTx() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void TerminateNestedTransactionThrowsExceptionOnNextNestedOperationMultiThreadedVersionWithNestedTx() { // Given //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final GraphDatabaseService db = getTemporaryDatabase(); GraphDatabaseService db = TemporaryDatabase; try { // When //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.CountDownLatch txSet = new java.util.concurrent.CountDownLatch(1); System.Threading.CountdownEvent txSet = new System.Threading.CountdownEvent(1); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.CountDownLatch terminated = new java.util.concurrent.CountDownLatch(1); System.Threading.CountdownEvent terminated = new System.Threading.CountdownEvent(1); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final Transaction[] outer = {null}; Transaction[] outer = new Transaction[] { null }; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final Exception[] threadFail = {null}; Exception[] threadFail = new Exception[] { null }; Thread worker = new Thread(() => { Transaction transaction = Db.beginTx(); try { using (Transaction inner = Db.beginTx()) { outer[0] = inner; txSet.Signal(); terminated.await(); Db.createNode(); fail("should have failed earlier"); } } catch (Exception e) { threadFail[0] = e; } finally { transaction.Close(); } }); worker.Start(); txSet.await(); outer[0].Terminate(); terminated.Signal(); worker.Join(); assertThat(threadFail[0], instanceOf(typeof(TransactionTerminatedException))); } finally { Db.shutdown(); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public TYPE get() throws Exception public override TYPE Get() { Latch.await(); if (Failure != null) { throw Failure; } return(Value); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testLockCounters() throws InterruptedException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void TestLockCounters() { RagManager ragManager = new RagManager(); LockResource resource = new LockResource(ResourceTypes.NODE, 1L); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final RWLock lock = createRWLock(ragManager, resource); RWLock @lock = CreateRWLock(ragManager, resource); LockTransaction lockTransaction = new LockTransaction(); LockTransaction anotherTransaction = new LockTransaction(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final LockTransaction writeTransaction = new LockTransaction(); LockTransaction writeTransaction = new LockTransaction(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.CountDownLatch writerCompletedLatch = new java.util.concurrent.CountDownLatch(1); System.Threading.CountdownEvent writerCompletedLatch = new System.Threading.CountdownEvent(1); @lock.Mark(); @lock.AcquireReadLock(LockTracer.NONE, lockTransaction); @lock.Mark(); @lock.AcquireReadLock(LockTracer.NONE, anotherTransaction); assertEquals(2, @lock.ReadCount); assertEquals(0, @lock.WriteCount); assertEquals(2, @lock.TxLockElementCount); ThreadStart writer = CreateWriter(@lock, writeTransaction, writerCompletedLatch); _executor.submit(writer); WaitWaitingThreads(@lock, 1); // check that all reader, writes, threads counters are correct assertEquals(2, @lock.ReadCount); assertEquals(0, @lock.WriteCount); assertEquals(3, @lock.TxLockElementCount); assertEquals(1, @lock.WaitingThreadsCount); @lock.ReleaseReadLock(lockTransaction); @lock.ReleaseReadLock(anotherTransaction); writerCompletedLatch.await(); // test readers and waiting thread gone assertEquals(0, @lock.ReadCount); assertEquals(1, @lock.WriteCount); assertEquals(1, @lock.TxLockElementCount); assertEquals(0, @lock.WaitingThreadsCount); @lock.ReleaseWriteLock(writeTransaction); // check lock is clean in the end assertEquals(0, @lock.TxLockElementCount); assertEquals(0, @lock.WaitingThreadsCount); assertEquals(0, @lock.ReadCount); assertEquals(0, @lock.WriteCount); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public Void answer(org.mockito.invocation.InvocationOnMock invocation) throws Throwable public override Void Answer( InvocationOnMock invocation ) { // releasing reader after local lock released ResourceLatch.Signal(); // waiting here for reader to finish read lock acquisition. // by this we check that local exclusive lock where released before releasing it on // master otherwise reader will be blocked forever ResourceReleaseLatch.await(); return null; }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldReclaimAndRecreateWhenUsageGoesDownBetweenSpikes() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldReclaimAndRecreateWhenUsageGoesDownBetweenSpikes() { // given const int poolMinSize = 50; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int bellowPoolMinSize = poolMinSize / 5; int bellowPoolMinSize = poolMinSize / 5; const int poolMaxSize = 200; StatefulMonitor stateMonitor = new StatefulMonitor(this); FakeClock clock = FakeClocks; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final SomethingResourcePool pool = getResourcePool(stateMonitor, clock, poolMinSize); SomethingResourcePool pool = GetResourcePool(stateMonitor, clock, poolMinSize); AcquireResourcesAndExceedTimeout(pool, clock, poolMaxSize); // when // After the peak, stay well below concurrent usage, using up all already present resources in the process ExceedTimeout(clock); // Requires some rounds to happen, since there is constant racing between releasing and acquiring which does // not always result in reaping of resources, as there is reuse for (int i = 0; i < 30; i++) { // The latch is necessary to reduce races between batches System.Threading.CountdownEvent release = new System.Threading.CountdownEvent(bellowPoolMinSize); foreach (ResourceHolder holder in AcquireFromPool(pool, bellowPoolMinSize)) { holder.Release(release); } release.await(); ExceedTimeout(clock); } // then // currentPeakSize should not be higher than bellowPoolMinSize assertTrue(stateMonitor.CurrentPeakSize.get().ToString(), stateMonitor.CurrentPeakSize.get() <= bellowPoolMinSize); // target size should remain at pool min size assertEquals(poolMinSize, stateMonitor.TargetSize.get()); assertEquals(poolMinSize, pool.UnusedSize()); // only the excess from the pool max size down to min size must have been disposed // +1 that was used to trigger initial exceed timeout check assertEquals(poolMaxSize - poolMinSize + 1, stateMonitor.DisposedConflict.get()); stateMonitor.CreatedConflict.set(0); stateMonitor.DisposedConflict.set(0); // when // After the lull, recreate a peak AcquireResourcesAndExceedTimeout(pool, clock, poolMaxSize); // then assertEquals(poolMaxSize - poolMinSize + 1, stateMonitor.CreatedConflict.get()); assertEquals(0, stateMonitor.DisposedConflict.get()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(timeout = TEST_TIMEOUT_MILLIS) public void testLockRequestsTermination() throws InterruptedException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void TestLockRequestsTermination() { // given RagManager ragManager = new RagManager(); LockResource node1 = new LockResource(ResourceTypes.NODE, 1L); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final RWLock lock = createRWLock(ragManager, node1); RWLock @lock = CreateRWLock(ragManager, node1); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final LockTransaction mainTransaction = new LockTransaction(); LockTransaction mainTransaction = new LockTransaction(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final LockTransaction writerTransaction = new LockTransaction(); LockTransaction writerTransaction = new LockTransaction(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.CountDownLatch writerCompletedLatch = new java.util.concurrent.CountDownLatch(1); System.Threading.CountdownEvent writerCompletedLatch = new System.Threading.CountdownEvent(1); ThreadStart conflictingWriter = CreateFailedWriter(@lock, writerTransaction, writerCompletedLatch); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final LockTransaction readerTransaction = new LockTransaction(); LockTransaction readerTransaction = new LockTransaction(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.CountDownLatch readerCompletedLatch = new java.util.concurrent.CountDownLatch(1); System.Threading.CountdownEvent readerCompletedLatch = new System.Threading.CountdownEvent(1); ThreadStart reader = CreateFailedReader(@lock, readerTransaction, readerCompletedLatch); // when @lock.Mark(); assertTrue(@lock.AcquireWriteLock(LockTracer.NONE, mainTransaction)); _executor.submit(reader); _executor.submit(conflictingWriter); // wait waiters to come WaitWaitingThreads(@lock, 2); assertEquals(3, @lock.TxLockElementCount); // when @lock.TerminateLockRequestsForLockTransaction(readerTransaction); @lock.TerminateLockRequestsForLockTransaction(writerTransaction); readerCompletedLatch.await(); writerCompletedLatch.await(); // expect only main write lock counters and elements present // all the rest should be cleaned up assertEquals(0, @lock.WaitingThreadsCount); assertEquals(0, @lock.ReadCount); assertEquals(1, @lock.WriteCount); assertEquals(1, @lock.TxLockElementCount); }
public override void Run() { try { ExecutionLatch.await(); } catch (InterruptedException e) { throw new Exception("Interrupted while waiting for a latch", e); } }
internal virtual void AwaitStartSignal() { try { StartSignal.await(10, SECONDS); } catch (InterruptedException e) { throw new Exception(e); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void write(TestCoordinator testCoordinator, java.util.concurrent.CountDownLatch readerReadySignal, java.util.concurrent.CountDownLatch readerStartSignal, java.util.concurrent.atomic.AtomicBoolean endSignal, java.util.concurrent.atomic.AtomicBoolean failHalt) throws InterruptedException, java.io.IOException private void Write(TestCoordinator testCoordinator, System.Threading.CountdownEvent readerReadySignal, System.Threading.CountdownEvent readerStartSignal, AtomicBoolean endSignal, AtomicBoolean failHalt) { assertTrue(readerReadySignal.await(10, SECONDS)); // Ready, set... readerStartSignal.Signal(); // GO! while (!failHalt.get() && !endSignal.get()) { WriteOneIteration(testCoordinator, failHalt); testCoordinator.IterationFinished(); } }
public override void outputFileCreated(Stream @out) { try { _allowRotationComplete.await(); } catch (InterruptedException e) { throw new Exception(e); } }
private void Await(System.Threading.CountdownEvent latch) { try { assertTrue(latch.await(1, TimeUnit.MINUTES)); } catch (InterruptedException e) { throw new AssertionError(e); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(timeOut = 5000) public void interruptHangingResultsListener() throws InterruptedException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: public virtual void interruptHangingResultsListener() { HangingFunction fn = new HangingFunction(); CalculationTaskCell cell = CalculationTaskCell.of(0, 0, TestingMeasures.PRESENT_VALUE, NATURAL); CalculationTask task = CalculationTask.of(TARGET, fn, cell); Column column = Column.of(TestingMeasures.PRESENT_VALUE); CalculationTasks tasks = CalculationTasks.of(ImmutableList.of(task), ImmutableList.of(column)); ExecutorService executor = Executors.newSingleThreadExecutor(); try { CalculationTaskRunner test = CalculationTaskRunner.of(executor); MarketData marketData = MarketData.empty(VAL_DATE); AtomicBoolean shouldNeverComplete = new AtomicBoolean(); AtomicBoolean interrupted = new AtomicBoolean(); AtomicReference <Exception> thrown = new AtomicReference <Exception>(); ResultsListener listener = new ResultsListener(); test.calculateAsync(tasks, marketData, REF_DATA, listener); System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1); Thread thread = new Thread(() => { try { listener.result(); shouldNeverComplete.set(true); } catch (Exception ex) { interrupted.set(Thread.CurrentThread.Interrupted); thrown.set(ex); } latch.Signal(); }); // run the thread, wait until properly started, then interrupt, wait until properly handled thread.Start(); while (!fn.started) { } thread.Interrupt(); latch.await(); // asserts assertEquals(interrupted.get(), true); assertEquals(shouldNeverComplete.get(), false); assertEquals(thrown.get() is Exception, true); assertEquals(thrown.get().Cause is InterruptedException, true); } finally { executor.shutdownNow(); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public Action next() throws InterruptedException public virtual Action Next() { _startLatch.await(); int index = _actionCounter.AndIncrement; if (index < _plan.Length) { _executedByThread[index] = Thread.CurrentThread.Id; return(_plan[index]); } return(null); }