Inheritance: IDisposable
Example #1
0
//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
        }
        public void TestChangeNotification()
        {
            var countDown = new CountdownEvent(1);
            EventHandler<DatabaseChangeEventArgs> handler
                = (sender, e) => countDown.Signal();

            database.Changed += handler;

            // create a document
            var documentProperties = new Dictionary<string, object>();
            documentProperties["foo"] = 1;
            documentProperties["bar"] = false;
            documentProperties["baz"] = "touch";
            
            var body = new Body(documentProperties);
            var rev1 = new RevisionInternal(body);

            database.PutRevision(rev1, null, false);
            Sleep(500);
            
            Assert.IsTrue(countDown.Wait(TimeSpan.FromSeconds(1)));

            // Analysis disable once DelegateSubtraction
            database.Changed -= handler;
        }
Example #3
0
 internal ResourceReader( SlaveLocksClientConcurrentTest outerInstance, SlaveLocksClient locksClient, ResourceType resourceType, long id, System.Threading.CountdownEvent resourceLatch, System.Threading.CountdownEvent resourceReleaseLatch )
     : base(outerInstance, locksClient, resourceType, id)
 {
     this._outerInstance = outerInstance;
         this.ResourceLatch = resourceLatch;
         this.ResourceReleaseLatch = resourceReleaseLatch;
 }
Example #4
0
        static void Main(string[] args)
        {
            // If using an API key
            //ImportIO io = new ImportIO("http://api.import.io",Guid.parse("d08d14f3-6c98-44af-a301-f8d4288ecce3"),"tMFNJzaaLe8sgYF9hFNhKI7akyiPLMhfu8U2omNVCVr5hqWWLyiQMApDDyUucQKF++BAoVi6jnGnavYqRKP/9g==");
            
            // If using a username and password
            ImportIO io = new ImportIO();
            io.Login("xxx", "xxx");
            

            io.Connect();
            Dictionary<String,Object> query1 = new Dictionary<string,object>();
            query1.Add("input",new Dictionary<String,String>() {{ "query","mac mini" }});
            query1.Add("connectorGuids", new List<String>() { "39df3fe4-c716-478b-9b80-bdbee43bfbde" });

            Dictionary<String, Object> query2 = new Dictionary<string, object>();
            query2.Add("input", new Dictionary<String, String>() { { "query", "ubuntu" } });
            query2.Add("connectorGuids", new List<String>() { "39df3fe4-c716-478b-9b80-bdbee43bfbde" });

            Dictionary<String, Object> query3 = new Dictionary<string, object>();
            query3.Add("input", new Dictionary<String, String>() { { "query", "ibm" } });
            query3.Add("connectorGuids", new List<String>() { "39df3fe4-c716-478b-9b80-bdbee43bfbde" });

            countdownLatch = new CountdownEvent(3);

            io.DoQuery(query1, HandleQuery);
            io.DoQuery(query2, HandleQuery);
            io.DoQuery(query3, HandleQuery);

            countdownLatch.Wait();

            io.Disconnect();
        }
Example #5
0
//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();
        }
Example #6
0
        public void TestTimerStartAutoReset()
        {
            CountdownEvent cde = new CountdownEvent(1);
            int result = 0;
            _timer = new TestTimer(1);

            // Test defaults.
            Assert.Equal(1, _timer.Interval);
            Assert.True(_timer.AutoReset);

            _timer.AutoReset = false;
            _timer.Elapsed += (sender, e) => { result = ++result; cde.Signal(); };
            _timer.Start();

            Assert.True(_timer.Enabled);
            cde.Wait();

            // Only elapsed once.
            Assert.Equal(1, result);

            cde = new CountdownEvent(10);
            _timer.AutoReset = true;

            cde.Wait();
            cde.Dispose();

            _timer.Stop();
            // Atleast elapsed 10 times.
            Assert.True(result >= 10);
        }
        public void be_able_to_subscribe_to_non_existing_stream_and_then_catch_event()
        {
            const string stream = "be_able_to_subscribe_to_non_existing_stream_and_then_catch_event";
            using (var store = BuildConnection(_node))
            {
                store.ConnectAsync().Wait();
                var appeared = new CountdownEvent(1);
                var dropped = new CountdownEvent(1);

                var subscription = store.SubscribeToStreamFrom(stream,
                                                               null,
                                                               CatchUpSubscriptionSettings.Default,
                                                               (_, x) => appeared.Signal(),
                                                               _ => Log.Info("Live processing started."),
                                                               (_, __, ___) => dropped.Signal());

                store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, TestEvent.NewTestEvent()).Wait();

                if (!appeared.Wait(Timeout))
                {
                    Assert.IsFalse(dropped.Wait(0), "Subscription was dropped prematurely.");
                    Assert.Fail("Appeared countdown event timed out.");
                }

                Assert.IsFalse(dropped.Wait(0));
                subscription.Stop(Timeout);
                Assert.IsTrue(dropped.Wait(Timeout));
            }
        }
