public void MoveNextBlocks()
{
var finished = new ManualResetEvent(false);
var enumerator = new EnqueueableEnumerator <Tick>(true);
// producer
int count = 0;
Task.Run(() =>
{
while (!finished.WaitOne(TimeSpan.FromMilliseconds(50)))
{
enumerator.Enqueue(new Tick(DateTime.Now, Symbols.SPY, 100, 101));
count++;
// 5 data points is plenty
if (count > 5)
{
finished.Set();
enumerator.Stop();
}
}
});
// consumer
int dequeuedCount = 0;
bool encounteredError = false;
var consumerTaskFinished = new ManualResetEvent(false);
Task.Run(() =>
{
while (enumerator.MoveNext())
{
dequeuedCount++;
if (enumerator.Current == null)
{
encounteredError = true;
}
}
consumerTaskFinished.Set();
});
finished.WaitOne(Timeout.Infinite);
consumerTaskFinished.WaitOne(Timeout.Infinite);
Assert.IsFalse(enumerator.MoveNext());
Assert.IsFalse(encounteredError);
Assert.AreEqual(count, dequeuedCount);
enumerator.Dispose();
}
public void SetErrorHandlerExitsOnTrueReturn()
{
var enqueable = new EnqueueableEnumerator <BaseData>();
var exchange = new BaseDataExchange("test");
var cancellationToken = new CancellationTokenSource();
Task.Factory.StartNew(() =>
{
while (!cancellationToken.IsCancellationRequested)
{
Thread.Sleep(10);
enqueable.Enqueue(new Tick {
Symbol = Symbols.SPY, Time = DateTime.UtcNow
});
}
});
var first = true;
var errorCaught = new AutoResetEvent(true);
BaseData last = null;
exchange.SetErrorHandler(error =>
{
errorCaught.Set();
return(true);
});
exchange.AddEnumerator(Symbols.SPY, enqueable, handleData: spy =>
{
if (first)
{
first = false;
throw new Exception();
}
last = spy;
});
Task.Run(() => exchange.Start());
Assert.IsTrue(errorCaught.WaitOne(DefaultTimeout));
exchange.Stop();
Assert.IsNull(last);
enqueable.Dispose();
cancellationToken.Cancel();
}
public void EndsQueueConsumption()
{
var enqueable = new EnqueueableEnumerator <BaseData>();
var exchange = new BaseDataExchange("test");
var cancellationToken = new CancellationTokenSource();
Task.Run(() =>
{
while (!cancellationToken.IsCancellationRequested)
{
Thread.Sleep(10);
enqueable.Enqueue(new Tick {
Symbol = Symbols.SPY, Time = DateTime.UtcNow
});
}
});
BaseData last = null;
var lastUpdated = new AutoResetEvent(false);
exchange.AddEnumerator(Symbols.SPY, enqueable, handleData: spy =>
{
last = spy;
lastUpdated.Set();
});
var finishedRunning = new AutoResetEvent(false);
Task.Run(() => { exchange.Start(); finishedRunning.Set(); });
Assert.IsTrue(lastUpdated.WaitOne(DefaultTimeout));
exchange.Stop();
cancellationToken.Cancel();
Assert.IsTrue(finishedRunning.WaitOne(DefaultTimeout));
var endTime = DateTime.UtcNow;
Assert.IsNotNull(last);
Assert.IsTrue(last.Time <= endTime);
enqueable.Dispose();
}
public void DefaultErrorHandlerDoesNotStopQueueConsumption()
{
var enqueable = new EnqueueableEnumerator <BaseData>();
var exchange = new BaseDataExchange("test");
var cancellationToken = new CancellationTokenSource();
Task.Run(() =>
{
while (!cancellationToken.IsCancellationRequested)
{
Thread.Sleep(10);
enqueable.Enqueue(new Tick {
Symbol = Symbols.SPY, Time = DateTime.UtcNow
});
}
});
var first = true;
BaseData last = null;
var lastUpdated = new AutoResetEvent(false);
exchange.AddEnumerator(Symbols.SPY, enqueable, handleData: spy =>
{
if (first)
{
first = false;
throw new Exception("This exception should be swalloed by the exchange!");
}
last = spy;
lastUpdated.Set();
});
Task.Run(() => exchange.Start());
Assert.IsTrue(lastUpdated.WaitOne(DefaultTimeout));
exchange.Stop();
cancellationToken.Cancel();
enqueable.Dispose();
}
public void RecordsInternalQueueCount()
{
var enumerator = new EnqueueableEnumerator <Tick>();
var currentTime = new DateTime(2015, 12, 01);
var tick = new Tick(currentTime, Symbols.SPY, 100, 101);
enumerator.Enqueue(tick);
Assert.AreEqual(1, enumerator.Count);
tick = new Tick(currentTime, Symbols.SPY, 100, 101);
enumerator.Enqueue(tick);
Assert.AreEqual(2, enumerator.Count);
enumerator.MoveNext();
Assert.AreEqual(1, enumerator.Count);
enumerator.MoveNext();
Assert.AreEqual(0, enumerator.Count);
enumerator.Dispose();
}
public void PassesTicksStraightThrough()
{
var enumerator = new EnqueueableEnumerator <Tick>();
// add some ticks
var currentTime = new DateTime(2015, 10, 08);
// returns true even if no data present until stop is called
Assert.IsTrue(enumerator.MoveNext());
Assert.IsNull(enumerator.Current);
var tick1 = new Tick(currentTime, Symbols.SPY, 199.55m, 199, 200)
{
Quantity = 10
};
enumerator.Enqueue(tick1);
Assert.IsTrue(enumerator.MoveNext());
Assert.AreEqual(tick1, enumerator.Current);
Assert.IsTrue(enumerator.MoveNext());
Assert.IsNull(enumerator.Current);
var tick2 = new Tick(currentTime, Symbols.SPY, 199.56m, 199.21m, 200.02m)
{
Quantity = 5
};
enumerator.Enqueue(tick2);
Assert.IsTrue(enumerator.MoveNext());
Assert.AreEqual(tick2, enumerator.Current);
enumerator.Stop();
Assert.IsFalse(enumerator.MoveNext());
Assert.IsNull(enumerator.Current);
enumerator.Dispose();
}
public void RecordsMostRecentlyEnqueuedItem()
{
var enumerator = new EnqueueableEnumerator <Tick>();
var currentTime = new DateTime(2015, 12, 01);
var tick1 = new Tick(currentTime, Symbols.SPY, 100, 101);
enumerator.Enqueue(tick1);
Assert.AreEqual(null, enumerator.Current);
Assert.AreEqual(tick1, enumerator.LastEnqueued);
var tick2 = new Tick(currentTime, Symbols.SPY, 100, 101);
enumerator.Enqueue(tick2);
Assert.AreEqual(tick2, enumerator.LastEnqueued);
enumerator.MoveNext();
Assert.AreEqual(tick1, enumerator.Current);
enumerator.MoveNext();
Assert.AreEqual(tick2, enumerator.Current);
enumerator.Dispose();
}