public static void Assert_EnqueueSingleProducerBounded(IEventQueueStorageStrategy <TestEvent> strategy, int maxEventCount)
{
/* PRECONDITION */
Debug.Assert(strategy != null);
Debug.Assert(maxEventCount >= 0);
Debug.Assert(strategy.IsClosed);
/* GIVEN */
var expectedEventCount = (maxEventCount < maxEvents) ? maxEventCount : maxEvents;
var producer = new TestProducer(strategy);
var consumer = new TestConsumer(strategy);
using var produceEvent = new ManualResetEvent(false);
using var consumeEvent = new ManualResetEvent(false);
/* WHEN */
strategy.Open();
Assert.IsTrue(!strategy.IsClosed);
consumer.Consume((@event, num) => num < expectedEventCount, result => result.EventSuccess(consumeEvent));
producer.Produce(num => num < maxEvents, result => result.EventSuccess(produceEvent));
/* THEN */
Assert.IsTrue(produceEvent.WaitOne(maxWaitTime), "Producer did not complete successfully");
Assert.IsTrue(consumeEvent.WaitOne(maxWaitTime), "Consumer did not complete successfully");
}
public void TestBoundedSingleConsumer_IsOccupied()
{
/* PRECONDITION */
Debug.Assert(Strategy != null);
using var allowedConsumerDidNotFailed = new ManualResetEvent(true);
using var invalidConsumerFailed = new ManualResetEvent(false);
/* GIVEN */
var consumer = new TestConsumer(Strategy);
consumer.Consume(
(@event, index) => true,
result => result?.EventSuccess(allowedConsumerDidNotFailed));
/* WHEN */
var invalidConsumer = new TestConsumer(Strategy);
invalidConsumer.Consume(
(@event, num) => true,
result => result?.EventThrows <ChannelConsumingException>(invalidConsumerFailed));
/* THEN */
Assert.IsTrue(allowedConsumerDidNotFailed.WaitOne(maxWaitTime), "An Error occurred while consuming using valid consumers.");
Assert.IsTrue(invalidConsumerFailed.WaitOne(maxWaitTime), "InvalidConsumer should fail.");
}
public void TestMultiConsumer_FreeConsumer()
{
/* PRECONDITION */
Debug.Assert(Strategy != null);
Debug.Assert(Strategy.IsClosed);
using var allowedConsumerDidFail = new ManualResetEvent(false);
using var retryConsumerDidFail = new ManualResetEvent(false);
var validationConsumer = new TestConsumer(Strategy);
var shouldContinue = true;
Strategy.Open();
/* GIVEN */
validationConsumer.Consume(
(@event, index) => shouldContinue,
result => result.EventThrows <ChannelConsumingException>(allowedConsumerDidFail));
/* WHEN */
var producer = new TestProducer(Strategy);
producer.ProduceUnconditionally();
shouldContinue = false;
// We wait until the current consumer exits. After that we can try to retry consuming which should not cause an error.
Assert.IsFalse(allowedConsumerDidFail.WaitOne(500));
// Reopen the strategy so all consumers are freed and new consumers can be attached!
Strategy.Close();
Strategy.Open();
var newConsumer = new TestConsumer(Strategy);
newConsumer.Consume((@event, num) => true, result => result.EventThrows <ChannelConsumingException>(retryConsumerDidFail));
/* THEN */
Assert.IsFalse(allowedConsumerDidFail.WaitOne(500), "An Error occurred while consuming using valid consumers.");
Assert.IsFalse(retryConsumerDidFail.WaitOne(500), "The retry consumer did unexpectedly fail with an exception.");
}
public static void Assert_EnqueueSingleProducerUnbounded(IEventQueueStorageStrategy <TestEvent> strategy)
{
/* PRECONDITION */
Debug.Assert(strategy != null);
Debug.Assert(strategy.IsClosed);
/* GIVEN */
strategy.Open();
var producer = new TestProducer(strategy);
var consumer = new TestConsumer(strategy);
using var produceEvent = new ManualResetEvent(false);
using var consumeEvent = new ManualResetEvent(false);
/* WHEN */
consumer.Consume((@event, num) => num < maxEvents, result => result.EventSuccess(consumeEvent));
producer.Produce(num => num < maxEvents, result => result.EventSuccess(produceEvent));
/* THEN */
Assert.IsTrue(produceEvent.WaitOne(maxWaitTime), "Producer did not finish in time");
Assert.IsTrue(consumeEvent.WaitOne(maxWaitTime), "Consumer did not receive events in time");
}
public void TestMultiConsumer_DistributeEvents()
{
/* PRECONDITION */
Debug.Assert(defaultMaxConsumer > 1);
Debug.Assert(defaultMaxEvents > 0);
Debug.Assert(Strategy != null);
Debug.Assert(Strategy.IsClosed);
using var consumersReceivedEventsIndividually = new CountdownEvent(defaultMaxConsumer);
using var producerFinished = new ManualResetEvent(false);
var maxEvents = defaultMaxEvents / 2;
/* GIVEN */
Strategy.Open();
for (var index = 0; index < defaultMaxConsumer; index++)
{
var consumer = new TestConsumer(Strategy);
consumer.Consume(
(@event, index) => index < maxEvents,
result =>
{
if (result != null && result.IsSuccess())
{
consumersReceivedEventsIndividually.Signal();
}
});
}
/* WHEN */
var producer = new TestProducer(Strategy);
producer.Produce(num => num < maxEvents, result => result.EventSuccess(producerFinished));
/* THEN */
Assert.IsTrue(producerFinished.WaitOne(maxWaitTime), "Producer was not able to queue all events!");
Assert.IsTrue(consumersReceivedEventsIndividually.Wait(maxWaitTime * defaultMaxConsumer), "Not all consumers received the event!");
}