Example #8
0
        static void M1()
        {
            var sameLocalVariable = 123;
            var cdevent = new CountdownEvent(2);

            if (Fork.CloneThread())
            {
                lock (_sync)
                {
                    Console.ReadKey();
                    Console.WriteLine("in forked thread: {0}, tid: {1} ", sameLocalVariable, Thread.CurrentThread.ManagedThreadId);
                    cdevent.Signal();
                }
            }
            else
            {
                lock (_sync)
                {
                    Console.ReadKey();
                    Console.WriteLine("in parent thread: {0}, tid: {1} ", sameLocalVariable, Thread.CurrentThread.ManagedThreadId);
                    cdevent.Signal();
                }
            }

            cdevent.Wait();
        }
        protected override long RunDisruptorPass()
        {
            Setup();
            var latch = new CountdownEvent(NUM_EVENT_PROCESSORS);
            var listTh = new List<Thread>();
            for (int i = 0; i < 3; i++)
            {
                handlers[i].Reset(latch, -1 + ITERATIONS);
            }

            disruptor.Start();
            var start = System.Diagnostics.Stopwatch.StartNew();

            for (long i = 0; i < ITERATIONS; i++)
            {
                long sequence = ringBuffer.Next();
                ringBuffer[sequence].Value = i;
                ringBuffer.Publish(sequence);
            }
            latch.Wait();
            long opsPerSecond = (ITERATIONS * 1000L) / start.ElapsedMilliseconds;
            for (int i = 0; i < NUM_EVENT_PROCESSORS; i++)
            {
                Assert.AreEqual(results[i], handlers[i].Value);
            }
            disruptor.Shutdown();
            return opsPerSecond;
        }
        public void be_able_to_subscribe_to_non_existing_stream()
        {
            const string stream = "be_able_to_subscribe_to_non_existing_stream";
            using (var store = BuildConnection(_node))
            {
                store.ConnectAsync().Wait();
                var appeared = new ManualResetEventSlim(false);
                var dropped = new CountdownEvent(1);

                var subscription = store.SubscribeToStreamFrom(stream,
                                                               null,
                                                               CatchUpSubscriptionSettings.Default,
                                                               (_, x) => appeared.Set(),
                                                               _ => Log.Info("Live processing started."),
                                                               (_, __, ___) => dropped.Signal());

                Thread.Sleep(100); // give time for first pull phase
                store.SubscribeToStreamAsync(stream, false, (s, x) => { }, (s, r, e) => { }).Wait();
                Thread.Sleep(100);
                Assert.IsFalse(appeared.Wait(0), "Some event appeared.");
                Assert.IsFalse(dropped.Wait(0), "Subscription was dropped prematurely.");
                subscription.Stop(Timeout);
                Assert.IsTrue(dropped.Wait(Timeout));
            }
        }
Example #11
0
//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();
        }
Example #12
0
		static void Main(string[] args)
		{
			int max = 50;
			CountdownEvent cd = new CountdownEvent(max);

			string endPoint = "tcp://localhost:5557";
			System.Console.WriteLine("Publishing on {0}\n", endPoint);

			const string topic = "TestTopicxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";

			{
				var publisher = new MessagePublisher<IMessage>("tcp://localhost:5557",
					new ProtoBufMessageSerializer(),
					topic);

				for (int i = 0; i < max; i++)
				{
					publisher.PublishAsync(new Message1AndItIs32CharactersLongForSureDefinitionForSure()
					{
						Id = i
					});

					Thread.Sleep(TimeSpan.FromSeconds(0.5));
					System.Console.WriteLine("Published: {0}", i);
				}
			}

			System.Console.WriteLine("[finished - any key to continue]");
			System.Console.ReadKey();
		}
