public void TestEnqueueFirstOverridesPriority()
{
PriorityMessageQueue queue = new PriorityMessageQueue();
// Add a higher priority message
InboundMessageDispatch message1 = CreateEnvelope(MsgPriority.High);
queue.Enqueue(message1);
// Add other lower priority messages 'first'.
InboundMessageDispatch message2 = CreateEnvelope(MsgPriority.BelowNormal);
InboundMessageDispatch message3 = CreateEnvelope(MsgPriority.AboveLow);
InboundMessageDispatch message4 = CreateEnvelope(MsgPriority.Low);
queue.EnqueueFirst(message2);
queue.EnqueueFirst(message3);
queue.EnqueueFirst(message4);
// Verify they dequeue in the reverse of the order
// they were added, and not priority order.
Assert.AreSame(message4, queue.DequeueNoWait());
Assert.AreSame(message3, queue.DequeueNoWait());
Assert.AreSame(message2, queue.DequeueNoWait());
Assert.AreSame(message1, queue.DequeueNoWait());
}
public void TestDequeueZeroWhenQueueIsNotEmpty()
{
PriorityMessageQueue queue = new PriorityMessageQueue();
InboundMessageDispatch message = CreateEnvelope();
queue.EnqueueFirst(message);
Assert.False(queue.IsEmpty);
Assert.AreSame(message, queue.Dequeue(1));
}
public void TestDequeueReturnsWhenQueueIsDisposed()
{
PriorityMessageQueue queue = new PriorityMessageQueue();
Task.Run(async() =>
{
await Task.Delay(TimeSpan.FromMilliseconds(100));
queue.Dispose();
});
Assert.IsNull(queue.Dequeue(-1));
}
public void AddMessage_InternallyCallsEnqueue()
{
/* Arrange */
var pq = new Mock <IPriorityQueue <DateTime, IMessage> >();
var pmq = new PriorityMessageQueue(pq.Object);
var stubMessage = new Mock <IMessage>();
/* Act */
pmq.AddMessage(stubMessage.Object);
/* Assert */
pq.Verify(x => x.Enqueue(It.IsAny <DateTime>(), stubMessage.Object), Times.Once());
}
private void DoDequeueWaitsUntilMessageArrivesTestImpl(int timeout)
{
PriorityMessageQueue queue = new PriorityMessageQueue();
InboundMessageDispatch message = CreateEnvelope();
Task.Run(async() =>
{
await Task.Delay(TimeSpan.FromMilliseconds(100));
queue.Enqueue(message);
});
Assert.AreSame(message, queue.Dequeue(timeout));
}
public void TestRemoveFirstSparse()
{
PriorityMessageQueue queue = new PriorityMessageQueue();
queue.Enqueue(CreateEnvelope(MsgPriority.High));
queue.Enqueue(CreateEnvelope(MsgPriority.BelowNormal));
queue.Enqueue(CreateEnvelope(MsgPriority.VeryLow));
Assert.AreEqual(MsgPriority.High, queue.DequeueNoWait().Message.NMSPriority);
Assert.AreEqual(MsgPriority.BelowNormal, queue.DequeueNoWait().Message.NMSPriority);
Assert.AreEqual(MsgPriority.VeryLow, queue.DequeueNoWait().Message.NMSPriority);
Assert.True(queue.IsEmpty);
}
public void AddNullMessage_ArgumentNullException()
{
var pq = new Mock <IPriorityQueue <DateTime, IMessage> >();
var pmq = new PriorityMessageQueue(pq.Object);
try
{
pmq.AddMessage(null);
Assert.IsTrue(false, "Adding null message should throw an argument null exception.");
}
catch (ArgumentNullException)
{
}
}
public void AddMessage_WithFutureExpiration_IsNotPendingMessage()
{
/* Arrange */
var pq = new Mock <IPriorityQueue <DateTime, IMessage> >();
var pmq = new PriorityMessageQueue(pq.Object);
var stubMessage = new Mock <IMessage>();
// Setub the message to return a datetime in the future
stubMessage.Setup(x => x.TimeToDeliver()).Returns(DateTime.Now.AddDays(10));
/* Act */
pmq.AddMessage(stubMessage.Object);
/* Assert */
Assert.AreEqual(0, pmq.PendingMessageCount);
}
public void TestEnqueueFirst()
{
PriorityMessageQueue queue = new PriorityMessageQueue();
InboundMessageDispatch message1 = CreateEnvelope();
InboundMessageDispatch message2 = CreateEnvelope();
InboundMessageDispatch message3 = CreateEnvelope();
queue.EnqueueFirst(message1);
queue.EnqueueFirst(message2);
queue.EnqueueFirst(message3);
Assert.AreSame(message3, queue.DequeueNoWait());
Assert.AreSame(message2, queue.DequeueNoWait());
Assert.AreSame(message1, queue.DequeueNoWait());
}
public void TestClear()
{
PriorityMessageQueue queue = new PriorityMessageQueue();
IEnumerable <InboundMessageDispatch> messages = CreateFullRangePrioritySet();
foreach (InboundMessageDispatch envelope in messages)
{
queue.Enqueue(envelope);
}
Assert.False(queue.IsEmpty);
queue.Clear();
Assert.True(queue.IsEmpty);
Assert.IsNull(queue.DequeueNoWait());
}
public void TestRemoveFirst()
{
PriorityMessageQueue queue = new PriorityMessageQueue();
IEnumerable <InboundMessageDispatch> messages = CreateFullRangePrioritySet();
foreach (InboundMessageDispatch envelope in messages)
{
queue.Enqueue(envelope);
}
for (int i = (int)MsgPriority.Highest; i >= 0; i--)
{
InboundMessageDispatch first = queue.DequeueNoWait();
Assert.AreEqual(i, (int)first.Message.NMSPriority);
}
Assert.True(queue.IsEmpty);
}
public void AddMessage_WithExpirationNow_IsPendingMessage()
{
/* Arrange */
var pq = new Mock <IPriorityQueue <DateTime, IMessage> >();
var pmq = new PriorityMessageQueue(pq.Object);
var stubMessage = new Mock <IMessage>();
// Setub the message to return a datetime in the future
stubMessage.Setup(x => x.TimeToDeliver()).Returns(DateTime.Now);
// first call to Dequeue() returns stubMessage, second call returns a default IMessage
pq.Setup(x => x.Dequeue())
.Returns(stubMessage.Object)
.Callback(() => pq.Setup(y => y.Dequeue())
.Returns(default(IMessage)));
/* Act */
pmq.AddMessage(stubMessage.Object);
/* Assert */
Assert.AreEqual(1, pmq.PendingMessageCount);
}
public void TestRemoveFirstOnEmptyQueue()
{
PriorityMessageQueue queue = new PriorityMessageQueue();
Assert.IsNull(queue.DequeueNoWait());
}
public void TestDequeueZeroWhenQueueIsEmpty()
{
PriorityMessageQueue queue = new PriorityMessageQueue();
Assert.IsNull(queue.Dequeue(0));
}
public void TestCreate()
{
PriorityMessageQueue queue = new PriorityMessageQueue();
Assert.AreEqual(0, queue.Count);
}
