public void ShouldCallExceptionHandlerOnTimeoutException()
{
var waitStrategy = new AsyncWaitStrategy(TimeSpan.FromMilliseconds(1));
var ringBuffer = new RingBuffer <StubEvent>(() => new StubEvent(-1), new SingleProducerSequencer(16, waitStrategy));
var sequenceBarrier = ringBuffer.NewAsyncBarrier();
var exception = new TaskCompletionSource <Exception>();
var exceptionHandler = new TestExceptionHandler <StubEvent>(x => exception.TrySetResult(x.ex));
var eventHandler = new TestAsyncBatchEventHandler <StubEvent> {
OnTimeoutAction = TestException.ThrowOnce()
};
var eventProcessor = CreateEventProcessor(ringBuffer, sequenceBarrier, eventHandler);
ringBuffer.AddGatingSequences(eventProcessor.Sequence);
eventProcessor.SetExceptionHandler(exceptionHandler);
var task = eventProcessor.Start();
Assert.IsTrue(exception.Task.Wait(TimeSpan.FromSeconds(2)));
Assert.AreEqual(0, exceptionHandler.EventExceptionCount);
Assert.AreEqual(1, exceptionHandler.TimeoutExceptionCount);
Assert.AreEqual(0, exceptionHandler.BatchExceptionCount);
eventProcessor.Halt();
Assert.IsTrue(task.Wait(TimeSpan.FromSeconds(2)));
}
public void ShouldAlwaysHalt()
{
var waitStrategy = new AsyncWaitStrategy();
var sequencer = new SingleProducerSequencer(8, waitStrategy);
var barrier = new AsyncSequenceBarrier(sequencer, waitStrategy, new Sequence(-1), new Sequence[0]);
var dp = new ArrayDataProvider <object>(sequencer.BufferSize);
var h1 = new LifeCycleHandler();
var p1 = CreateEventProcessor(dp, barrier, h1);
p1.Halt();
p1.Start();
Assert.IsTrue(h1.WaitStart(TimeSpan.FromSeconds(2)));
Assert.IsTrue(h1.WaitShutdown(TimeSpan.FromSeconds(2)));
for (int i = 0; i < 1000; i++)
{
var h2 = new LifeCycleHandler();
var p2 = CreateEventProcessor(dp, barrier, h2);
p2.Start();
p2.Halt();
Assert.IsTrue(h2.WaitStart(TimeSpan.FromSeconds(2)));
Assert.IsTrue(h2.WaitShutdown(TimeSpan.FromSeconds(2)));
}
for (int i = 0; i < 1000; i++)
{
var h2 = new LifeCycleHandler();
var p2 = CreateEventProcessor(dp, barrier, h2);
p2.Start();
Thread.Yield();
p2.Halt();
Assert.IsTrue(h2.WaitStart(TimeSpan.FromSeconds(2)));
Assert.IsTrue(h2.WaitShutdown(TimeSpan.FromSeconds(2)));
}
}
public void ShouldCallOnTimeout()
{
var waitStrategy = new AsyncWaitStrategy(TimeSpan.FromMilliseconds(1));
var ringBuffer = new RingBuffer <StubEvent>(() => new StubEvent(-1), new SingleProducerSequencer(16, waitStrategy));
var sequenceBarrier = ringBuffer.NewAsyncBarrier();
var onTimeoutSignal = new ManualResetEvent(false);
var eventHandler = new TestAsyncBatchEventHandler <StubEvent> {
OnTimeoutAction = () => onTimeoutSignal.Set()
};
var eventProcessor = CreateEventProcessor(ringBuffer, sequenceBarrier, eventHandler);
ringBuffer.AddGatingSequences(eventProcessor.Sequence);
var task = eventProcessor.Start();
Assert.IsTrue(onTimeoutSignal.WaitOne(TimeSpan.FromSeconds(2)));
eventProcessor.Halt();
Assert.IsTrue(task.Wait(TimeSpan.FromSeconds(2)));
}
public void ShouldWaitFromMultipleThreadsWithTimeoutsAsync()
{
// Arrange
var timeout = TimeSpan.FromMilliseconds(400);
var waitStrategy = new AsyncWaitStrategy(timeout);
var waitResult1 = new TaskCompletionSource <SequenceWaitResult>();
var waitResult2 = new TaskCompletionSource <SequenceWaitResult>();
var sequence1 = new Sequence();
var stopwatch = Stopwatch.StartNew();
var waitTask1 = Task.Run(async() =>
{
waitResult1.SetResult(await waitStrategy.WaitForAsync(10, new DependentSequenceGroup(Cursor), CancellationToken));
Thread.Sleep(1);
sequence1.SetValue(10);
});
var waitTask2 = Task.Run(async() => waitResult2.SetResult(await waitStrategy.WaitForAsync(10, new DependentSequenceGroup(Cursor, sequence1), CancellationToken)));
// Ensure waiting tasks are blocked
AssertIsNotCompleted(waitResult1.Task);
AssertIsNotCompleted(waitResult2.Task);
// Act
// Assert
AssertHasResult(waitResult1.Task, SequenceWaitResult.Timeout);
AssertHasResult(waitResult2.Task, SequenceWaitResult.Timeout);
AssertIsCompleted(waitTask1);
AssertIsCompleted(waitTask2);
// Required to make the test pass on azure pipelines.
var tolerance = TimeSpan.FromMilliseconds(50);
Assert.That(stopwatch.Elapsed, Is.GreaterThanOrEqualTo(timeout - tolerance));
}