Example #13
0
        public virtual void ShouldKeepHighest()
        {
            // GIVEN
            Race      race      = new Race();
            HighestId highestId = new HighestId();
            int       threads   = Runtime.Runtime.availableProcessors();

            System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(threads);
            AtomicLongArray highestIds            = new AtomicLongArray(threads);

            for (int c = 0; c < threads; c++)
            {
                int cc = c;
                race.AddContestant(new RunnableAnonymousInnerClass(this, highestId, latch, highestIds, cc));
            }
            race.WithEndCondition(() => latch.CurrentCount == 0);

            // WHEN
            race.Go();

            long highest = 0;

            for (int i = 0; i < threads; i++)
            {
                highest = max(highest, highestIds.get(i));
            }
            assertEquals(highest, highestId.Get());
        }
        public void be_able_to_subscribe_to_empty_db()
        {
            using (var store = TestConnection.Create(_node.TcpEndPoint))
            {
                store.ConnectAsync().Wait();
                var appeared = new ManualResetEventSlim(false);
                var dropped = new CountdownEvent(1);

                var subscription = store.SubscribeToAllFrom(null,
                                                            false,
                                                            (_, x) =>
                                                            {
                                                                if (!SystemStreams.IsSystemStream(x.OriginalEvent.EventStreamId))
                                                                    appeared.Set();
                                                            },
                                                            _ => Log.Info("Live processing started."),
                                                            (_, __, ___) => dropped.Signal());

                Thread.Sleep(100); // give time for first pull phase
                store.SubscribeToAllAsync(false, (s, x) => { }, (s, r, e) => { }).Wait();
                Thread.Sleep(100);

                Assert.IsFalse(appeared.Wait(0), "Some event appeared.");
                Assert.IsFalse(dropped.Wait(0), "Subscription was dropped prematurely.");
                subscription.Stop(Timeout);
                Assert.IsTrue(dropped.Wait(Timeout));
            }
        }
        protected PerformanceRecord ExecuteReadWithParallel(string operation, IEnumerable<uint> ids, int numberOfThreads, Func<long> readAction)
        {
            var countdownEvent = new CountdownEvent(numberOfThreads);

            var sw = Stopwatch.StartNew();
            var bytes = new long[numberOfThreads];
            for (int i = 0; i < numberOfThreads; i++)
            {
                var c = i;
                ThreadPool.QueueUserWorkItem(
                    state =>
                    {
                        bytes[c] = readAction();

                        countdownEvent.Signal();
                    });
            }

            countdownEvent.Wait();
            sw.Stop();

            return new PerformanceRecord
            {
                Bytes = bytes.Sum(),
                Operation = operation,
                Time = DateTime.Now,
                Duration = sw.ElapsedMilliseconds,
                ProcessedItems = ids.Count() * numberOfThreads
            };
        }
Example #16
0
//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
        }
Example #17
0
		public void BasicUsageTest ()
		{
			bool act1 = false, act2 = false;
			var evt = new CountdownEvent (2);

			var broadcast = new BroadcastBlock<int> (null);
			var action1 = new ActionBlock<int> (i =>
			{
				act1 = i == 42;
				evt.Signal ();
			});
			var action2 = new ActionBlock<int> (i =>
			{
				act2 = i == 42;
				evt.Signal ();
			});

			broadcast.LinkTo (action1);
			broadcast.LinkTo (action2);

			Assert.IsTrue (broadcast.Post (42));

			Assert.IsTrue (evt.Wait (100));

			Assert.IsTrue (act1);
			Assert.IsTrue (act2);
		}
Example #18
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldHaveTaskQueueSizeEqualToMaxNumberOfProcessors() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldHaveTaskQueueSizeEqualToMaxNumberOfProcessors()
        {
            // GIVEN
            StageControl control = mock(typeof(StageControl));

//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);
            const int     processors    = 2;
            int           maxProcessors = 5;
            Configuration configuration = new ConfigurationAnonymousInnerClass(this, maxProcessors);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final ProcessorStep<Void> step = new BlockingProcessorStep(control, configuration, processors, latch);
            ProcessorStep <Void> step = new BlockingProcessorStep(control, configuration, processors, latch);

            step.Start(ORDER_SEND_DOWNSTREAM);
            step.Processors(1);                 // now at 2
            // adding up to max processors should be fine
            for (int i = 0; i < processors + maxProcessors; i++)
            {
                step.Receive(i, null);
            }

            // WHEN
            Future <Void> receiveFuture = T2.execute(Receive(processors, step));

            T2.get().waitUntilThreadState(Thread.State.TIMED_WAITING);
            latch.Signal();

            // THEN
            receiveFuture.get();
        }
Example #19
0
//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);
            }
        }
        private static void Run(string[] args)
        {
            Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
            Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");

            var config = new ClientConfig();
            config.GetNetworkConfig().AddAddress("127.0.0.1");
            var client = HazelcastClient.NewHazelcastClient(config);

            var list = client.GetList<string>("collection-listener-example");
            var cdown = new CountdownEvent(3);
            list.AddItemListener(new ItemListener<string>
            {
                OnItemAdded = e =>
                {
                    Console.WriteLine("Item added: " + e.GetItem());
                    cdown.Signal();
                },
                OnItemRemoved = e =>
                {
                    Console.WriteLine("Item removed: " + e.GetItem());
                    cdown.Signal();
                }
            }, true);

            list.Add("item1");
            list.Add("item2");
            list.Remove("item1");

            cdown.Wait();
            list.Destroy();
            client.Shutdown();
        }
Example #21
0
        // 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);
            }
        }
Example #22
0
//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());
        }
