public void ExecuteAllowsResubmitSameTask()
{
const int nTasks = 1000;
AtomicInteger nRun = new AtomicInteger(0);
IRunnable runnable = new Runnable(() => nRun.IncrementValueAndReturn());
var es = new ThreadPoolExecutor(1, 30, Delays.Long, new ArrayBlockingQueue <IRunnable>(30));
ExecutorService = es;
for (int i = 0; i < nTasks; ++i)
{
for (; ;)
{
try
{
es.Execute(runnable);
break;
}
catch (RejectedExecutionException)
{
}
}
}
// enough time to run all tasks
for (int i = 0; i < 20 && nRun.Value < nTasks; i++)
{
Thread.Sleep(Delays.Short);
}
Assert.AreEqual(nRun.Value, nTasks);
}
public override IMessage PreSend(IMessage message, IMessageChannel channel)
{
Assert.IsNotNull(message);
return
(MessageBuilder.FromMessage(message).SetHeader(GetType().Name, counter.IncrementValueAndReturn()).
Build());
}
public void ExecutionContinuesWithOneThreadWhenFactoryFailesToCreateMore()
{
var nRun = new AtomicInteger(0);
const int nTasks = 100;
var failingThreadFactory = MockRepository.GenerateStub <IThreadFactory>();
failingThreadFactory.Stub(f => f.NewThread(Arg <IRunnable> .Is.NotNull))
.Do(new Function <IRunnable, Thread>(r => new Thread(r.Run))).Repeat.Once();
var es = new ThreadPoolExecutor(nTasks, nTasks, Delays.Long,
new LinkedBlockingQueue <IRunnable>(), failingThreadFactory);
ExecutorService = es;
for (int k = 0; k < nTasks; ++k)
{
es.Execute(() => nRun.IncrementValueAndReturn());
}
for (int i = 0; i < 20 && nRun.Value < nTasks; i++)
{
Thread.Sleep(Delays.Short);
}
Assert.That(es.PoolSize, Is.EqualTo(1));
Assert.AreEqual(nTasks, nRun.Value);
}
public override IMessage PostReceive(IMessage message, IMessageChannel channel)
{
Assert.IsNotNull(channel);
Assert.That(channel, Is.SameAs(_channel));
if (message != null)
{
_messageCounter.IncrementValueAndReturn();
}
_invokedCounter.IncrementValueAndReturn();
return(message);
}
public override void PostSend(IMessage message, IMessageChannel channel, bool sent)
{
Assert.IsNotNull(message);
Assert.IsNotNull(channel);
Assert.That(channel, Is.SameAs(_channel));
if (sent)
{
_sentCounter.IncrementValueAndReturn();
}
_invokedCounter.IncrementValueAndReturn();
}
protected int NextThreadId(bool noException)
{
if (noException || ThreadCount.Value < Threshold)
{
var next = ThreadCount.IncrementValueAndReturn();
if (next <= Threshold)
{
return(next);
}
if (noException)
{
return(-next);
}
}
throw new RejectedExecutionException();
}
public bool Accept(IMessage message)
{
_counter.IncrementValueAndReturn();
return(_shouldAccept);
}
public override bool PreReceive(IMessageChannel channel)
{
counter.IncrementValueAndReturn();
return(false);
}
public override IMessage PreSend(IMessage message, IMessageChannel channel)
{
Assert.IsNotNull(message);
counter.IncrementValueAndReturn();
return(null);
}
public int Next()
{
return(count.IncrementValueAndReturn());
}
public void TestReplyToThreeDeep()
{
var mockConnectionFactory = new Mock <ConnectionFactory>();
var mockConnection = new Mock <IConnection>();
var mockChannel = new Mock <IModel>();
mockConnectionFactory.Setup(m => m.CreateConnection()).Returns(mockConnection.Object);
mockConnection.Setup(m => m.IsOpen).Returns(true);
mockConnection.Setup(m => m.CreateModel()).Returns(mockChannel.Object);
mockChannel.Setup(m => m.CreateBasicProperties()).Returns(() => new BasicProperties());
var template = new RabbitTemplate(new SingleConnectionFactory(mockConnectionFactory.Object));
var replyQueue = new Queue("new.replyTo");
template.ReplyQueue = replyQueue;
var messageProperties = new MessageProperties();
messageProperties.ReplyTo = "replyTo2";
messageProperties.SetHeader(RabbitTemplate.STACKED_REPLY_TO_HEADER, "replyTo1");
messageProperties.SetHeader(RabbitTemplate.STACKED_CORRELATION_HEADER, "a");
var message = new Message(Encoding.UTF8.GetBytes("Hello, world!"), messageProperties);
var props = new List <IBasicProperties>();
var count = new AtomicInteger();
var nestedReplyTo = new List <string>();
var nestedReplyStack = new List <string>();
var nestedCorrelation = new List <string>();
mockChannel.Setup(m => m.BasicPublish(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IBasicProperties>(), It.IsAny <byte[]>())).Callback <string, string, bool, bool, IBasicProperties, byte[]>
(
(a1, a2, a3, a4, a5, a6) =>
{
var basicProps = a5;
props.Add(basicProps);
var springProps = new DefaultMessagePropertiesConverter().ToMessageProperties(basicProps, null, "UTF-8");
var replyMessage = new Message(Encoding.UTF8.GetBytes("!dlrow olleH"), springProps);
if (count.IncrementValueAndReturn() < 2)
{
var anotherMessage = new Message(Encoding.UTF8.GetBytes("Second"), springProps);
replyMessage = template.SendAndReceive(anotherMessage);
nestedReplyTo.Add(replyMessage.MessageProperties.ReplyTo);
nestedReplyStack.Add((string)replyMessage.MessageProperties.Headers[RabbitTemplate.STACKED_REPLY_TO_HEADER]);
nestedCorrelation.Add((string)replyMessage.MessageProperties.Headers[RabbitTemplate.STACKED_CORRELATION_HEADER]);
}
template.OnMessage(replyMessage);
});
var reply = template.SendAndReceive(message);
Assert.IsNotNull(reply);
Assert.AreEqual(2, props.Count);
var basicProperties = props[0];
Assert.AreEqual("new.replyTo", basicProperties.ReplyTo);
Assert.AreEqual("replyTo2:replyTo1", basicProperties.Headers[RabbitTemplate.STACKED_REPLY_TO_HEADER]);
Assert.IsTrue(((string)basicProperties.Headers[RabbitTemplate.STACKED_CORRELATION_HEADER]).EndsWith(":a"));
basicProperties = props[1];
Assert.AreEqual("new.replyTo", basicProperties.ReplyTo);
Assert.AreEqual("new.replyTo:replyTo2:replyTo1", basicProperties.Headers[RabbitTemplate.STACKED_REPLY_TO_HEADER]);
Assert.IsTrue(((string)basicProperties.Headers[RabbitTemplate.STACKED_CORRELATION_HEADER]).EndsWith(":a"));
Assert.AreEqual("replyTo1", reply.MessageProperties.Headers[RabbitTemplate.STACKED_REPLY_TO_HEADER]);
Assert.AreEqual("a", reply.MessageProperties.Headers[RabbitTemplate.STACKED_CORRELATION_HEADER]);
Assert.AreEqual(1, nestedReplyTo.Count);
Assert.AreEqual(1, nestedReplyStack.Count);
Assert.AreEqual(1, nestedCorrelation.Count);
Assert.AreEqual("replyTo2:replyTo1", nestedReplyStack[0]);
Assert.IsTrue(nestedCorrelation[0].EndsWith(":a"));
}
public override IMessage PreSend(IMessage message, IMessageChannel channel)
{
_sendCount.IncrementValueAndReturn();
return(message);
}
