bool DoExecute(MessageResult ctx, IObserverHandler<IMessage> handler, AtomicInteger barrier) { var e = new MessageReceivingEventArgs (ctx, handler.Target); try { ListnerManager.OnReceiving(e); if (!e.Ignored) ctx.results.Add(DelegateInvoker.Invoke<IMessage>(handler, ctx.Request.Sender, ctx.Request.ToMessage())); return true; } catch (Exception ex) { var re = new MessageExceptionEventArgs (ctx,ex); ListnerManager.OnReceivingException(re); ctx.InnerExceptions.Add(ex); return !re.Canceled; } finally { barrier--; if (barrier == 0) { ListnerManager.OnReceived(new MessageEventArgs(ctx)); ListnerManager.OnSent(e); OnCompleted(ctx); } else ListnerManager.OnReceived(new MessageEventArgs(ctx)); e = null; } }
public void AtomicInteger_Post_Decrement_AcqRel_Should_Success() { var atomicInteger = new AtomicInteger(int.MaxValue); atomicInteger--; Assert.Equal(int.MaxValue-1, atomicInteger.Value); }
public void Listener_must_listen_in() { //arrange var fooLatch = new TestLatch(sys, 2); var barLatch = new TestLatch(sys, 2); var barCount = new AtomicInteger(0); var broadcast = sys.ActorOf<BroadcastActor>(); var newListenerProps = Props.Create(() => new ListenerActor(fooLatch, barLatch, barCount)); var a1 = sys.ActorOf(newListenerProps); var a2 = sys.ActorOf(newListenerProps); var a3 = sys.ActorOf(newListenerProps); //act broadcast.Tell(new Listen(a1)); broadcast.Tell(new Listen(a2)); broadcast.Tell(new Listen(a3)); broadcast.Tell(new Deafen(a3)); broadcast.Tell(new WithListeners(a => a.Tell("foo"))); broadcast.Tell("foo"); //assert barLatch.Ready(TestLatch.DefaultTimeout); Assert.Equal(2, barCount.Value); fooLatch.Ready(TestLatch.DefaultTimeout); foreach (var actor in new[] {a1, a2, a3, broadcast}) { actor.Stop(); } }
public ListenerActor(TestLatch fooLatch, TestLatch barLatch, AtomicInteger barCount) { _fooLatch = fooLatch; _barLatch = barLatch; _barCount = barCount; Listeners = new ListenerSupport(); }
public void AtomicInteger_Pre_Increment_AcqRel_Should_Success() { var atomicInteger = new AtomicInteger(int.MaxValue-1); ++atomicInteger; Assert.Equal(int.MaxValue, atomicInteger.Value); }
public void ShouldAddToValueUsingFunction() { var atomicInt = new AtomicInteger(); const int expected = 100; atomicInt.Add(x => expected); Assert.AreEqual(expected, atomicInt.Value); }
public void AtomicInteger_IEquatable_Of_Int_Should_Compare() { IEquatable<int> firstAtomic = new AtomicInteger(int.MaxValue); IEquatable<int> secondAtomic = new AtomicInteger(int.MinValue); Assert.False(firstAtomic.Equals(int.MinValue)); Assert.False(secondAtomic.Equals(int.MaxValue)); }
public void AtomicInteger_Division_AcqRel_Should_Success() { var atomicInteger = new AtomicInteger(256); var result = atomicInteger / 2; Assert.Equal(256 / 2, result); }
public void AtomicInteger_Multiplication_AcqRel_Should_Success() { var atomicInteger = new AtomicInteger(123); var result = atomicInteger * 2; Assert.Equal(123*2, result); }
public void AtomicInteger_Subtraction_AcqRel_Should_Success() { var atomicInteger = new AtomicInteger(int.MaxValue); var result = atomicInteger - 1; Assert.Equal(int.MaxValue-1, result); }
public void AtomicInteger_Load_Should_Success() { var atomicInteger = new AtomicInteger(int.MaxValue); Assert.Equal(int.MaxValue, atomicInteger.Load(MemoryOrder.Relaxed)); Assert.Equal(int.MaxValue, atomicInteger.Load(MemoryOrder.Acquire)); Assert.Equal(int.MaxValue, atomicInteger.Load(MemoryOrder.AcqRel)); Assert.Equal(int.MaxValue, atomicInteger.Load(MemoryOrder.SeqCst)); }
public void AtomicInteger_Addition_AcqRel_Should_Success() { var atomicInteger = new AtomicInteger(int.MaxValue - 1); var result = atomicInteger+1; Assert.Equal(int.MaxValue, result); }
public void AtomicInteger_Implicit_Reassignment_Should_Change_Reference() { var firstAtomic = new AtomicInteger(int.MaxValue); var secondAtomic = firstAtomic; firstAtomic = int.MinValue; Assert.NotEqual(secondAtomic, firstAtomic); Assert.False(object.ReferenceEquals(secondAtomic, firstAtomic)); }
public void AtomicInteger_Should_Implement_Reference_Equality() { var firstAtomic = new AtomicInteger(int.MaxValue); var secondAtomic = new AtomicInteger(int.MinValue); Assert.False(firstAtomic.Equals(secondAtomic)); Assert.False(secondAtomic.Equals(firstAtomic)); // self equality Assert.True(firstAtomic.Equals(firstAtomic)); Assert.True(secondAtomic.Equals(secondAtomic)); }
public void BroadcastGroup_router_must_broadcast_message_using_Ask() { var doneLatch = new TestLatch(sys, 2); var counter1 = new AtomicInteger(0); var counter2 = new AtomicInteger(0); var actor1 = sys.ActorOf(Props.Create(() => new BroadcastTarget(doneLatch, counter1))); var actor2 = sys.ActorOf(Props.Create(() => new BroadcastTarget(doneLatch, counter2))); var routedActor = sys.ActorOf(Props.Create<TestActor>().WithRouter(new BroadcastGroup(actor1.Path.ToString(), actor2.Path.ToString()))); routedActor.Ask(new Broadcast(1)); routedActor.Tell(new Broadcast("end")); doneLatch.Ready(TimeSpan.FromSeconds(1)); counter1.Value.ShouldBe(1); counter2.Value.ShouldBe(1); }
//------------------------------------------------------------------------- public virtual void test_of_intintlambda() { assertMatrix(DoubleMatrix.of(0, 0, (i, j) => { throw new AssertionError(); })); assertMatrix(DoubleMatrix.of(0, 2, (i, j) => { throw new AssertionError(); })); assertMatrix(DoubleMatrix.of(2, 0, (i, j) => { throw new AssertionError(); })); AtomicInteger counter = new AtomicInteger(2); assertMatrix(DoubleMatrix.of(1, 2, (i, j) => counter.AndIncrement), 2d, 3d); assertMatrix(DoubleMatrix.of(2, 2, (i, j) => (i + 1) * (j + 1)), 1d, 2d, 2d, 4d); }
public void AtomicityInt() { AtomicTypeBase <int> atomic = new AtomicInteger(); void SumTask() { for (var x = 0; x < 300; x++) { atomic++; } } Task.WaitAll( Task.Factory.StartNew(SumTask), Task.Factory.StartNew(SumTask), Task.Factory.StartNew(SumTask)); Assert.That(atomic.Value, Is.EqualTo(900)); }
public void TestTlsCertsFromDynamicStreamExpiredAndRenewCert() { AtomicInteger certIndex = new AtomicInteger(1); AtomicInteger keyIndex = new AtomicInteger(0); MemoryStream certStream = CreateByteInputStream(TlsClientCertFilePath); MemoryStream keyStream = CreateByteInputStream(TlsClientKeyFilePath); Func <MemoryStream> certProvider = () => GetStream(certIndex, certStream, keyStream); Func <MemoryStream> keyProvider = () => GetStream(keyIndex, keyStream); AuthenticationTls auth = new AuthenticationTls(certProvider, keyProvider); _common.GetPulsarSystem(auth, 1000, enableTls: true, brokerService: "pulsar.BrokerServiceUrlTls"); _common.PulsarSystem.PulsarConsumer(_common.CreateConsumer(BytesSchema.Of(), "persistent://my-property/use/my-ns/my-topic1", "TestTlsCertsFromDynamicStreamExpiredAndRenewCert", "my-subscriber-name")); certIndex.SetValue(0); _common.PulsarSystem.PulsarConsumer(_common.CreateConsumer(BytesSchema.Of(), "persistent://my-property/use/my-ns/my-topic1", "TestTlsCertsFromDynamicStreamExpiredAndRenewCert", "my-subscriber-name")); }
void Dispatch(MessageResult ctx) { var handlers = Subject.Subscriber.Observers; var syncHandlers = handlers.Where(i => i.Value == SubscribeMode.Sync).Select(i => i.Key).ToArray(); var asyncHandlers = handlers.Where(i => i.Value == SubscribeMode.Async).Select(i => i.Key).ToArray(); var handlerCount = syncHandlers.Length + asyncHandlers.Length; var barrier = new AtomicInteger(handlerCount); foreach (var item in syncHandlers) { if (!DoExecute(ctx, item, barrier)) break; } Paraller.ForEach(asyncHandlers, handler => DoExecute(ctx, handler, barrier)); }
public virtual void TestMaxMergeCount() { Directory dir = NewDirectory(); IndexWriterConfig iwc = new IndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random())); int maxMergeCount = TestUtil.NextInt(Random(), 1, 5); int maxMergeThreads = TestUtil.NextInt(Random(), 1, maxMergeCount); CountdownEvent enoughMergesWaiting = new CountdownEvent(maxMergeCount); AtomicInteger runningMergeCount = new AtomicInteger(0); AtomicBoolean failed = new AtomicBoolean(); if (VERBOSE) { Console.WriteLine("TEST: maxMergeCount=" + maxMergeCount + " maxMergeThreads=" + maxMergeThreads); } ConcurrentMergeScheduler cms = new ConcurrentMergeSchedulerAnonymousInnerClassHelper(this, maxMergeCount, enoughMergesWaiting, runningMergeCount, failed); cms.SetMaxMergesAndThreads(maxMergeCount, maxMergeThreads); iwc.SetMergeScheduler(cms); iwc.SetMaxBufferedDocs(2); TieredMergePolicy tmp = new TieredMergePolicy(); iwc.SetMergePolicy(tmp); tmp.MaxMergeAtOnce = 2; tmp.SegmentsPerTier = 2; IndexWriter w = new IndexWriter(dir, iwc); Document doc = new Document(); doc.Add(NewField("field", "field", TextField.TYPE_NOT_STORED)); while (enoughMergesWaiting.CurrentCount != 0 && !failed.Get()) { for (int i = 0; i < 10; i++) { w.AddDocument(doc); } } w.Dispose(false); dir.Dispose(); }
[Test] public virtual void FairQueueUnblocksTakingThreadsInFifoOrder() { Options.SkipWhenNot(CollectionContractOptions.Fair); const int size = 3; var q = NewBlockingQueue(); var exitValue = new AtomicInteger(); var order = new AtomicInteger(1); for (int i = 1; i <= size; i++) { var index = i; ThreadManager.StartAndAssertRegistered( "T" + index, () => { while (order.Value < index) { Thread.Sleep(1); } Thread.Sleep(Delays.Short); order.IncrementValueAndReturn(); T result; Assert.IsTrue(q.Poll(Delays.Long, out result)); exitValue.Value = index; }); } while (order.Value <= size) { Thread.Sleep(1); } Thread.Sleep(Delays.Short); for (int i = 1; i <= size; i++) { Assert.IsTrue(q.Offer(TestData <T> .MakeData(i), Delays.Short)); for (int j = 0; j < 100 && exitValue.Value != i; j++) { Thread.Sleep(1); } Assert.That(exitValue.Value, Is.EqualTo(i)); } ThreadManager.JoinAndVerify(); }
public void TestDebatchByContainer() { var provider = new ServiceCollection().BuildServiceProvider(); var config = new ConfigurationBuilder().Build(); var received = new List <IMessage>(); var latch = new CountdownEvent(2); var container = new DirectMessageListenerContainer(new GenericApplicationContext(provider, config), connectionFactory); container.SetQueueNames(ROUTE); var lastInBatch = new List <bool>(); var batchSize = new AtomicInteger(); container.MessageListener = new TestDebatchListener(received, lastInBatch, batchSize, latch); container.Initialize(); container.Start(); try { var batchingStrategy = new SimpleBatchingStrategy(2, int.MaxValue, 30000); var template = new BatchingRabbitTemplate(batchingStrategy) { ConnectionFactory = connectionFactory }; var message = Message.Create(Encoding.UTF8.GetBytes("foo")); template.Send(string.Empty, ROUTE, message); message = Message.Create(Encoding.UTF8.GetBytes("bar")); template.Send(string.Empty, ROUTE, message); Assert.True(latch.Wait(TimeSpan.FromSeconds(10))); Assert.Equal(2, received.Count); Assert.Equal("foo", Encoding.UTF8.GetString((byte[])received[0].Payload)); Assert.Equal(3, received[0].Headers.ContentLength()); Assert.False(lastInBatch[0]); Assert.Equal("bar", Encoding.UTF8.GetString((byte[])received[1].Payload)); Assert.Equal(3, received[1].Headers.ContentLength()); Assert.True(lastInBatch[1]); Assert.Equal(2, batchSize.Value); } finally { container.Stop(); } }
public void TestWithChannelListener() { var mockConnectionFactory = new Mock <ConnectionFactory>(); var mockConnection = new Mock <IConnection>(); var mockChannel = new Mock <IModel>(); mockConnectionFactory.Setup(c => c.CreateConnection()).Returns(mockConnection.Object); mockConnection.Setup(m => m.IsOpen).Returns(true); mockChannel.Setup(m => m.IsOpen).Returns(true); mockConnection.Setup(m => m.CreateModel()).Returns(mockChannel.Object); var called = new AtomicInteger(0); var connectionFactory = this.CreateConnectionFactory(mockConnectionFactory.Object); var mockConnectionListener = new Mock <IConnectionListener>(); mockConnectionListener.Setup(m => m.OnCreate(It.IsAny <Rabbit.Connection.IConnection>())).Callback((Rabbit.Connection.IConnection conn) => called.IncrementValueAndReturn()); mockConnectionListener.Setup(m => m.OnClose(It.IsAny <Rabbit.Connection.IConnection>())).Callback((Rabbit.Connection.IConnection conn) => called.DecrementValueAndReturn()); connectionFactory.ConnectionListeners = new List <IConnectionListener> { mockConnectionListener.Object }; ((CachingConnectionFactory)connectionFactory).ChannelCacheSize = 1; var con = connectionFactory.CreateConnection(); var channel = con.CreateChannel(false); Assert.AreEqual(1, called.Value); channel.Close(); con.Close(); mockConnection.Verify(c => c.Close(), Times.Never()); connectionFactory.CreateConnection(); con.CreateChannel(false); Assert.AreEqual(1, called.Value); connectionFactory.Dispose(); mockConnection.Verify(c => c.Close(), Times.AtLeastOnce()); mockConnectionFactory.Verify(c => c.CreateConnection(), Times.Exactly(1)); }
public void AtomicInteger_Aligned_Value_Change_Should_Success() { var atomicInteger = new AtomicInteger(int.MaxValue, align: true); Assert.Equal(int.MaxValue, atomicInteger.Value); atomicInteger.Value = int.MinValue; Assert.Equal(int.MinValue, atomicInteger.Value); atomicInteger.Value = 0; Assert.Equal(0, atomicInteger.Value); // same value assignment atomicInteger.Value = 0; Assert.Equal(0, atomicInteger.Value); atomicInteger.Value = 123; Assert.Equal(123, atomicInteger.Value); atomicInteger.Value = 123; Assert.Equal(123, atomicInteger.Value); }
/// <exception cref="System.Exception"/> public virtual void TestShutdown() { AtomicInteger bytesRead = new AtomicInteger(0); AtomicBoolean failed = new AtomicBoolean(false); DomainSocket[] socks = DomainSocket.Socketpair(); Runnable reader = new _Runnable_737(socks, bytesRead, failed); Thread readerThread = new Thread(reader); readerThread.Start(); socks[0].GetOutputStream().Write(1); socks[0].GetOutputStream().Write(2); socks[0].GetOutputStream().Write(3); Assert.True(readerThread.IsAlive()); socks[0].Shutdown(); readerThread.Join(); NUnit.Framework.Assert.IsFalse(failed.Get()); Assert.Equal(3, bytesRead.Get()); IOUtils.Cleanup(null, socks); }
public void TestChangeListenerNotificationBatching() { const int numDocs = 50; var atomicInteger = new AtomicInteger(0); var doneSignal = new CountDownLatch(1); database.Changed += (sender, e) => atomicInteger.IncrementAndGet(); database.RunInTransaction(() => { CreateDocuments(database, numDocs); doneSignal.CountDown(); return(true); }); var success = doneSignal.Await(TimeSpan.FromSeconds(30)); Assert.IsTrue(success); Assert.AreEqual(1, atomicInteger.Get()); }
public static void execute(List <Action> callables, AtomicInteger noEstimateCounter, RunningAverageAndStdDev timing) { List <Action> list = wrapWithStatsCallables(callables, noEstimateCounter, timing); int processorCount = Environment.ProcessorCount; Task[] tasks = new Task[list.Count]; log.info("Starting timing of {} tasks in {} threads", new object[] { list.Count, processorCount }); try { for (int i = 0; i < tasks.Length; i++) { tasks[i] = Task.Factory.StartNew(list[i]); } Task.WaitAll(tasks, 0x2710); } catch (Exception exception) { throw new TasteException(exception.Message, exception); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void createdExecutorShouldExecuteSubmittedTasks() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void CreatedExecutorShouldExecuteSubmittedTasks() { AtomicBoolean exitCondition = new AtomicBoolean(false); AtomicInteger threadCounter = new AtomicInteger(0); _executorService = _factory.create(0, 1, Duration.ZERO, 0, false, NewThreadFactoryWithCounter(threadCounter)); assertNotNull(_executorService); assertEquals(0, threadCounter.get()); Future task1 = _executorService.submit(NewInfiniteWaitingRunnable(exitCondition)); assertEquals(1, threadCounter.get()); exitCondition.set(true); assertNull(task1.get(1, MINUTES)); assertTrue(task1.Done); assertFalse(task1.Cancelled); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testCloseableScheduleWithFixedDelayAndAdditionalTasks() throws InterruptedException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: public virtual void testCloseableScheduleWithFixedDelayAndAdditionalTasks() { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.atomic.AtomicInteger outerCounter = new java.util.concurrent.atomic.AtomicInteger(0); AtomicInteger outerCounter = new AtomicInteger(0); Runnable command = () => { outerCounter.incrementAndGet(); }; executorService.scheduleWithFixedDelay(command, DELAY_MS, DELAY_MS, TimeUnit.MILLISECONDS); CloseableScheduledExecutorService service = new CloseableScheduledExecutorService(executorService); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.atomic.AtomicInteger innerCounter = new java.util.concurrent.atomic.AtomicInteger(0); AtomicInteger innerCounter = new AtomicInteger(0); service.scheduleWithFixedDelay(() => { innerCounter.incrementAndGet(); }, DELAY_MS, DELAY_MS, TimeUnit.MILLISECONDS); Thread.Sleep(DELAY_MS * 4); service.close(); Thread.Sleep(DELAY_MS * 2); int innerValue = innerCounter.get(); Assert.assertTrue(innerValue > 0); int value = outerCounter.get(); Thread.Sleep(DELAY_MS * 2); int newValue = outerCounter.get(); Assert.assertTrue(newValue > value); Assert.assertEquals(innerValue, innerCounter.get()); value = newValue; Thread.Sleep(DELAY_MS * 2); newValue = outerCounter.get(); Assert.assertTrue(newValue > value); Assert.assertEquals(innerValue, innerCounter.get()); }
public void TestWriteThreadSafety() { MockedTime time = new MockedTime(); HystrixRollingPercentile p = new HystrixRollingPercentile(time, 100, 25, 1000, true); int num_threads = 10; int num_iterations = 1000; CountdownEvent latch = new CountdownEvent(num_threads); Random r = new Random(); AtomicInteger added = new AtomicInteger(0); for (int i = 0; i < num_threads; i++) { Task t = new Task( () => { for (int j = 1; j < (num_iterations / num_threads) + 1; j++) { int nextInt = r.Next(100); p.AddValue(nextInt); added.GetAndIncrement(); } latch.SignalEx(); }, CancellationToken.None, TaskCreationOptions.LongRunning); t.Start(); } try { latch.Wait(TimeSpan.FromSeconds(100)); Assert.Equal(added.Value, p._buckets.PeekLast._data.Length); } catch (Exception) { Assert.True(false, "Timeout on all threads writing percentiles"); } }
public void TestRecovery() { var mockConnectionFactory = new Mock <RC.IConnectionFactory>(); var count = new AtomicInteger(); mockConnectionFactory.Setup((f) => f.CreateConnection(It.IsAny <string>())) .Callback(() => count.IncrementAndGet()) .Throws(new AuthenticationFailureException("foo")); var connectionFactory = new SingleConnectionFactory(mockConnectionFactory.Object); var template = new RabbitTemplate(connectionFactory) { RetryTemplate = new PollyRetryTemplate(new Dictionary <Type, bool>(), 3, true, 1, 1, 1) }; var recoverInvoked = new AtomicBoolean(); template.RecoveryCallback = new TestRecoveryRecoveryCallback(recoverInvoked); template.ConvertAndSend("foo", "bar", "baz"); Assert.Equal(3, count.Value); Assert.True(recoverInvoked.Value); }
void Dispatch(MessageResult ctx) { var handlers = Subject.Subscriber.Observers; var syncHandlers = handlers.Where(i => i.Value == SubscribeMode.Sync).Select(i => i.Key).ToArray(); var asyncHandlers = handlers.Where(i => i.Value == SubscribeMode.Async).Select(i => i.Key).ToArray(); var handlerCount = syncHandlers.Length + asyncHandlers.Length; var barrier = new AtomicInteger(handlerCount); foreach (var item in syncHandlers) { if (!DoExecute(ctx, item, barrier)) { break; } } Paraller.ForEach(asyncHandlers, handler => DoExecute(ctx, handler, barrier)); }
/// <summary> /// Initializes a new instance of the <see cref="ClientBase" /> class. /// </summary> /// <param name="serverSession">The network session to bind the instance to.</param> /// <param name="packetFactory">The <see cref="IPacketFactory" /> to use for this client.</param> /// <param name="logger">The logger to use for this client.</param> /// <exception cref="ArgumentNullException">Thrown if any of the parameters is <see langword="null" />.</exception> protected ClientBase(IServerSession serverSession, IPacketFactory packetFactory, ILogger logger) { if (serverSession == null) { throw new ArgumentNullException(nameof(serverSession)); } if (packetFactory == null) { throw new ArgumentNullException(nameof(packetFactory)); } _isDisposed = false; _sentPings = new AtomicInteger(0); ServerSession = InitializeSession(serverSession); PacketFactory = packetFactory; Logger = logger; _keepAliveTimer = InitializeTimer(); _keepAliveTimer.Start(); }
public virtual void TestMultipleFailedTasks() { JobHistoryParser parser = new JobHistoryParser(Org.Mockito.Mockito.Mock <FSDataInputStream >()); EventReader reader = Org.Mockito.Mockito.Mock <EventReader>(); AtomicInteger numEventsRead = new AtomicInteger(0); // Hack! TaskType taskType = TaskType.Map; TaskID[] tids = new TaskID[2]; JobID jid = new JobID("1", 1); tids[0] = new TaskID(jid, taskType, 0); tids[1] = new TaskID(jid, taskType, 1); Org.Mockito.Mockito.When(reader.GetNextEvent()).ThenAnswer(new _Answer_842(numEventsRead , tids, taskType, jid)); // send two task start and two task fail events for tasks 0 and 1 JobHistoryParser.JobInfo info = parser.Parse(reader); NUnit.Framework.Assert.IsTrue("Task 0 not implicated", info.GetErrorInfo().Contains (tids[0].ToString())); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldWaitForAllContestantsToComplete() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldWaitForAllContestantsToComplete() { // GIVEN Race race = new Race(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.atomic.AtomicInteger completed = new java.util.concurrent.atomic.AtomicInteger(); AtomicInteger completed = new AtomicInteger(); int count = 5; race.AddContestants(count, throwing(() => { sleep(current().Next(100)); completed.incrementAndGet(); })); // WHEN race.Go(); // THEN assertEquals(count, completed.get()); }
public void Start() { if (_shutdown.CompareAndSet(true, false)) { _eventId = new AtomicInteger(0); _eventQueue = new BlockingCollection <ZooKeeperEvent>(); Task.Factory.StartNew(() => { var events = _eventQueue.GetConsumingEnumerable(); foreach (var @event in events) { var eventId = _eventId.Increment(); @event.Description = string.Format("Delivering event #{0} {1}", eventId, @event.Description); @event.Run(); } _shutdownCompleted.Set(); }); } }
public void AtomicInteger_Value_Change_Should_Success() { var atomicInteger = new AtomicInteger(int.MaxValue); Assert.Equal(int.MaxValue, atomicInteger.Value); atomicInteger.Value = int.MinValue; Assert.Equal(int.MinValue, atomicInteger.Value); atomicInteger.Value = 0; Assert.Equal(0, atomicInteger.Value); // same value assignment atomicInteger.Value = 0; Assert.Equal(0, atomicInteger.Value); atomicInteger.Value = 123; Assert.Equal(123, atomicInteger.Value); atomicInteger.Value = 123; Assert.Equal(123, atomicInteger.Value); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void distinctRateLimitersOperateIndependently() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void DistinctRateLimitersOperateIndependently() { // given Limiters limiters = new Limiters(Clocks.fakeClock()); AtomicInteger cnt = new AtomicInteger(); System.Action <ThreadStart> rateLimiterA = Org.Neo4j.causalclustering.helper.Limiters.rateLimiter("A", _eternity); System.Action <ThreadStart> rateLimiterB = Org.Neo4j.causalclustering.helper.Limiters.rateLimiter("B", _eternity); // when rateLimiterA(cnt.incrementAndGet); rateLimiterA(cnt.incrementAndGet); rateLimiterA(cnt.incrementAndGet); rateLimiterB(cnt.incrementAndGet); rateLimiterB(cnt.incrementAndGet); rateLimiterB(cnt.incrementAndGet); // then assertEquals(2, cnt.get()); }
public MockClusterApplication() { AllLiveNodes = new AtomicInteger(0); HandleApplicationMessageCheck = new AtomicInteger(0); InformLeaderElectedCheck = new AtomicInteger(0); InformLeaderLostCheck = new AtomicInteger(0); InformLocalNodeShutDownCheck = new AtomicInteger(0); InformLocalNodeStartedCheck = new AtomicInteger(0); InformNodeIsHealthyCheck = new AtomicInteger(0); InformNodeJoinedClusterCheck = new AtomicInteger(0); InformNodeLeftClusterCheck = new AtomicInteger(0); InformQuorumAchievedCheck = new AtomicInteger(0); InformQuorumLostCheck = new AtomicInteger(0); InformAttributesClientCheck = new AtomicInteger(0); InformAttributeSetCreatedCheck = new AtomicInteger(0); InformAttributeAddedCheck = new AtomicInteger(0); InformAttributeRemovedCheck = new AtomicInteger(0); InformAttributeReplacedCheck = new AtomicInteger(0); InformAttributeSetRemovedCheck = new AtomicInteger(0); StopCheck = new AtomicInteger(0); }
public virtual void TestRepeatingThread() { AtomicInteger counter = new AtomicInteger(); MultithreadedTestUtil.TestContext ctx = new MultithreadedTestUtil.TestContext(); ctx.AddThread(new _RepeatingTestThread_118(counter, ctx)); ctx.StartThreads(); long st = Time.Now(); ctx.WaitFor(3000); ctx.Stop(); long et = Time.Now(); long elapsed = et - st; // Test should have waited just about 3 seconds Assert.True("Test took " + (et - st) + "ms", Math.Abs(elapsed - 3000) < 500); // Counter should have been incremented lots of times in 3 full seconds Assert.True("Counter value = " + counter.Get(), counter.Get() > 1000); }
internal Mover(NameNodeConnector nnc, Configuration conf, AtomicInteger retryCount ) { long movedWinWidth = conf.GetLong(DFSConfigKeys.DfsMoverMovedwinwidthKey, DFSConfigKeys .DfsMoverMovedwinwidthDefault); int moverThreads = conf.GetInt(DFSConfigKeys.DfsMoverMoverthreadsKey, DFSConfigKeys .DfsMoverMoverthreadsDefault); int maxConcurrentMovesPerNode = conf.GetInt(DFSConfigKeys.DfsDatanodeBalanceMaxNumConcurrentMovesKey , DFSConfigKeys.DfsDatanodeBalanceMaxNumConcurrentMovesDefault); this.retryMaxAttempts = conf.GetInt(DFSConfigKeys.DfsMoverRetryMaxAttemptsKey, DFSConfigKeys .DfsMoverRetryMaxAttemptsDefault); this.retryCount = retryCount; this.dispatcher = new Dispatcher(nnc, Sharpen.Collections.EmptySet <string>(), Sharpen.Collections .EmptySet <string>(), movedWinWidth, moverThreads, 0, maxConcurrentMovesPerNode, conf); this.storages = new Mover.StorageMap(); this.targetPaths = nnc.GetTargetPaths(); this.blockStoragePolicies = new BlockStoragePolicy[1 << BlockStoragePolicySuite.IdBitLength ]; }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void startAndAssertJoined(System.Nullable<int> expectedAssignedPort, java.util.Map<String, String> config) throws Exception private void StartAndAssertJoined(int?expectedAssignedPort, IDictionary <string, string> config) { File configDir = WriteConfig(config); System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1); AtomicInteger port = new AtomicInteger(); _clients[0].addClusterListener(JoinAwaitingListener(latch, port)); bool arbiterStarted = StartArbiter(configDir, latch); if (expectedAssignedPort == null) { assertFalse(format("Should not be able to start arbiter given config file:%s", config), arbiterStarted); } else { assertTrue(format("Should be able to start arbiter given config file:%s", config), arbiterStarted); assertEquals(expectedAssignedPort.Value, port.get()); } }
//------------------------------------------------------------------------- //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(enabled = false) public void test_javaBroken() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: public virtual void test_javaBroken() { // uncomment system out to see how broken it is // very specific format instance needed DecimalFormat format = new DecimalFormat("#,##0.###", new DecimalFormatSymbols(Locale.ENGLISH)); Random random = new Random(1); System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1); AtomicInteger broken = new AtomicInteger(); int threadCount = 15; for (int i = 0; i < threadCount; i++) { ThreadStart runner = () => { try { latch.await(); int val = random.Next(999); string a = format.format((double)val); string b = Convert.ToInt32(val).ToString(); Console.WriteLine(a + " " + b); if (!a.Equals(b)) { broken.incrementAndGet(); } } catch (Exception ex) { Console.WriteLine("Exception: " + ex.Message); } }; (new Thread(runner, "TestThread" + i)).Start(); } // start all threads together latch.Signal(); Thread.Sleep(1000); Console.WriteLine("Broken: " + broken.get()); assertTrue(broken.get() > 0); }
bool DoExecute(MessageResult ctx, IObserverHandler <IMessage> handler, AtomicInteger barrier) { var e = new MessageReceivingEventArgs(ctx, handler.Target); try { ListnerManager.OnReceiving(e); if (!e.Ignored) { ctx.results.Add(DelegateInvoker.Invoke <IMessage>(handler, ctx.Request.Sender, ctx.Request.ToMessage())); } return(true); } catch (Exception ex) { var re = new MessageExceptionEventArgs(ctx, ex); ListnerManager.OnReceivingException(re); ctx.InnerExceptions.Add(ex); return(!re.Canceled); } finally { barrier--; if (barrier == 0) { ListnerManager.OnReceived(new MessageEventArgs(ctx)); ListnerManager.OnSent(e); OnCompleted(ctx); } else { ListnerManager.OnReceived(new MessageEventArgs(ctx)); } e = null; } }
public void TestTlsCertsFromDynamicStream() { string topicName = "persistent://my-property/use/my-ns/my-topic1"; AtomicInteger index = new AtomicInteger(0); MemoryStream certStream = CreateByteInputStream(TlsClientCertFilePath); MemoryStream keyStream = CreateByteInputStream(TlsClientKeyFilePath); Func <MemoryStream> certProvider = () => GetStream(index, certStream); Func <MemoryStream> keyProvider = () => GetStream(index, keyStream); AuthenticationTls auth = new AuthenticationTls(certProvider, keyProvider); _common.GetPulsarSystem(auth, 1000, enableTls: true, brokerService: "pulsar.BrokerServiceUrlTls"); _common.PulsarSystem.PulsarConsumer(_common.CreateConsumer(BytesSchema.Of(), topicName, "TestTlsCertsFromDynamicStream", "my-subscriber-name")); // unload the topic so, new connection will be made and read the cert streams again var producer = _common.PulsarSystem.PulsarProducer(_common.CreateProducer(BytesSchema.Of(), "persistent://my-property/use/my-ns/my-topic1", "")); for (int i = 0; i < 10; i++) { var send = new Send(("test" + i).GetBytes(), ImmutableDictionary <string, object> .Empty); _common.PulsarSystem.Send(send, producer.Producer); } ConsumedMessage msg = null; for (var i = 0; i < 10; i++) { msg = _common.PulsarSystem.Receive("TestTlsCertsFromDynamicStream", 5000); var exepctedMsg = "test" + i; var data = (byte[])(object)msg.Message.Data; Assert.Equal(exepctedMsg.GetBytes(), data); } // Acknowledge the consumption of all messages at once _common.PulsarSystem.AcknowledgeCumulative(msg); }
private WindowCache(WindowCacheConfig cfg) : base(TableSize(cfg), LockCount(cfg)) { _maxFiles = cfg.PackedGitOpenFiles; _maxBytes = cfg.PackedGitLimit; _memoryMap = cfg.PackedGitMMAP; _windowSizeShift = Bits(cfg.PackedGitWindowSize); _windowSize = 1 << _windowSizeShift; _openFiles = new AtomicInteger(); _openBytes = new AtomicLong(); if (_maxFiles < 1) { throw new ArgumentException("Open files must be >= 1"); } if (_maxBytes < _windowSize) { throw new ArgumentException("Window size must be < limit"); } }
public virtual void TestNoErrors() { AtomicInteger threadsRun = new AtomicInteger(); MultithreadedTestUtil.TestContext ctx = new MultithreadedTestUtil.TestContext(); for (int i = 0; i < 3; i++) { ctx.AddThread(new _TestingThread_42(threadsRun, ctx)); } Assert.Equal(0, threadsRun.Get()); ctx.StartThreads(); long st = Time.Now(); ctx.WaitFor(30000); long et = Time.Now(); // All threads should have run Assert.Equal(3, threadsRun.Get()); // Test shouldn't have waited the full 30 seconds, since // the threads exited faster than that. Assert.True("Test took " + (et - st) + "ms", et - st < 5000); }
public int computeItemSimilarities(int degreeOfParallelism, int maxDurationInHours, SimilarItemsWriter writer) { ExecutorService executorService = Executors.newFixedThreadPool(degreeOfParallelism + 1); Output output = null; try { writer.open(); DataModel dataModel = getRecommender().getDataModel(); BlockingQueue<long[]> itemsIDsInBatches = queueItemIDsInBatches(dataModel, batchSize); BlockingQueue<List<SimilarItems>> results = new LinkedBlockingQueue<List<SimilarItems>>(); AtomicInteger numActiveWorkers = new AtomicInteger(degreeOfParallelism); for (int n = 0; n < degreeOfParallelism; n++) { executorService.execute(new SimilarItemsWorker(n, itemsIDsInBatches, results, numActiveWorkers)); } output = new Output(results, writer, numActiveWorkers); executorService.execute(output); } catch (Exception e) { throw new IOException(e); } finally { executorService.shutdown(); try { bool succeeded = executorService.awaitTermination(maxDurationInHours, TimeUnit.HOURS); if (!succeeded) { throw new RuntimeException("Unable to complete the computation in " + maxDurationInHours + " hours!"); } } catch (InterruptedException e) { throw new RuntimeException(e); } Closeables.close(writer, false); } return output.getNumSimilaritiesProcessed(); }
public void Test() { AtomicInteger m = new AtomicInteger(0); Assert.IsTrue(m == 0); Assert.IsFalse(m.CompareAndSet(3, 2)); Assert.IsTrue(m == 0); Assert.IsTrue(m.CompareAndSet(0, 2)); Assert.IsTrue(m == 2); var rs = m + 3;// 2+3 Assert.AreEqual(5, rs); Assert.AreEqual(4, m--); Assert.AreEqual(2, m - 2); Assert.AreEqual(6, m + 4); Assert.AreEqual(6, m.GetAndAdd(4)); Assert.AreEqual(10, m); }
public void AtomicInteger_Division_SeqCst_Should_Fail() { var atomicInteger = new AtomicInteger(256, MemoryOrder.SeqCst); Assert.Throws<DivideByZeroException>(() => atomicInteger / 0); }
public void AtomicInteger_Division_SeqCst_Should_Success() { const int initialValue = 256; var atomicInteger = new AtomicInteger(initialValue); var result = atomicInteger / 2; Assert.Equal(initialValue / 2, result); Assert.Equal(initialValue, atomicInteger.Value); }
public void AtomicInteger_Addition_SeqCst_Should_Success() { const int initialValue = int.MaxValue - 1; var atomicInteger = new AtomicInteger(initialValue); var result = atomicInteger + 1; Assert.Equal(int.MaxValue, result); Assert.Equal(initialValue, atomicInteger.Value); }
public void AtomicInteger_Implicit_Int_AcqRel_Should_Success() { var atomicInteger = new AtomicInteger(int.MaxValue); var func = new Func<int, int>(i => i); Assert.Equal(int.MaxValue, func(atomicInteger)); }
public void AtomicInteger_Post_Decrement_SeqCst_Should_Success() { var atomicInteger = new AtomicInteger(int.MaxValue, MemoryOrder.SeqCst); atomicInteger--; Assert.Equal(int.MaxValue - 1, atomicInteger.Value); }
public void AtomicInteger_Implicit_Int_SeqCst_Should_Success() { var atomicInteger = new AtomicInteger(int.MaxValue, MemoryOrder.SeqCst); var func = new Func<int, int>(i => i); Assert.Equal(int.MaxValue, func(atomicInteger)); }
public void AtomicInteger_Division_AcqRel_Should_Fail() { var atomicInteger = new AtomicInteger(256); Assert.Throws<DivideByZeroException>(() => atomicInteger/0); }
public void AtomicInteger_Pre_Increment_SeqCst_Should_Success() { var atomicInteger = new AtomicInteger(int.MaxValue - 1, MemoryOrder.SeqCst); ++atomicInteger; Assert.Equal(int.MaxValue, atomicInteger.Value); }
public void AtomicInteger_Inequality_AcqRel_Should_Success() { var atomicInteger = new AtomicInteger(int.MinValue); Assert.True(atomicInteger != int.MaxValue); }
public void AtomicInteger_Multiplication_SeqCst_Should_Success() { const int initialValue = 123; var atomicInteger = new AtomicInteger(initialValue); var result = atomicInteger * 2; Assert.Equal(initialValue * 2, result); Assert.Equal(initialValue, atomicInteger.Value); }
public void AtomicInteger_Inequality_SeqCst_Should_Success() { var atomicInteger = new AtomicInteger(int.MinValue, MemoryOrder.SeqCst); Assert.True(atomicInteger != int.MaxValue); }