Example #23
0
        public void TestFindAllEntities()
        {
            RunAndAwait( () =>
            {
              var entities = new List<FindAllEntityAsync>();
              var latch = new CountdownEvent( 10 );
              for( int i = 0; i < 10; i++ )
              {
            var findAllEntity = new FindAllEntityAsync {Name = "bot_#" + i, Age = 20 + i};
            Backendless.Persistence.Save( findAllEntity, new AsyncCallback<FindAllEntityAsync>( response =>
              {
                entities.Add( findAllEntity );
                latch.Signal();
              }, fault =>
                {
                  for( int j = 0; j < latch.CurrentCount; j++ )
                    latch.Signal();

                  FailCountDownWith( fault );
                } ) );
              }
              latch.Wait();

              Backendless.Persistence.Of<FindAllEntityAsync>()
                     .Find( new ResponseCallback<BackendlessCollection<FindAllEntityAsync>>( this )
                       {
                         ResponseHandler =
                           backendlessCollection => AssertArgumentAndResultCollections( entities, backendlessCollection )
                       } );
            } );
        }
		public void Test()
		{
			var CustomThreadPool = new CustomThreadPool(2);
			var Results0 = new List<int>();
			var Results1 = new List<int>();
			var CountdownEvent = new CountdownEvent(2);

			CustomThreadPool.AddTask(0, () =>
			{
				Thread.Sleep(10);
				Results0.Add(0);
			});
			CustomThreadPool.AddTask(0, () =>
			{
				Results0.Add(1);
				CountdownEvent.Signal();
			});
			CustomThreadPool.AddTask(1, () =>
			{
				Results1.Add(0);
				CountdownEvent.Signal();
			});

			CountdownEvent.Wait();
			Thread.Sleep(10);
			Assert.IsTrue(CustomThreadPool.GetLoopIterCount(0) <= 2);
			Assert.IsTrue(CustomThreadPool.GetLoopIterCount(1) <= 2);
			Assert.AreEqual("0,1", Results0.ToStringArray());
			Assert.AreEqual("0", Results1.ToStringArray());
			CustomThreadPool.Stop();
		}
Example #25
0
        public void Should_catch_EndOfStreamException()
        {
            // Arrange
            var count = new CountdownEvent(2);
            var channel = Substitute.For<IModel>();
            var watcher = Substitute.For<IRabbitWatcher>();
            var queue = Substitute.For<IInMemoryPriorityQueue<GenericPriorityMessage<BasicDeliverEventArgs>>>();
            queue.When(x => x.Dequeue()).Do(callInfo => {
                count.Signal();
                throw new EndOfStreamException();                
            });
            var consumer = new PriorityBurrowConsumer(channel, Substitute.For<IMessageHandler>(), watcher, true, 2);

            var sub = Substitute.For<CompositeSubscription>();
            sub.AddSubscription(new Subscription(channel) { ConsumerTag = "Burrow" });
            consumer.Init(queue, sub, 1, Guid.NewGuid().ToString());
            

            // Action
            consumer.Ready();
            count.Wait();

            // Assert
            consumer.Dispose();
        }
 public ConcurrentRunner(int maxThread, int loopEach)
 {
     this.maxThread = maxThread;
     this.loopEach = loopEach;
     this.semaphore = new SemaphoreSlim(0, maxThread);
     this.countdown = new CountdownEvent(maxThread);
 }
