public void Add_WhenItemsHaveUnorderedTimeStamps_ThrowsException()
{
// Arrange
var window = new SlidingWindow <Trade>(TimeSpan.FromMilliseconds(100), 1000, Trade.CreateCalculation);
var olderItem = CreateTradeItem(DateTime.Now.AddMilliseconds(-1000));
var newerItem = CreateTradeItem(DateTime.Now);
// Act
window.Add(newerItem);
// Assert
Assert.Throws <ArgumentException>(() => window.Add(olderItem));
}
public void Add_WhenItemIsNotInsideOfWindowRangeButItsBucketIs_ShouldIncludeTheBucketInWindow()
{
// Arrange
var items = CreateTradeItemsList(new[] { 0, 990 }, new[] { 10, 20 });
var window = new SlidingWindow <Trade>(TimeSpan.FromMilliseconds(999), 100, Trade.CreateCalculation, testDateTimeProvider);
// Act
testDateTimeProvider.Now = items[0].TimeStamp;
window.Add(items[0]);
testDateTimeProvider.Now = items[1].TimeStamp;
window.Add(items[1]);
var calculation = window.GetCalculationFor(items[0].TimeStamp.AddMilliseconds(900)) as Calculation;
// Assert
Assert.Equal((15, 2), (calculation.Volume, calculation.CurrentCount));
}
public void Add_WhenFirstBucketShiftedOutsideOfTheWindow_ShouldRemoveTheBucketFromWindow()
{
// Arrange
var items = CreateTradeItemsList(new[] { -90, 0 }, new[] { 10, 20 });
var window = new SlidingWindow <Trade>(TimeSpan.FromMilliseconds(100), 10, Trade.CreateCalculation, testDateTimeProvider);
// Act
testDateTimeProvider.Now = items[0].TimeStamp;
window.Add(items[0]);
testDateTimeProvider.Now = items[1].TimeStamp;
window.Add(items[1]);
testDateTimeProvider.Now = testDateTimeProvider.Now.AddMilliseconds(20);
var calculationAfterSecondItem = window.GetCurrentWindowCalculation() as Calculation;
// Assert
Assert.Equal((items[1].Volume, 1), (calculationAfterSecondItem.Volume, calculationAfterSecondItem.CurrentCount));
}
public void Add_IfTimestampsDifferMoreThanBucketInterval_ShouldCreateNewBucket(int bucketInterval, int shift)
{
// Arrange
var window = new SlidingWindow <Trade>(TimeSpan.FromMinutes(1), bucketInterval, Trade.CreateCalculation);
var olderItem = CreateTradeItem(DateTime.Now.AddMilliseconds(shift));
var newerItem = CreateTradeItem(DateTime.Now);
// Act
window.Add(olderItem);
window.Add(newerItem);
// Assert
var buckets = window.GetBuckets().Item2;
var firstBucket = buckets[window.GetTimeStampKey(olderItem.TimeStamp)];
var secondBucket = buckets[window.GetTimeStampKey(newerItem.TimeStamp)];
Assert.NotEqual(firstBucket, secondBucket);
}
public void Add_NewItemAdded_ShouldCleanUpOldBuckets()
{
// Arrange
var window = new SlidingWindow <Trade>(TimeSpan.FromMilliseconds(100), 1000, Trade.CreateCalculation, testDateTimeProvider);
var olderItem = CreateTradeItem(DateTime.Now.AddMilliseconds(-1000));
var newerItem = CreateTradeItem(DateTime.Now);
// Act
testDateTimeProvider.Now = olderItem.TimeStamp;
window.Add(olderItem);
testDateTimeProvider.Now = newerItem.TimeStamp;
window.Add(newerItem);
// Assert
var bucketsList = window.GetBuckets().Item1;
var buckets = window.GetBuckets().Item2;
Assert.Single(buckets);
Assert.Single(bucketsList);
Assert.False(buckets.ContainsKey(window.GetTimeStampKey(olderItem.TimeStamp)));
Assert.Equal(window.GetTimeStampKey(newerItem.TimeStamp), bucketsList.First.Value.TimeStampKey);
}
public void GetCurrentCalculation_WhenMultipleItemsAdded_ShouldUpdateWindowCorrectly(
Trade[] items, int windowLengthInMs, decimal expectedVolume, decimal expectedCount)
{
// Arrange
var window = new SlidingWindow <Trade>(TimeSpan.FromMilliseconds(windowLengthInMs), 10, Trade.CreateCalculation, testDateTimeProvider);
// Act
foreach (var item in items)
{
testDateTimeProvider.Now = item.TimeStamp;
window.Add(item);
}
testDateTimeProvider.Now = items[^ 1].TimeStamp;
public void Main(string argument, UpdateType updateSource)
{
Log.ClearScreen();
Cycles++;
Log.Info($"Cycles: {Cycles}");
Log.Info($"State: {RunState}");
Log.Info();
switch (updateSource)
{
case UpdateType.Terminal:
argument = argument.ToUpper();
if (Commands.ContainsKey(argument))
{
Commands[argument](argument, updateSource);
}
else
{
// TODO: Unhandled argument. Panic?
}
break;
case UpdateType.Update1:
if (Updater != null)
{
Updater.Update();
}
if (Ticks.ContainsKey(RunState))
{
Ticks[RunState]?.Invoke(argument, updateSource);
}
else
{
throw new Exception($"Unhandled state during dispatch: {RunState}");
}
break;
default:
throw new Exception($"Unhandled update source: {updateSource}");
}
Log.Info();
Log.Info($"Last run time: {Runtime.LastRunTimeMs:N4}ms");
Average.Add((int)(Runtime.LastRunTimeMs * 10000));
Log.Info($"Min: {Average.Min / 10000f:N4}, Avg: {Average.Average / 10000f:N4}, Max: {Average.Max / 10000f:N4}");
Log.Info($"Instructions: {Runtime.CurrentInstructionCount}/{Runtime.MaxInstructionCount}");
}
public void SlidingWindow_WhenWindowLengthIsNotAFactorOfBucketInterval_AdjustsCorrectly(
Trade[] items, int windowLengthInMs, int bucketInterval, decimal expectedVolume, decimal expectedCount)
{
// Arrange
var window = new SlidingWindow <Trade>(TimeSpan.FromMilliseconds(windowLengthInMs), bucketInterval, Trade.CreateCalculation, testDateTimeProvider);
// Act
foreach (var item in items)
{
testDateTimeProvider.Now = item.TimeStamp;
window.Add(item);
}
var calculation = window.GetCurrentWindowCalculation() as Calculation;
// Assert
Assert.Equal((expectedVolume, expectedCount), (calculation.Volume, calculation.CurrentCount));
}
public void GetCurrentCalculation_WhenNoItemInWindow_ShouldUpdateWindowAndReturnEmpty(
Trade[] items, int windowLengthInMs, decimal expectedVolume, decimal expectedCount)
{
// Arrange
var window = new SlidingWindow <Trade>(TimeSpan.FromMilliseconds(windowLengthInMs), 10, Trade.CreateCalculation, testDateTimeProvider);
// Act
foreach (var item in items)
{
testDateTimeProvider.Now = item.TimeStamp;
window.Add(item);
}
testDateTimeProvider.Now = DateTime.Now;
var calculation = window.GetCurrentWindowCalculation() as Calculation;
// Assert
Assert.Equal((expectedVolume, expectedCount), (calculation.Volume, calculation.CurrentCount));
}
public void Add_WhenBucketsAreOlderThanInterval_ShouldRemoveOlderBuckets()
{
// Arrange
var windowInterval = TimeSpan.FromMilliseconds(500);
var items = CreateTradeItemsList(new[] { -2000, -1000, 0 }, new[] { 200, 100, 10 });
var window = new SlidingWindow <Trade>(windowInterval, 500, Trade.CreateCalculation, testDateTimeProvider);
// Act
foreach (var item in items)
{
testDateTimeProvider.Now = item.TimeStamp;
window.Add(item);
}
var buckets = window.GetBuckets().Item1;
var expectedOldestTimeStampKey = window.GetTimeStampKey(testDateTimeProvider.Now.Add(-windowInterval * 2));
// Assert
Assert.True(buckets.All(b => b.TimeStampKey >= expectedOldestTimeStampKey));
}
public void SlidingWindow_IfShiftToRight_AdjustsCorrectly(int shift, int expectedVolume, int expectedCount)
{
// Arrange
var items = CreateTradeItemsList(new[] { -1000, -900, -800, -700, -600, -500, -400, -300, -200, -100, 0 },
new[] { 1000, 900, 800, 700, 600, 500, 400, 300, 200, 100, 0 });
var window = new SlidingWindow <Trade>(TimeSpan.FromMilliseconds(500), 10, Trade.CreateCalculation, testDateTimeProvider);
// Act
foreach (var item in items)
{
testDateTimeProvider.Now = item.TimeStamp;
window.Add(item);
}
var currentCalculation = window.GetCurrentWindowCalculation() as Calculation;
var shiftRight = window.GetCalculationFor(testDateTimeProvider.Now.AddMilliseconds(shift)) as Calculation;
// Assert
Assert.Equal((1500m / 6, 6), (currentCalculation.Volume, currentCalculation.CurrentCount));
Assert.Equal((expectedVolume, expectedCount), (shiftRight.Volume, shiftRight.CurrentCount));
}
public void SlidingWindow_IfShiftToLeft_AdjustsCorrectly()
{
// Arrange
var trades = CreateTradeItemsList(new[] { -1000, -900, -800, -700, -600, -500, -400, -300, -200, -100, 0 },
new[] { 1000, 900, 800, 700, 600, 500, 400, 300, 200, 100, 0 });
var window = new SlidingWindow <Trade>(TimeSpan.FromMilliseconds(500), 10, Trade.CreateCalculation, testDateTimeProvider);
// Act
foreach (var trade in trades)
{
testDateTimeProvider.Now = trade.TimeStamp;
window.Add(trade);
}
var currentCalculation = window.GetCurrentWindowCalculation() as Calculation;
var shiftLeft = window.GetCalculationFor(testDateTimeProvider.Now.AddMilliseconds(-250)) as Calculation;
// Assert
Assert.Equal((250, 6), (currentCalculation.Volume, currentCalculation.CurrentCount));
Assert.Equal((2500m / 5, 5), (shiftLeft.Volume, shiftLeft.CurrentCount));
}
// Starts scanning at character pos of string text for occurrence of any word
// in stemmed_terms. Returns a list of (words)*[(matched word)(words)*]+
private SnippetLine MarkTerms(ArrayList stemmed_terms, string text, ref int pos)
{
SnippetLine snippet_line = null;
int prev_match_end_pos = pos; // misnomer; means 1 + end_pos of previous word
// 1. get next word
// 2. if no next word, return arraylist
// 3. if word is not a match, following_words ++
// 4. else {
// 4a. add list to the arraylist
// 4b. add word to the arraylist
// 4c. clear list
// 4d. following_words=0
// }
// 5. if (following_words >= max_following_words) {
// 5a. add list to the arraylist
// 5b. clear list
// 5c. return list
// }
while (pos < text.Length)
{
// Find the beginning of the next token
if (IsTokenSeparator(text [pos]))
{
++pos;
continue;
}
// Find the end of the next token
int end_pos = pos + 1;
while (end_pos < text.Length && !IsTokenSeparator(text [end_pos]))
{
++end_pos;
}
string token = text.Substring(pos, end_pos - pos);
string stemmed_token = null;
bool found_match = false;
// Iterate through the stemmed terms and match the token
for (int i = 0; i < stemmed_terms.Count; i++)
{
// If this term is longer than the token in question, give up.
if (end_pos - pos < ((string)stemmed_terms [i]).Length)
{
continue;
}
// We cache the token, so as to avoid stemming it more than once
// when considering multiple terms.
if (stemmed_token == null)
{
stemmed_token = LuceneCommon.Stem(token.ToLower());
}
if (String.Compare((string)stemmed_terms [i], stemmed_token, true) != 0)
{
continue;
}
// We have a match!
found_match = true;
//Console.WriteLine ("Found match");
if (snippet_line == null)
{
snippet_line = new SnippetLine();
}
// Find the fragment before the match
int start_pos = sliding_window.StartValue;
if (start_pos == -1) // If no non-match words seen after last match
{
start_pos = prev_match_end_pos; // Use wherever previous word ended
}
sliding_window.Reset();
string before_match = text.Substring(start_pos, pos - start_pos);
snippet_line.AddNonMatchFragment(before_match);
//Console.WriteLine ("Adding [{0}, {1}]:[{2}]", start_pos, pos - 1, before_match);
snippet_line.AddMatchFragment(i, token);
//Console.WriteLine ("Adding word [{0}, {1}]:[{2}]", pos, end_pos - 1, token);
prev_match_end_pos = end_pos;
break;
}
if (!found_match)
{
// Add the start pos of the token to the window
sliding_window.Add(pos);
// If we found a match previously and saw enough following words, stop
if (snippet_line != null && snippet_line.Count > 0 && sliding_window.Count == context_length)
{
sliding_window.Reset();
string after_match = text.Substring(prev_match_end_pos, end_pos - prev_match_end_pos);
snippet_line.AddNonMatchFragment(after_match);
//Console.WriteLine ("Adding [{0}, {1}]:[{2}]", prev_match_end_pos, end_pos - 1, after_match);
return(snippet_line);
}
}
pos = end_pos;
}
// If less than 6 words came after the last match, add the rest here
if (snippet_line != null && snippet_line.Count > 0)
{
sliding_window.Reset();
string after_match = text.Substring(prev_match_end_pos, pos - prev_match_end_pos);
snippet_line.AddNonMatchFragment(after_match);
//Console.WriteLine ("Adding [{0}, {1}]:[{2}]", prev_match_end_pos, pos - 1, after_match);
//Console.WriteLine ("Sending snippet: {0}", snippet_line.ToString ());
return(snippet_line);
}
sliding_window.Reset();
return(null);
}
