public void CountReturnsInitialCountAndDecreasesAftercountDown() { CountDownLatch l = new CountDownLatch(2); Assert.AreEqual(2, l.Count); l.CountDown(); Assert.AreEqual(1, l.Count); }
public void CountDownDecrementsCountWhenPositiveAndHasNoEffectWhenZero() { CountDownLatch l = new CountDownLatch(1); Assert.AreEqual(1, l.Count); l.CountDown(); Assert.AreEqual(0, l.Count); l.CountDown(); Assert.AreEqual(0, l.Count); }
public void TimedAwaitReturnsFalseOnNonPositiveWaitTime() { CountDownLatch l = new CountDownLatch(1); ThreadManager.StartAndAssertRegistered( "T1", delegate { Assert.IsTrue(l.Count == 1); Assert.IsFalse(l.Await(TimeSpan.Zero)); }); ThreadManager.JoinAndVerify(Delays.Short); }
public void AwaitChokesIfInterruptedBeforeCountedDown() { CountDownLatch l = new CountDownLatch(1); Thread t = ThreadManager.StartAndAssertRegistered( "T1", delegate { Assert.IsTrue(l.Count > 0); Assert.Throws<ThreadInterruptedException>(l.Await); }); Assert.AreEqual(l.Count, 1); t.Interrupt(); ThreadManager.JoinAndVerify(); }
public void AwaitReturnsImmediatelyIfCountIsZero() { CountDownLatch l = new CountDownLatch(1); l.CountDown(); ThreadManager.StartAndAssertRegistered( "T1", delegate { Assert.IsTrue(l.Count == 0); l.Await(); }); ThreadManager.JoinAndVerify(); }
public void ToStringIndicatesCurrentCount() { CountDownLatch s = new CountDownLatch(2); String us = s.ToString(); Assert.IsTrue(us.IndexOf("Count = 2") >= 0); s.CountDown(); String s1 = s.ToString(); Assert.IsTrue(s1.IndexOf("Count = 1") >= 0); s.CountDown(); String s2 = s.ToString(); Assert.IsTrue(s2.IndexOf("Count = 0") >= 0); }
public void AwaitChokesIfInterruptedBeforeCountedDown() { CountDownLatch l = new CountDownLatch(1); Thread t = ThreadManager.StartAndAssertRegistered( "T1", delegate { Assert.IsTrue(l.Count > 0); Assert.Throws <ThreadInterruptedException>(l.Await); }); Assert.AreEqual(l.Count, 1); t.Interrupt(); ThreadManager.JoinAndVerify(); }
public void AwaitReturnsImmediatelyIfCountIsZero() { CountDownLatch l = new CountDownLatch(1); l.CountDown(); ThreadManager.StartAndAssertRegistered( "T1", delegate { Assert.IsTrue(l.Count == 0); l.Await(); }); ThreadManager.JoinAndVerify(); }
public void TestListenerTransactionalFails() { this.transactional = true; var latch = new CountDownLatch(this.messageCount); this.container = this.CreateContainer(new TxTestListener(latch, true, this)); for (var i = 0; i < this.txSize; i++) { this.template.ConvertAndSend(this.queue.Name, i + "foo"); } var timeout = Math.Min(1 + this.messageCount / (4 * this.concurrentConsumers), 30); logger.Debug("Waiting for messages with timeout = " + timeout + " (s)"); var waited = latch.Await(new TimeSpan(0, 0, 0, timeout)); Assert.True(waited, "Timed out waiting for message"); Assert.Null(this.template.ReceiveAndConvert(this.queue.Name)); }
public void TimedAwaitReturnsImmediatelyIfCountIsZero() { CountDownLatch l = new CountDownLatch(1); l.CountDown(); ThreadManager.StartAndAssertRegistered( "T1", delegate { Assert.IsTrue(l.Count == 0); Assert.IsTrue(l.Await(Delays.Medium)); Assert.IsTrue(l.Await(TimeSpan.Zero)); }); ThreadManager.JoinAndVerify(Delays.Short); }
public void TimedAwaitTimesOutIfNotCountedDownBeforeTimeout() { CountDownLatch l = new CountDownLatch(1); ThreadManager.StartAndAssertRegistered( "T1", delegate { Assert.IsTrue(l.Count > 0); Assert.IsFalse(l.Await(Delays.Short)); Assert.IsTrue(l.Count > 0); }); Assert.AreEqual(l.Count, 1); ThreadManager.JoinAndVerify(); Assert.AreEqual(l.Count, 1); }
public void TestBlockingReceiveWithTimeout() { QueueChannel channel = new QueueChannel(); AtomicBoolean receiveInterrupted = new AtomicBoolean(false); CountDownLatch latch = new CountDownLatch(1); Thread t = new Thread(new ThreadStart(delegate { IMessage message = channel.Receive(new TimeSpan(10000)); receiveInterrupted.Value = true; Assert.IsTrue(message == null); latch.CountDown(); })); t.Start(); //Assert.IsFalse(receiveInterrupted.Value); t.Interrupt(); latch.Await(); Assert.IsTrue(receiveInterrupted.Value); }
public void TimedAwaitReturnsAfterCountDownToZero() { CountDownLatch l = new CountDownLatch(2); ThreadManager.StartAndAssertRegistered( "T1", delegate { Assert.IsTrue(l.Count > 0); Assert.IsTrue(l.Await(Delays.Small)); }); Assert.AreEqual(l.Count, 2); Thread.Sleep(Delays.Short); l.CountDown(); Assert.AreEqual(l.Count, 1); l.CountDown(); Assert.AreEqual(l.Count, 0); ThreadManager.JoinAndVerify(); }
public void AwaitReturnsAfterCountDownToZeroButNotBefore() { CountDownLatch l = new CountDownLatch(2); ThreadManager.StartAndAssertRegistered( "T1", delegate { Assert.IsTrue(l.Count > 0); l.Await(); Assert.IsTrue(l.Count == 0); }); Assert.AreEqual(l.Count, 2); Thread.Sleep(Delays.Short); l.CountDown(); Assert.AreEqual(l.Count, 1); l.CountDown(); Assert.AreEqual(l.Count, 0); ThreadManager.JoinAndVerify(); }
public void TimedAwaitTimesOutIfNotCountedDownBeforeTimeout() { CountDownLatch l = new CountDownLatch(1); ThreadManager.StartAndAssertRegistered( "T1", delegate { Assert.IsTrue(l.Count > 0); Assert.IsFalse(l.Await(Delays.Short)); Assert.IsTrue(l.Count > 0); }); Assert.AreEqual(l.Count, 1); ThreadManager.JoinAndVerify(); Assert.AreEqual(l.Count, 1); }
public void TimedAwaitReturnsImmediatelyIfCountIsZero() { CountDownLatch l = new CountDownLatch(1); l.CountDown(); ThreadManager.StartAndAssertRegistered( "T1", delegate { Assert.IsTrue(l.Count == 0); Assert.IsTrue(l.Await(Delays.Medium)); Assert.IsTrue(l.Await(TimeSpan.Zero)); }); ThreadManager.JoinAndVerify(Delays.Short); }
public void TimedAwaitReturnsFalseOnNonPositiveWaitTime() { CountDownLatch l = new CountDownLatch(1); ThreadManager.StartAndAssertRegistered( "T1", delegate { Assert.IsTrue(l.Count == 1); Assert.IsFalse(l.Await(TimeSpan.Zero)); }); ThreadManager.JoinAndVerify(Delays.Short); }
public SendWithReturnAddressChannel(IList<string> replies, CountDownLatch latch) { _replies = replies; _latch = latch; }
public void sendWithReturnAddress() { IList<string> replies = new List<string>(3); CountDownLatch latch = new CountDownLatch(3); IMessageChannel replyChannel = new SendWithReturnAddressChannel(replies, latch); MessageChannelTemplate template = new MessageChannelTemplate(); IMessage message1 = MessageBuilder.WithPayload("test1").SetReplyChannel(replyChannel).Build(); IMessage message2 = MessageBuilder.WithPayload("test2").SetReplyChannel(replyChannel).Build(); IMessage message3 = MessageBuilder.WithPayload("test3").SetReplyChannel(replyChannel).Build(); template.Send(message1, requestChannel); template.Send(message2, requestChannel); template.Send(message3, requestChannel); latch.Await(TimeSpan.FromMilliseconds(2000)); Assert.That(latch.Count, Is.EqualTo(0)); Assert.IsTrue(replies.Contains("TEST1")); Assert.IsTrue(replies.Contains("TEST2")); Assert.IsTrue(replies.Contains("TEST3")); }
public void TestListenerTransactionalSunnyDay() { transactional = true; CountDownLatch latch = new CountDownLatch(messageCount); container = CreateContainer(new TxTestListener(latch, false, this)); for (int i = 0; i < messageCount; i++) { template.ConvertAndSend(queue.Name, i + "foo"); } int timeout = Math.Min(1 + messageCount / (4 * concurrentConsumers), 30); logger.Debug("Waiting for messages with timeout = " + timeout + " (s)"); var waited = latch.Await(new TimeSpan(0, 0, 0, timeout)); Assert.True(waited, "Timed out waiting for message"); Assert.Null(template.ReceiveAndConvert(queue.Name)); }
/// <summary> /// Does the listener with exception test. /// </summary> /// <param name="latch">The latch.</param> /// <param name="listener">The listener.</param> /// <remarks></remarks> private void DoListenerWithExceptionTest(CountDownLatch latch, object listener) { this.container = this.CreateContainer(listener); if (this.acknowledgeMode.TransactionAllowed()) { // Should only need one message if it is going to fail for (var i = 0; i < this.concurrentConsumers; i++) { this.template.ConvertAndSend(this.queue.Name, i + "foo"); } } else { for (var i = 0; i < this.messageCount; i++) { this.template.ConvertAndSend(this.queue.Name, i + "foo"); } } try { var waited = latch.Await(new TimeSpan(0, 0, 0, (5 + Math.Max(1, this.messageCount / 20)))); Assert.True(waited, "Timed out waiting for message"); } finally { // Wait for broker communication to finish before trying to stop // container Thread.Sleep(300); this.container.Shutdown(); Thread.Sleep(300); } if (this.acknowledgeMode.TransactionAllowed()) { Assert.NotNull(this.template.ReceiveAndConvert(this.queue.Name)); } else { Assert.Null(this.template.ReceiveAndConvert(this.queue.Name)); } }
/// <summary> /// Initializes a new instance of the <see cref="ChannelAwareListener"/> class. /// </summary> /// <param name="latch">The latch.</param> /// <remarks></remarks> public ChannelAwareListener(CountDownLatch latch) : this(latch, false) { }
public void TestImmediateReceive() { AtomicBoolean messageReceived = new AtomicBoolean(false); QueueChannel channel = new QueueChannel(); CountDownLatch latch1 = new CountDownLatch(1); CountDownLatch latch2 = new CountDownLatch(1); IExecutor singleThreadExecutor = Executors.NewSingleThreadExecutor(); singleThreadExecutor.Execute( delegate { IMessage message = channel.Receive(TimeSpan.Zero); if (message != null) { messageReceived.Value = true; } latch1.CountDown(); }); latch1.Await(); singleThreadExecutor.Execute( delegate { channel.Send(new Message<string>("testing")); }); Assert.IsFalse(messageReceived.Value); singleThreadExecutor.Execute( delegate { IMessage message = channel.Receive(TimeSpan.Zero); if (message != null) { messageReceived.Value = true; } latch2.CountDown(); }); latch2.Await(); Assert.IsNotNull(messageReceived.Value); }
public void CountDownDecrementsCountWhenPositiveAndHasNoEffectWhenZero() { CountDownLatch l = new CountDownLatch(1); Assert.AreEqual(1, l.Count); l.CountDown(); Assert.AreEqual(0, l.Count); l.CountDown(); Assert.AreEqual(0, l.Count); }
/// <summary> /// Initializes a new instance of the <see cref="TxTestListener"/> class. /// </summary> /// <param name="latch">The latch.</param> /// <param name="fail">if set to <c>true</c> [fail].</param> /// <param name="outer">The outer.</param> /// <remarks></remarks> public TxTestListener(CountDownLatch latch, bool fail, MessageListenerTxSizeIntegrationTests outer) { this.latch = latch; this.fail = fail; this.outer = outer; }
/// <summary> /// Initializes a new instance of the <see cref="SimplePocoListener"/> class. /// </summary> /// <param name="latch">The latch.</param> /// <remarks></remarks> public SimplePocoListener(CountDownLatch latch) : this(latch, false) { }
public void ToStringIndicatesCurrentCount() { CountDownLatch s = new CountDownLatch(2); String us = s.ToString(); Assert.IsTrue(us.IndexOf("Count = 2") >= 0); s.CountDown(); String s1 = s.ToString(); Assert.IsTrue(s1.IndexOf("Count = 1") >= 0); s.CountDown(); String s2 = s.ToString(); Assert.IsTrue(s2.IndexOf("Count = 0") >= 0); }
/// <summary> /// Does the sunny day test. /// </summary> /// <param name="latch">The latch.</param> /// <param name="listener">The listener.</param> /// <remarks></remarks> private void DoSunnyDayTest(CountDownLatch latch, object listener) { this.container = this.CreateContainer(listener); for (var i = 0; i < this.messageCount; i++) { this.template.ConvertAndSend(this.queue.Name, i + "foo"); } var waited = latch.Await(new TimeSpan(0, 0, 0, Math.Max(2, this.messageCount / 40))); Assert.True(waited, "Timed out waiting for message"); Assert.Null(this.template.ReceiveAndConvert(this.queue.Name)); }
/// <summary> /// Initializes a new instance of the <see cref="ChannelAwareListener"/> class. /// </summary> /// <param name="latch">The latch.</param> /// <param name="fail">if set to <c>true</c> [fail].</param> /// <remarks></remarks> public ChannelAwareListener(CountDownLatch latch, bool fail) { this.latch = latch; this.fail = fail; }
/// <summary> /// Initializes a new instance of the <see cref="SimplePocoListener"/> class. /// </summary> /// <param name="latch">The latch.</param> /// <param name="fail">if set to <c>true</c> [fail].</param> /// <remarks></remarks> public SimplePocoListener(CountDownLatch latch, bool fail) { this.latch = latch; this.fail = fail; }
public TestObject(int countdown) { _latch = new CountDownLatch(countdown); }
public void CountReturnsInitialCountAndDecreasesAftercountDown() { CountDownLatch l = new CountDownLatch(2); Assert.AreEqual(2, l.Count); l.CountDown(); Assert.AreEqual(1, l.Count); }
public void Reset() { _latch = new CountDownLatch(1); _hasRun.Value = false; }
public void TestSimpleSendAndReceive() { AtomicBoolean messageReceived = new AtomicBoolean(false); CountDownLatch latch = new CountDownLatch(1); QueueChannel channel = new QueueChannel(); new Thread(new ThreadStart(delegate { IMessage message = channel.Receive(); if (message != null) { messageReceived.Value = true; latch.CountDown(); } })).Start(); Assert.That(messageReceived.Value, Is.False); channel.Send(new Message<string>("testing")); latch.Await(new TimeSpan(0, 0, 0, 0, 25)); Assert.That(messageReceived.Value, Is.True); }
public void TestPocoListenerSunnyDay() { var latch = new CountDownLatch(this.messageCount); this.DoSunnyDayTest(latch, new MessageListenerAdapter(new SimplePocoListener(latch))); }
public void TestBlockingSendWithNoTimeout() { QueueChannel channel = new QueueChannel(1); bool result1 = channel.Send(new Message<string>("test-1")); Assert.IsTrue(result1); AtomicBoolean SendInterrupted = new AtomicBoolean(false); CountDownLatch latch = new CountDownLatch(1); Thread t = new Thread(new ThreadStart(delegate { channel.Send(new Message<string>("test-2")); SendInterrupted.Value = true; latch.CountDown(); })); t.Start(); //Assert.IsFalse(SendInterrupted.Value); t.Interrupt(); latch.Await(); Assert.IsTrue(SendInterrupted.Value); }
public void TestPocoListenerWithException() { var latch = new CountDownLatch(this.messageCount); this.DoListenerWithExceptionTest(latch, new MessageListenerAdapter(new SimplePocoListener(latch, true))); }
public void TestMultipleMessagesWithResponseCorrelator() { IApplicationContext context = TestUtils.GetContext(@"Gateway\gatewayWithResponseCorrelator.xml"); const int numRequests = 500; ITestService service = (ITestService) context.GetObject("proxy"); string[] results = new string[numRequests]; CountDownLatch latch = new CountDownLatch(numRequests); IExecutor executor = Executors.NewFixedThreadPool(numRequests); for (int i = 0; i < numRequests; i++) { int count = i; executor.Execute(delegate { // add some randomness to the ordering of requests try { Thread.Sleep(new Random().Next(100)); } catch (ThreadInterruptedException e) { // ignore } results[count] = service.RequestReply("test-" + count); latch.CountDown(); }); } latch.Await(TimeSpan.FromSeconds(10)); for (int i = 0; i < numRequests; i++) { Assert.That(results[i], Is.EqualTo("test-" + i + "!!!")); } TestChannelInterceptor interceptor = (TestChannelInterceptor) context.GetObject("interceptor"); Assert.That(interceptor.SentCount, Is.EqualTo(numRequests)); Assert.That(interceptor.ReceivedCount, Is.EqualTo(numRequests)); }
public void TestListenerWithException() { var latch = new CountDownLatch(this.messageCount); this.DoListenerWithExceptionTest(latch, new Listener(latch, true)); }