Example #27
0
        public void SocketConnect()
        {
            const int port = 5050;
            const int clientCount = 10;
            var listener = SocketEvents.GetTcpStreamSockets(port);
            var countdown = new CountdownEvent(clientCount);
            try
            {
                var tcs = new TaskCompletionSource<object>();
                int count = 0;
                listener.Subscribe(s =>
                {
                    count++;
                    countdown.Signal();
                    s.Close();
                },
                tcs.SetException,
                () => tcs.TrySetResult(null));

                for (int i = 0; i < clientCount; i++)
                {
                    SocketTestUtility.Connect(port);
                }

                countdown.WaitEx();
                Assert.IsTrue(count == clientCount);
            }
            finally
            {
                listener.Dispose();
            }
        }
        public void Should_be_able_to_subscribe_as_exlusive()
        {
            var countdownEvent = new CountdownEvent(10);
            var firstCount = 0;
            var secondCount = 0;

            bus.Subscribe<MyMessage>("test", message =>
                {
                    countdownEvent.Signal();
                    Interlocked.Increment(ref firstCount);
                    Console.WriteLine("[1] " + message.Text);
                }, x => x.AsExclusive());
            bus.Subscribe<MyMessage>("test", message =>
                {
                    countdownEvent.Signal();
                    Interlocked.Increment(ref secondCount);
                    Console.WriteLine("[2] " + message.Text);
                }, x => x.AsExclusive());

            for (var i = 0; i < 10; ++i)
                bus.Publish(new MyMessage
                    {
                        Text = "Exclusive " + i
                    });
            countdownEvent.Wait(10 * 1000);
            Assert.IsTrue(firstCount == 10 && secondCount == 0 || firstCount == 0 && secondCount == 10);
            Console.WriteLine("Stopped consuming");
        }
        static void Main(string[] args)
        {
            // initialize the semaphores
            semA = new SemaphoreSlim(2);
            semB = new SemaphoreSlim(2);

            // define the number of tasks we will use
            int taskCount = 10;

            // initialize the barrier
            cdEvent = new CountdownEvent(taskCount);

            Task[] tasks = new Task[10];
            for (int i = 0; i < taskCount; i++) {
                tasks[i] = Task.Factory.StartNew((stateObject) => {
                    InitialMethod((int)stateObject);
                    Console.WriteLine("Task {0} completed", Task.CurrentId);
                }, i);
            }

            // wait for all of the tasks to have reached a terminal method
            cdEvent.Wait();

            // throw an exception to force the debugger to break
            throw new Exception();
        }
        public void Should_load_share_between_multiple_consumers()
        {
            var countdownEvent = new CountdownEvent(2);

            MyMessage receivedMessage1 = null;
            bus.Subscribe<MyMessage>("subscriberId", message =>
            {
                Console.WriteLine("Handler A got '{0}'", message.Text);
                receivedMessage1 = message;
                countdownEvent.Signal();
            });

            MyMessage receivedMessage2 = null;
            bus.Subscribe<MyMessage>("subscriberId", message =>
            {
                Console.WriteLine("Handler B got '{0}'", message.Text);
                receivedMessage2 = message;
                countdownEvent.Signal();
            });

            var publishedMessage1 = new MyMessage { Text = "Hello There From The First!" };
            var publishedMessage2 = new MyMessage { Text = "Hello There From The Second!" };
            using (var channel = bus.OpenPublishChannel())
            {
                channel.Publish(publishedMessage1);
                channel.Publish(publishedMessage2);
            }

            // give the task background thread time to process the message.
            countdownEvent.Wait();

            receivedMessage1.Text.ShouldEqual(publishedMessage1.Text);
            receivedMessage2.Text.ShouldEqual(publishedMessage2.Text);
        }
        protected override long RunDisruptorPass()
        {
            CountdownEvent latch = new CountdownEvent(1);
            long expectedCount = batchEventProcessor.Sequence.Value + ITERATIONS;
            handler.Reset(latch, ITERATIONS);
            Task.Factory.StartNew(() => batchEventProcessor.Run());
            Stopwatch start = Stopwatch.StartNew();

            RingBuffer<long[]> rb = ringBuffer;

            for (long i = 0; i < ITERATIONS; i++)
            {
                long next = rb.Next();
                long[] @event = rb.Get(next);
                for (int j = 0; j < @event.Length; j++)
                {
                    @event[j] = i;
                }
                rb.Publish(next);
            }

            latch.Wait();
            long opsPerSecond = (ITERATIONS * ARRAY_SIZE * 1000L) / (start.ElapsedMilliseconds);
            waitForEventProcessorSequence(expectedCount);
            batchEventProcessor.Halt();

            PerfTestUtil.failIf(0, handler.Value);

            return opsPerSecond;
        }
        public void ProperRooting_NoGC_SingleShot()
        {
            var cts = new CancellationTokenSource();

            new Thread(() =>
            {
                while (!cts.IsCancellationRequested)
                {
                    Thread.Sleep(50);
                    GC.Collect();
                    GC.WaitForPendingFinalizers();
                }
            }).Start();

            var tp = ThreadPoolScheduler.Instance;
            var N = 100;
            var cd = new CountdownEvent(N);
            for (int i = 0; i < N; i++)
            {
                tp.Schedule(TimeSpan.FromMilliseconds(100 + i), () => { cd.Signal(); });
            }

            Assert.True(cd.Wait(TimeSpan.FromMinutes(1)));
            cts.Cancel();
        }
Example #33
0
        public void HydratingFromMultipleThreads_IsSafe()
        {
            var numberOfHydrations = 0;
            var cache = new CachedValue<int>(() => ++numberOfHydrations);

            Assert.That(cache.Value, Is.EqualTo(1));

            using (var countdownEvent = new CountdownEvent(2))
            {
                Action threadAction = () =>
                {
                    cache.Invalidate();
                    countdownEvent.Signal();
                    countdownEvent.Wait();

                    Assert.That(cache.Value, Is.EqualTo(2));
                };

                var t1 = threadAction.BeginInvoke(threadAction.EndInvoke, null);
                var t2 = threadAction.BeginInvoke(threadAction.EndInvoke, null);
                WaitHandle.WaitAll(new[]{t1.AsyncWaitHandle, t2.AsyncWaitHandle});
            }

            Assert.That(numberOfHydrations, Is.EqualTo(2));
        }
