internal static void CompareTrades(IDxTrade playedTrade, IDxTrade lastTrade)
{
Assert.AreEqual(playedTrade.EventSymbol, lastTrade.EventSymbol);
Assert.AreEqual(playedTrade.Time, lastTrade.Time);
Assert.AreEqual(playedTrade.ExchangeCode, lastTrade.ExchangeCode);
Assert.AreEqual(playedTrade.Price, lastTrade.Price);
Assert.AreEqual(playedTrade.Size, lastTrade.Size);
Assert.AreEqual(playedTrade.Change, lastTrade.Change);
Assert.AreEqual(playedTrade.DayVolume, lastTrade.DayVolume);
}
/// <summary>
/// Creates Trade event from another object.
/// </summary>
/// <param name="trade">Other Trade object.</param>
internal PlayedTrade(IDxTrade trade)
{
this.EventSymbol = trade.EventSymbol;
this.Time = trade.Time;
this.Sequence = trade.Sequence;
this.TimeNanoPart = trade.TimeNanoPart;
this.ExchangeCode = trade.ExchangeCode;
this.Price = trade.Price;
this.Size = trade.Size;
this.Change = trade.Change;
this.Tick = trade.Tick;
this.RawFlags = trade.RawFlags;
this.DayVolume = trade.DayVolume;
this.DayTurnover = trade.DayTurnover;
this.TickDirection = trade.TickDirection;
this.IsExtendedTradingHours = trade.IsExtendedTradingHours;
this.Scope = trade.Scope;
Params = new EventParams(0, 0, 0);
Data = new DxTestTrade(Tools.DateToUnixTime(Time), Sequence, TimeNanoPart, ExchangeCode, Price, (int)Size, Tick, Change, RawFlags, DayVolume, DayTurnover, TickDirection, IsExtendedTradingHours, Scope);
}
public void GetLastEventsPromisesTest()
{
//create default endpoint
DXEndpoint.Create();
var symbols = new string[] { "SYMA", "SYMB" };
//try to create promise with invalid parameters
Assert.Catch(typeof(ArgumentException), () =>
{
try
{
Task.WaitAll(DXFeed.GetInstance().GetLastEventsPromises <IDxTrade>(null, CancellationToken.None).ToArray());
}
catch (AggregateException ae)
{
foreach (var inner in ae.InnerExceptions)
{
throw inner;
}
}
});
Assert.Catch(typeof(ArgumentException), () =>
{
try
{
Task.WaitAll(DXFeed.GetInstance().GetLastEventsPromises <IDxTrade>(new object[] { null }, CancellationToken.None).ToArray());
}
catch (AggregateException ae)
{
foreach (var inner in ae.InnerExceptions)
{
throw inner;
}
}
});
//try to cancel promise
CancellationTokenSource cancelSource = new CancellationTokenSource();
List <Task <IDxLastingEvent> > promises = DXFeed.GetInstance().GetLastEventsPromises <IDxTrade>(symbols, cancelSource.Token);
cancelSource.CancelAfter(TimeSpan.FromSeconds(2));
try
{
Task.WaitAll(promises.ToArray());
}
catch (AggregateException ae)
{
foreach (var inner in ae.InnerExceptions)
{
if (!(inner is OperationCanceledException))
{
Assert.Fail("Unexpected exception: " + inner);
}
}
}
//try wait promise with timeout
cancelSource = new CancellationTokenSource(TimeSpan.FromSeconds(2));
promises = DXFeed.GetInstance().GetLastEventsPromises <IDxTrade>(symbols, cancelSource.Token);
try
{
Task.WaitAll(promises.ToArray());
}
catch (AggregateException ae)
{
foreach (var inner in ae.InnerExceptions)
{
if (!(inner is OperationCanceledException))
{
Assert.Fail("Unexpected exception: " + inner);
}
}
}
//try close endpoint while promise waiting
Task closeEndpointTask = Task.Run(() =>
{
Thread.Sleep(TimeSpan.FromSeconds(2));
DXEndpoint.GetInstance().Close();
});
promises = DXFeed.GetInstance().GetLastEventsPromises <IDxTrade>(symbols, CancellationToken.None);
List <Task> allTasks = new List <Task>();
foreach (var p in promises)
{
allTasks.Add(p);
}
allTasks.Add(closeEndpointTask);
try
{
Task.WaitAll(allTasks.ToArray());
}
catch (AggregateException ae)
{
foreach (var inner in ae.InnerExceptions)
{
if (!(inner is OperationCanceledException))
{
Assert.Fail("Unexpected exception: " + inner);
}
}
}
//try to get promise on closed endpoint
promises = DXFeed.GetInstance().GetLastEventsPromises <IDxTrade>(symbols, CancellationToken.None);
try
{
Task.WaitAll(promises.ToArray());
}
catch (AggregateException ae)
{
foreach (var inner in ae.InnerExceptions)
{
if (!(inner is OperationCanceledException))
{
Assert.Fail("Unexpected exception: " + inner);
}
}
}
//try to get last event succesfully
var playedTrades = new PlayedTrade[] {
new PlayedTrade(symbols[0], Tools.DateToUnixTime(DateTime.Now), 0, 0, 'B', 123.456, 100, 123, 1.1, 0, 2.2, 0.0, Direction.Undefined, false, Scope.Regional),
new PlayedTrade(symbols[1], Tools.DateToUnixTime(DateTime.Now), 0, 0, 'B', 234.567, 101, 234, 3.2, 0, 4.3, 0.0, Direction.Undefined, false, Scope.Regional)
};
Task eventPlayerTask = Task.Run(() =>
{
Thread.Sleep(TimeSpan.FromSeconds(1));
foreach (var t in playedTrades)
{
EventPlayer <IDxTrade> eventPlayer = new EventPlayer <IDxTrade>(GetSubscriptionFromFeed <IDxTrade>(t.EventSymbol));
eventPlayer.PlayEvents(t.EventSymbol, t);
}
});
cancelSource = new CancellationTokenSource(TimeSpan.FromSeconds(10));
promises = DXEndpoint.Create().Feed.GetLastEventsPromises <IDxTrade>(symbols, cancelSource.Token);
allTasks = new List <Task>();
foreach (var p in promises)
{
allTasks.Add(p);
}
allTasks.Add(eventPlayerTask);
Assert.DoesNotThrow(() =>
{
Task.WaitAll(allTasks.ToArray());
});
Dictionary <string, PlayedTrade> playedTradeDictionary = new Dictionary <string, PlayedTrade>();
foreach (var t in playedTrades)
{
playedTradeDictionary[t.EventSymbol] = t;
}
foreach (var p in promises)
{
IDxTrade lastTrade = p.Result as IDxTrade;
Assert.True(playedTradeDictionary.ContainsKey(lastTrade.EventSymbol));
var playedTrade = playedTradeDictionary[lastTrade.EventSymbol];
playedTradeDictionary.Remove(lastTrade.EventSymbol);
CompareTrades(playedTrade, lastTrade);
}
//thread-safety case
DXEndpoint.Create();
List <Task> threadTasks = new List <Task>();
for (int i = 0; i < 10; i++)
{
var threadSymbols = new string[] { symbols[0] + i.ToString(), symbols[1] + i.ToString() };
var threadPlayedTrades = new PlayedTrade[] {
new PlayedTrade(threadSymbols[0], Tools.DateToUnixTime(DateTime.Now), 0, 0, 'B', 123.456, 100, 123, 1.1, 0, 2.2, 0.0, Direction.Undefined, false, Scope.Regional),
new PlayedTrade(threadSymbols[1], Tools.DateToUnixTime(DateTime.Now), 0, 0, 'B', 234.567, 101, 234, 3.2, 0, 4.3, 0.0, Direction.Undefined, false, Scope.Regional)
};
HashSet <string> threadPlayedSymbols = new HashSet <string>();
foreach (var t in threadPlayedTrades)
{
threadTasks.Add(Task.Run(() =>
{
Thread.Sleep(TimeSpan.FromSeconds(2));
var eventPlayer = new EventPlayer <IDxTrade>(GetSubscriptionFromFeed <IDxTrade>(t.EventSymbol));
eventPlayer.PlayEvents(t.EventSymbol, t);
}));
threadPlayedSymbols.Add(t.EventSymbol);
}
foreach (var p in DXEndpoint.GetInstance().Feed.GetLastEventsPromises <IDxTrade>(threadSymbols, new CancellationTokenSource(TimeSpan.FromSeconds(20)).Token))
{
threadTasks.Add(p.ContinueWith((resultPromise) =>
{
IDxTrade threadTrade = resultPromise.Result as IDxTrade;
Assert.True(threadPlayedSymbols.Remove(threadTrade.EventSymbol));
}));
}
}
;
Assert.DoesNotThrow(() =>
{
Task.WaitAll(threadTasks.ToArray());
});
}
public void GetLastEventPromiseTest()
{
//create default endpoint
DXEndpoint.Create();
var symbol = "SYMA";
//try to create promise with invalid parameters
Assert.Catch(typeof(ArgumentException), () =>
{
try
{
DXFeed.GetInstance().GetLastEventPromise <IDxTrade>(null, CancellationToken.None).Wait();
}
catch (AggregateException ae)
{
foreach (var inner in ae.InnerExceptions)
{
throw inner;
}
}
});
//try to cancel promise
CancellationTokenSource cancelSource = new CancellationTokenSource();
Task <IDxLastingEvent> promise = DXFeed.GetInstance().GetLastEventPromise <IDxTrade>(symbol, cancelSource.Token);
cancelSource.CancelAfter(TimeSpan.FromSeconds(2));
try
{
Task.WaitAll(promise);
}
catch (AggregateException ae)
{
foreach (var inner in ae.InnerExceptions)
{
if (!(inner is OperationCanceledException))
{
Assert.Fail("Unexpected exception: " + inner);
}
}
}
//try wait promise with timeout
cancelSource = new CancellationTokenSource(TimeSpan.FromSeconds(2));
promise = DXFeed.GetInstance().GetLastEventPromise <IDxTrade>(symbol, cancelSource.Token);
try
{
Task.WaitAll(promise);
}
catch (AggregateException ae)
{
foreach (var inner in ae.InnerExceptions)
{
if (!(inner is OperationCanceledException))
{
Assert.Fail("Unexpected exception: " + inner);
}
}
}
//try close endpoint while promise waiting
Task closeEndpointTask = Task.Run(() =>
{
Thread.Sleep(TimeSpan.FromSeconds(2));
DXEndpoint.GetInstance().Close();
});
promise = DXFeed.GetInstance().GetLastEventPromise <IDxTrade>(symbol, CancellationToken.None);
try
{
Task.WaitAll(promise, closeEndpointTask);
}
catch (AggregateException ae)
{
foreach (var inner in ae.InnerExceptions)
{
if (!(inner is OperationCanceledException))
{
Assert.Fail("Unexpected exception: " + inner);
}
}
}
//try to get promise on closed endpoint
promise = DXFeed.GetInstance().GetLastEventPromise <IDxTrade>(symbol, CancellationToken.None);
try
{
Task.WaitAll(promise);
}
catch (AggregateException ae)
{
foreach (var inner in ae.InnerExceptions)
{
if (!(inner is OperationCanceledException))
{
Assert.Fail("Unexpected exception: " + inner);
}
}
}
//try to get last event succesfully
var playedTrade = new PlayedTrade(symbol, Tools.DateToUnixTime(DateTime.Now), 0, 0, 'B', 123.456, 100, 123, 1.1, 0, 2.2, 0.0, Direction.Undefined, false, Scope.Regional);
Task eventPlayerTask = Task.Run(() =>
{
Thread.Sleep(TimeSpan.FromSeconds(1));
EventPlayer <IDxTrade> eventPlayer = new EventPlayer <IDxTrade>(GetSubscriptionFromFeed <IDxTrade>(symbol));
eventPlayer.PlayEvents(symbol, playedTrade);
});
cancelSource = new CancellationTokenSource(TimeSpan.FromSeconds(10));
promise = DXEndpoint.Create().Feed.GetLastEventPromise <IDxTrade>(symbol, cancelSource.Token);
Assert.DoesNotThrow(() =>
{
Task.WaitAll(promise, eventPlayerTask);
});
IDxTrade lastTrade = promise.Result as IDxTrade;
Assert.AreEqual(symbol, lastTrade.EventSymbol);
CompareTrades(playedTrade, lastTrade);
//thread-safety case
DXEndpoint.Create();
List <Task> tasks = new List <Task>();
for (int i = 0; i < 10; i++)
{
var threadSymbol = symbol + i.ToString();
var threadPlayedTrade = new PlayedTrade(threadSymbol, Tools.DateToUnixTime(DateTime.Now), 0, 0, 'B', 123.456, 100, 123, 1.1, 0, 2.2, 0.0, Direction.Undefined, false, Scope.Regional);
tasks.Add(Task.Run(() =>
{
Thread.Sleep(TimeSpan.FromSeconds(1));
var eventPlayer = new EventPlayer <IDxTrade>(GetSubscriptionFromFeed <IDxTrade>(threadSymbol));
eventPlayer.PlayEvents(threadSymbol, threadPlayedTrade);
}));
var threadPromise = DXEndpoint.GetInstance().Feed
.GetLastEventPromise <IDxTrade>(threadSymbol, new CancellationTokenSource(TimeSpan.FromSeconds(5)).Token)
.ContinueWith((resultPromise) =>
{
IDxTrade threadTrade = resultPromise.Result as IDxTrade;
Assert.AreEqual(threadSymbol, threadTrade.EventSymbol);
});
tasks.Add(threadPromise);
}
;
Assert.DoesNotThrow(() =>
{
Task.WaitAll(tasks.ToArray());
});
}
/// <summary>
/// Creates copy of trade object.
/// </summary>
/// <param name="trade">The IDxTrade object.</param>
internal NativeTrade(IDxTrade trade) : base(trade)
{
Change = trade.Change;
Tick = trade.Tick;
}
/// <summary>
/// Creates copy of trade object.
/// </summary>
/// <param name="trade">The IDxTrade object.</param>
internal NativeTrade(IDxTrade trade) : base(trade)
{
Tick = trade.Tick;
}