Example #34
0
        public IDisposable Start()
        {
            _monitor.Start();
            CountdownEvent pending = new CountdownEvent(_args.ConnectionLimit);
            var interval = Observable.Interval(TimeSpan.FromSeconds(1))
                .TakeWhile(_ => pending.CurrentCount > 0)
                .Subscribe(async _ =>
                {
                    var parallelCount = Math.Min(pending.CurrentCount, 10);

                    Task[] tasks = new Task[parallelCount];
                    for (int i = 0; i < parallelCount; i++)
                    {
                        tasks[i] = Task.Run(() => Connect(pending));
                    }

                    Task.WaitAll(tasks);
                },
                ex =>
                {
                    Console.WriteLine(ex.Message);
                    Environment.Exit(1);
                });

            pending.Wait();

            Observable.Interval(TimeSpan.FromSeconds(1)).Subscribe(this.SendMessage);

            return null;
        }
Example #35
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void terminatedTransactionDoesNotForceUpdatePulling()
        public virtual void TerminatedTransactionDoesNotForceUpdatePulling()
        {
            int testTxsOnMaster = 42;

            ClusterManager.ManagedCluster cluster = ClusterRule.withSharedSetting(HaSettings.pull_interval, "0s").withSharedSetting(HaSettings.tx_push_factor, "0").startCluster();

            HighlyAvailableGraphDatabase master = cluster.Master;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.ha.HighlyAvailableGraphDatabase slave = cluster.getAnySlave();
            HighlyAvailableGraphDatabase slave = cluster.AnySlave;

            CreateNodeOn(master);
            cluster.Sync();

            long lastClosedTxIdOnMaster = LastClosedTxIdOn(master);
            long lastClosedTxIdOnSlave  = LastClosedTxIdOn(slave);

//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch slaveTxStarted = new java.util.concurrent.CountDownLatch(1);
            System.Threading.CountdownEvent slaveTxStarted = new System.Threading.CountdownEvent(1);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch slaveShouldCommit = new java.util.concurrent.CountDownLatch(1);
            System.Threading.CountdownEvent slaveShouldCommit = new System.Threading.CountdownEvent(1);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicReference<org.neo4j.graphdb.Transaction> slaveTx = new java.util.concurrent.atomic.AtomicReference<>();
            AtomicReference <Transaction> slaveTx = new AtomicReference <Transaction>();
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.concurrent.Future<?> slaveCommit = java.util.concurrent.Executors.newSingleThreadExecutor().submit(() ->
            Future <object> slaveCommit = Executors.newSingleThreadExecutor().submit(() =>
            {
                using (Transaction tx = slave.BeginTx())
                {
                    slaveTx.set(tx);
                    slaveTxStarted.Signal();
                    Await(slaveShouldCommit);
                    tx.success();
                }
            });

            Await(slaveTxStarted);
            CreateNodesOn(master, testTxsOnMaster);

            assertNotNull(slaveTx.get());
            slaveTx.get().terminate();
            slaveShouldCommit.Signal();

            try
            {
                slaveCommit.get();
                fail("Exception expected");
            }
            catch (Exception e)
            {
                assertThat(e, instanceOf(typeof(ExecutionException)));
                assertThat(e.InnerException, instanceOf(typeof(TransientTransactionFailureException)));
            }

            assertEquals(lastClosedTxIdOnMaster + testTxsOnMaster, LastClosedTxIdOn(master));
            assertEquals(lastClosedTxIdOnSlave, LastClosedTxIdOn(slave));
        }
Example #36
0
        private Worker NewWorker(GraphDatabaseService db, System.Threading.CountdownEvent startSignal, AtomicBoolean stopSignal, AtomicReference <Exception> failure, Node parentNode)
        {
            Worker worker = new Worker(db, startSignal, stopSignal, failure, parentNode);

            worker.Start();
            return(worker);
        }
Example #37
0
//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));
        }
Example #38
0
//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);
            }
        }
Example #39
0
//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());
            });
        }
Example #40
0
        public MainWindow()
        {
            InitializeComponent();
            Thread.CurrentThread.Name = "Main Thread";

            CountdownEvent folderEndByXML = new CountdownEvent(1);
            CountdownEvent folderEndByTree = new CountdownEvent(1);
            CountdownEvent fileEndByXML = new CountdownEvent(1);
            CountdownEvent fileEndByTree = new CountdownEvent(1);

            m_parser = new Parser(m_progressToken, folderEndByTree, folderEndByXML, fileEndByTree, fileEndByXML);
            m_treeFiller = new TreeFiller(m_treeView, m_progressToken, folderEndByTree, fileEndByTree);
            m_xmlFiller = new XMLFiller(m_progressToken, folderEndByXML, fileEndByXML);

            m_folderName.DataContext = m_parser;
            m_xmlFileName.DataContext = m_xmlFiller;

            m_parser.ItemGrabbed += m_xmlFiller.ItemGrabbedHandler;
            m_parser.ItemGrabbed += m_treeFiller.ItemGrabbedHandler;
            m_parser.FolderStarted += m_xmlFiller.FolderStartedHandler;
            m_parser.FolderStarted += m_treeFiller.FolderStartedHandler;
            m_parser.FolderFinished += m_xmlFiller.FolderFinishedHandler;
            m_parser.FolderFinished += m_treeFiller.FolderFinishedHandler;

            m_parser.ParserFinishEvent += this.ParserFinishEventHandler;

            m_xmlFiller.ExceptionOccuredEvent += this.ExceptionOccuredHandler;
            m_treeFiller.ExceptionOccuredEvent += this.ExceptionOccuredHandler;
            m_parser.ExceptionOccuredEvent += this.ExceptionOccuredHandler;
        }
        protected List<PerformanceRecord> ExecuteWriteWithParallel(IEnumerable<TestData> data, int numberOfTransactions, int itemsPerTransaction, int numberOfThreads, Func<IEnumerator<TestData>, long, long, List<PerformanceRecord>> writeFunction, out long elapsedMilliseconds)
        {
            var countdownEvent = new CountdownEvent(numberOfThreads);

            var parallelData = SplitData(data, numberOfTransactions, itemsPerTransaction, numberOfThreads);

            var records = new List<PerformanceRecord>[numberOfThreads];
            var sw = Stopwatch.StartNew();

            for (int i = 0; i < numberOfThreads; i++)
            {
                ThreadPool.QueueUserWorkItem(
                    state =>
                    {
                        var index = (int)state;
                        var pData = parallelData[index];

                        records[index] = writeFunction(pData.Enumerate(), pData.ItemsPerTransaction, pData.NumberOfTransactions);

                        countdownEvent.Signal();
                    },
                    i);
            }

            countdownEvent.Wait();
            sw.Stop();

            elapsedMilliseconds = sw.ElapsedMilliseconds;

            return records
                .SelectMany(x => x)
                .ToList();
        }
Example #42
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldNotUpdateOutputStreamWhenClosedDuringRotation() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        internal virtual void ShouldNotUpdateOutputStreamWhenClosedDuringRotation()
        {
//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);

            RotationListener rotationListener = spy(new RotationListenerAnonymousInnerClass2(this, allowRotationComplete));

//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.List<java.io.OutputStream> mockStreams = new java.util.ArrayList<>();
            IList <Stream>        mockStreams = new List <Stream>();
            FileSystemAbstraction fs          = new DelegatingFileSystemAbstractionAnonymousInnerClass(this, _fileSystem, mockStreams);

            ExecutorService rotationExecutor = Executors.newSingleThreadExecutor();

            try
            {
                RotatingFileOutputStreamSupplier supplier = new RotatingFileOutputStreamSupplier(fs, _logFile, 10, 0, 10, rotationExecutor, rotationListener);
                Stream outputStream = supplier.Get();

                Write(supplier, "A string longer than 10 bytes");
                assertThat(supplier.Get(), @is(outputStream));

                allowRotationComplete.Signal();
                supplier.Dispose();
            }
            finally
            {
                ShutDownExecutor(rotationExecutor);
            }

            AssertStreamClosed(mockStreams[0]);
        }
		public void Constructor_Zero ()
		{
			var ce = new CountdownEvent (0);
			Assert.IsTrue (ce.IsSet, "#1");
			Assert.AreEqual (0, ce.InitialCount, "#2");
			Assert.IsTrue (ce.Wait (0), "#3");
		}
Example #44
0
        public void Should_execute_less_than_4_seconds()
        {
            ThreadPool.SetMinThreads(NumThreads, NumThreads);

            Console.WriteLine("Burst test started");

            _mre.Reset();
            _countdown = new CountdownEvent(NumThreads);

            for (var i = 0; i < NumThreads; i++)
            {
                new Thread(OneThreadExecution) { Name = "Thread " + i }.Start();
            }

            _countdown.Wait();
            var dateTime = DateTime.Now;
            _countdown = new CountdownEvent(NumThreads);
            _mre.Set();
            _countdown.Wait();
            var timeSpan = DateTime.Now - dateTime;

            Console.WriteLine("Test finished");
            Console.WriteLine("Executed at {0}.{1:0}s.", timeSpan.Seconds, timeSpan.Milliseconds / 100);

            if (timeSpan.Seconds > 5)
            {
                Assert.Ignore("This test should't take more than to 4 seconds to run");
            }
        }
Example #45
0
            public void should_reconnect_within_5_seconds()
            {
                const int total = 100;
                var countdown = new CountdownEvent(total);

                IBus producer = this.StartBus("producer", cfg => cfg.Route("boo"));

                IBus consumer = this.StartBus(
                    "consumer",
                    cfg => cfg.On<BooMessage>("boo").
                               ReactWith(
                                   (m, ctx) =>
                                       {
                                           Console.WriteLine("Received {0}.", m.Num);
                                           countdown.Signal();
                                       }));

                int count = total;
                while (count -- > 0)
                {
                    producer.Emit("boo", new BooMessage(count));
                    Console.WriteLine("Sent {0}.", count);
                    Thread.Sleep(1.Seconds());
                }

                countdown.Wait();
            }
Example #46
0
        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.");
        }
Example #47
0
//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)));
        }
Example #48
0
 internal Worker(GraphDatabaseService db, System.Threading.CountdownEvent startSignal, AtomicBoolean stopSignal, AtomicReference <Exception> failure, Node parentNode)
 {
     this.Db          = db;
     this.StartSignal = startSignal;
     this.StopSignal  = stopSignal;
     this.Failure     = failure;
     this.ParentNode  = parentNode;
 }
Example #49
0
 internal Populator(DynamicIndexStoreViewIT outerInstance, GraphDatabaseService databaseService, long totalNodes, System.Threading.CountdownEvent startSignal, AtomicBoolean endSignal)
 {
     this._outerInstance  = outerInstance;
     this.DatabaseService = databaseService;
     this.TotalNodes      = totalNodes;
     this.StartSignal     = startSignal;
     this.EndSignal       = endSignal;
 }
//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();
            }
        }
Example #51
0
//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();
                }
            });
        }
Example #52
0
//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();
        }
Example #53
0
//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 Runnable createWriter(final RWLock lock, final LockTransaction transaction, final java.util.concurrent.CountDownLatch latch)
        private ThreadStart CreateWriter(RWLock @lock, LockTransaction transaction, System.Threading.CountdownEvent latch)
        {
            return(() =>
            {
                @lock.Mark();
                @lock.AcquireWriteLock(LockTracer.NONE, transaction);
                latch.Signal();
            });
        }
Example #54
0
 public RunnableAnonymousInnerClass(HighestIdTest outerInstance, [email protected] highestId, System.Threading.CountdownEvent latch, AtomicLongArray highestIds, int cc)
 {
     this.outerInstance = outerInstance;
     this._highestId    = highestId;
     this._latch        = latch;
     this._highestIds   = highestIds;
     this._cc           = cc;
     random             = ThreadLocalRandom.current();
 }
Example #55
0
 internal Committer(IdOrderingQueue queue, LongIterator idSource, AtomicBoolean end, System.Threading.CountdownEvent readySignal, System.Threading.CountdownEvent startSignal)
 {
     this.Queue       = queue;
     this.IdSource    = idSource;
     this.End         = end;
     this.ReadySignal = readySignal;
     this.StartSignal = startSignal;
     start();
 }
Example #56
0
//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);
        }
Example #57
0
 /// <summary>
 /// Set a trap for the eviction thread, and return a CountDownLatch with a counter set to 1.
 /// When the eviction thread performs the given trap-event, it will block on the latch after
 /// making the event observable.
 /// </summary>
 public virtual System.Threading.CountdownEvent Trap <T1>(Matcher <T1> trap) where T1 : Event
 {
     lock (this)
     {
         Debug.Assert(trap != null);
         _trapLatch = new System.Threading.CountdownEvent(1);
         this._trap = trap;
         return(_trapLatch);
     }
 }
Example #58
0
        private ICollection <Worker> CreateWorkers(GraphDatabaseService db, System.Threading.CountdownEvent startSignal, AtomicBoolean stopSignal, AtomicReference <Exception> failure, Node parentNode)
        {
            ICollection <Worker> workers = new List <Worker>();

            for (int i = 0; i < 2; i++)
            {
                workers.Add(NewWorker(db, startSignal, stopSignal, failure, parentNode));
            }
            return(workers);
        }
Example #59
0
 internal RunnableReader(GBPTreeConcurrencyITBase <KEY, VALUE> outerInstance, TestCoordinator testCoordinator, System.Threading.CountdownEvent readerReadySignal, System.Threading.CountdownEvent readerStartSignal, AtomicBoolean endSignal, AtomicBoolean failHalt, AtomicReference <Exception> readerError)
 {
     this._outerInstance    = outerInstance;
     this.ReaderReadySignal = readerReadySignal;
     this.ReaderStartSignal = readerStartSignal;
     this.EndSignal         = endSignal;
     this.FailHalt          = failHalt;
     this.ReaderError       = readerError;
     this.TestCoordinator   = testCoordinator;
 }
Example #60
-1
 public StressRunBase(RunData runData)
 {
     RunData = runData;
     Resolver = new DefaultDependencyResolver();
     CancellationTokenSource = new CancellationTokenSource();
     _countDown = new CountdownEvent(runData.Senders);
 }