public void ClearTest()
{
object[] symbols = new object[] { "IBM", "AAPL", "C" };
isFiresOnSymbolsRemoved = false;
var s = DXEndpoint.Create().Feed.CreateSubscription <IDxOrder>();
s.OnSymbolsRemoved += OnSymbolsRemoved;
s.AddSymbols(symbols);
Assert.Greater(s.GetSymbols().Count, 0);
s.Clear();
Assert.True(isFiresOnSymbolsRemoved);
Assert.AreEqual(s.GetSymbols().Count, 0);
//try to add symbols again after Clear
s.AddSymbols(symbols);
Assert.Greater(s.GetSymbols().Count, 0);
Parallel.For(ParallelFrom, ParallelTo, i =>
{
Assert.DoesNotThrow(() =>
{
s.Clear();
});
});
}
public void ConnectTest()
{
IDXEndpoint endpoint = DXEndpoint.Create();
Assert.True(endpoint.State == DXEndpointState.Connected || endpoint.State == DXEndpointState.Connecting);
Assert.Catch(typeof(ArgumentNullException), () => {
endpoint.Connect(null);
});
Assert.Catch(typeof(ArgumentNullException), () => {
endpoint.Connect(string.Empty);
});
Assert.Catch(typeof(ArgumentNullException), () => {
endpoint.Connect(" ");
});
Assert.Catch(() => {
endpoint.Connect("not-valid-address");
});
endpoint.Connect(testServerAddress);
Assert.True(endpoint.State == DXEndpointState.Connected || endpoint.State == DXEndpointState.Connecting);
endpoint.Connect(demoServerAddress);
Assert.True(endpoint.State == DXEndpointState.Connected || endpoint.State == DXEndpointState.Connecting);
//try to connect after disconnect
endpoint.Disconnect();
Assert.AreEqual(endpoint.State, DXEndpointState.NotConnected);
endpoint.Connect(demoServerAddress);
Assert.True(endpoint.State == DXEndpointState.Connected || endpoint.State == DXEndpointState.Connecting);
}
public void RemoveEventListenerTest()
{
var s = DXEndpoint.Create().Feed.CreateSubscription <IDxEventType>(typeof(IDxOrder));
Assert.Catch(typeof(ArgumentNullException), () =>
{
s.RemoveEventListener(null);
});
var listenersCount = 10;
var listenersList = new List <IDXFeedEventListener <IDxEventType> >(listenersCount);
for (var i = 0; i < listenersCount; i++)
{
listenersList.Add(new EventListener());
s.AddEventListener(listenersList.Last());
}
Parallel.For(ParallelFrom, ParallelTo, i =>
{
Assert.DoesNotThrow(() =>
{
s.RemoveEventListener(listenersList[i % listenersCount]);
});
});
}
public void IsClosedTest()
{
var s = DXEndpoint.Create().Feed.CreateSubscription <IDxOrder>();
Assert.False(s.IsClosed);
Parallel.For(ParallelFrom, ParallelTo, i =>
{
Assert.False(s.IsClosed);
});
s.Close();
Assert.True(s.IsClosed);
Parallel.For(ParallelFrom, ParallelTo, i =>
{
Assert.DoesNotThrow(() =>
{
Assert.True(s.IsClosed);
});
});
//try to close subscription via closing endpoint
s = DXFeed.GetInstance().CreateSubscription <IDxOrder>();
Assert.False(s.IsClosed);
DXEndpoint.GetInstance().Close();
Assert.True(s.IsClosed);
}
public void DetachSubscriptionTest()
{
//create default endpoint
DXEndpoint.Create();
//try to detach null subscription
Assert.Catch(typeof(ArgumentNullException), () =>
{
DXFeed.GetInstance().DetachSubscription <IDxOrder>(null);
});
//try to detach already detached subscription
var s = DXFeed.GetInstance().CreateSubscription <IDxOrder>();
DXFeed.GetInstance().DetachSubscription(s);
DXFeed.GetInstance().DetachSubscription(s);
//try to detach another not attached subscription
DXFeedSubscription <IDxOrder> other = new DXFeedSubscription <IDxOrder>(DXEndpoint.GetInstance() as DXEndpoint);
DXFeed.GetInstance().DetachSubscription(other);
//thread-safety case
DXEndpoint.Create();
Parallel.For(ParallelFrom, ParallelTo, i =>
{
Assert.DoesNotThrow(() =>
{
var newSubscription = new DXFeedSubscription <IDxOrder>(DXEndpoint.GetInstance() as DXEndpoint);
DXFeed.GetInstance().AttachSubscription(newSubscription);
DXFeed.GetInstance().DetachSubscription(newSubscription);
});
});
}
public void CreateTimeSeriesSubscriptionTest()
{
var symbol = "SYMA";
var s = DXEndpoint.Create().Feed.CreateTimeSeriesSubscription <IDxCandle>();
s.AddSymbols(symbol);
TestListener eventListener = new TestListener();
s.AddEventListener(eventListener);
var playedCandle = new PlayedCandle(symbol, Tools.DateToUnixTime(DateTime.Now), 123, 100, 12.34, 56.78, 9.0, 43.21, 1000, 999, 1001, 1002, 1, 777, 888, EventFlag.RemoveSymbol);
EventPlayer <IDxCandle> eventPlayer = new EventPlayer <IDxCandle>(s as DXFeedSubscription <IDxCandle>);
eventPlayer.PlayEvents(symbol, playedCandle);
Assert.AreEqual(eventListener.GetEventCount <IDxCandle>(symbol), 1);
IDxCandle receivedCandle = eventListener.GetLastEvent <IDxCandle>().Event;
Assert.AreEqual(symbol, receivedCandle.EventSymbol.ToString());
CompareCandles(playedCandle, receivedCandle);
//thread-safety case
DXEndpoint.Create();
Parallel.For(ParallelFrom, ParallelTo, i =>
{
Assert.DoesNotThrow(() =>
{
DXEndpoint.GetInstance().Feed.CreateTimeSeriesSubscription <IDxCandle>();
});
});
}
public void GetSymbolsTest()
{
object[] symbols = new object[] { "IBM", "AAPL", "C" };
isFiresOnSymbolsRemoved = false;
var s = DXEndpoint.Create().Feed.CreateSubscription <IDxOrder>();
s.AddSymbols(symbols);
Assert.AreEqual(symbols.Length, s.GetSymbols().Count);
Assert.True(s.GetSymbols().SetEquals(symbols));
//try to change returned symbols set
s.GetSymbols().Add("MSFT");
Assert.AreEqual(symbols.Length, s.GetSymbols().Count);
Assert.True(s.GetSymbols().SetEquals(symbols));
//try to add new symbol into subscription
s.AddSymbols("XBT/USD");
IList <object> newSymbols = new List <object>(symbols);
newSymbols.Add("XBT/USD");
Assert.AreEqual(newSymbols.Count, s.GetSymbols().Count);
Assert.True(s.GetSymbols().SetEquals(newSymbols));
Parallel.For(ParallelFrom, ParallelTo, i =>
{
Assert.True(s.GetSymbols().SetEquals(newSymbols));
});
}
public void FeedTest()
{
IDXEndpoint endpoint = DXEndpoint.Create();
Assert.True(endpoint.State == DXEndpointState.Connected || endpoint.State == DXEndpointState.Connecting);
Assert.IsNotNull(endpoint.Feed);
}
public void CreateSubscriptionTypesTest()
{
//create default endpoint
DXEndpoint.Create();
//try to create subscription with invalid event types parameters
//all attempts to create subscription in this block must be failed with exception
Assert.Catch(typeof(ArgumentException), () =>
{
DXFeed.GetInstance().CreateSubscription <IDxOrder>(typeof(IDxCandle), typeof(IDxQuote));
});
Assert.Catch(typeof(ArgumentException), () =>
{
DXFeed.GetInstance().CreateSubscription <IDxIndexedEvent>(typeof(IDxCandle), typeof(IDxQuote));
});
Assert.Catch(typeof(ArgumentException), () =>
{
DXFeed.GetInstance().CreateSubscription <IDxLastingEvent>(typeof(IDxOrder), typeof(IDxQuote));
});
Assert.Catch(typeof(ArgumentException), () =>
{
DXFeed.GetInstance().CreateSubscription <IDxMarketEvent>(typeof(IDxCandle));
});
Assert.Catch(typeof(ArgumentException), () =>
{
DXFeed.GetInstance().CreateSubscription <IDxMarketEvent>(typeof(string));
});
var symbol = "SYMA";
var s = DXFeed.GetInstance().CreateSubscription <IDxEventType>(typeof(IDxOrder), typeof(IDxTrade));
s.AddSymbols(symbol);
TestListener eventListener = new TestListener();
s.AddEventListener(eventListener);
EventPlayer <IDxEventType> eventPlayer = new EventPlayer <IDxEventType>(s as DXFeedSubscription <IDxEventType>);
var playedOrder = new PlayedOrder(symbol, 0, 0x4e54560000000006, 0, 0, 0, 0, 100, 25, Scope.Order, Side.Buy, 'A', OrderSource.NTV, "AAAA");
eventPlayer.PlayEvents(symbol, playedOrder);
var playedTrade = new PlayedTrade(symbol, 0, 0, 0, 'B', 123.456, 100, 123, 1.1, 0, 2.2, 0.0, Direction.Undefined, false, Scope.Regional);
eventPlayer.PlayEvents(symbol, playedTrade);
Assert.AreEqual(eventListener.GetEventCount <IDxOrder>(symbol), 1);
Assert.AreEqual(eventListener.GetEventCount <IDxTrade>(symbol), 1);
//thread-safety case
DXEndpoint.Create();
Parallel.For(ParallelFrom, ParallelTo, i =>
{
Assert.DoesNotThrow(() =>
{
DXFeed.GetInstance().CreateSubscription <IDxEventType>(typeof(IDxOrder), typeof(IDxTrade));
});
});
}
/// <summary>
/// Returns a default application-wide singleton instance of DXEndpoint with a default
/// role.
/// Most applications use only a single data-source and should rely on this method to
/// get one.
/// </summary>
/// <returns>Instance of DXEndpoint with a default role.</returns>
public static IDXEndpoint GetInstance()
{
if (endpointInstance == null)
{
lock (instanceLocker)
{
endpointInstance = new DXEndpoint();
endpointInstance.Connect(DefaultAddress);
}
}
return(endpointInstance);
}
public void PasswordTest()
{
IDXEndpoint endpoint = DXEndpoint.Create();
Assert.Catch(typeof(ArgumentNullException), () => {
endpoint.Password(null);
});
Assert.Catch(typeof(ArgumentNullException), () => {
endpoint.Password(string.Empty);
});
Assert.AreEqual(endpoint, endpoint.Password("test"));
}
/// <summary>
/// Creates detached subscription for a single event type.
/// </summary>
/// <param name="endpoint">The <see cref="DXEndpoint"/> instance.</param>
/// <exception cref="ArgumentNullException">If <paramref name="endpoint"/> is null.</exception>
/// <exception cref="ArgumentException">If type E is not event class.</exception>
/// <exception cref="DxException">Internal error.</exception>
public DXFeedSubscription(DXEndpoint endpoint) : this()
{
if (endpoint == null)
{
throw new ArgumentNullException("endpoint");
}
endpoint.OnClosing += Endpoint_OnClosing;
subscriptionInstance = endpoint.Connection.CreateSubscription(
EventTypeUtil.GetEventsType(typeof(E)),
new DXFeedEventHandler <E>(eventListeners, eventListenerLocker));
}
/// <summary>
/// Creates an new endpoint.
/// </summary>
/// <returns>The created endpoint.</returns>
public static IDXEndpoint Create()
{
lock (instanceLocker)
{
if (endpointInstance != null && endpointInstance.State != DXEndpointState.Closed)
{
endpointInstance.Close();
}
endpointInstance = new DXEndpoint();
endpointInstance.Connect(DefaultAddress);
}
return(endpointInstance);
}
public void ParallelFromTimeStampTest()
{
var s = DXEndpoint.Create().Feed.CreateTimeSeriesSubscription <IDxCandle>();
Random random = new Random();
Parallel.For(ParallelFrom, ParallelTo, i =>
{
Assert.DoesNotThrow(() =>
{
s.FromTimeStamp = Tools.DateToUnixTime(DateTime.Now.AddDays(random.Next(-356, 0)));
});
});
}
public void CloseTest()
{
isFiresOnSubscriptionClosed = false;
isFiresOnSymbolsRemoved = false;
var expectedEventSet = new HashSet <Type>(new Type[] { typeof(IDxOrder) });
var expectedSymbolSet = new HashSet <string>();
var eventListener = new EventListener();
var s = DXEndpoint.Create().Feed.CreateSubscription <IDxEventType>(typeof(IDxOrder));
s.OnSubscriptionClosed += OnSubscriptionClosed;
s.OnSymbolsAdded += OnSymbolsAdded;
s.OnSymbolsRemoved += OnSymbolsRemoved;
s.AddSymbols("IBM");
s.Close();
//try to call methods after closing subscription
Assert.True(isFiresOnSubscriptionClosed);
Assert.True(s.IsClosed);
Assert.True(s.EventTypes.SetEquals(expectedEventSet));
Assert.True(s.ContainsEventType(typeof(IDxOrder)));
s.Clear();
Assert.True(s.GetSymbols().SetEquals(expectedSymbolSet));
isFiresOnSymbolsAdded = false;
s.SetSymbols("AAPL");
Assert.False(isFiresOnSymbolsAdded);
Assert.True(s.GetSymbols().SetEquals(expectedSymbolSet));
s.AddSymbols("C");
Assert.False(isFiresOnSymbolsAdded);
Assert.True(s.GetSymbols().SetEquals(expectedSymbolSet));
s.RemoveSymbols("IBM");
Assert.False(isFiresOnSymbolsRemoved);
Assert.True(s.GetSymbols().SetEquals(expectedSymbolSet));
s.AddEventListener(eventListener);
s.RemoveEventListener(eventListener);
Parallel.For(ParallelFrom, ParallelTo, i =>
{
Assert.DoesNotThrow(() =>
{
s.Close();
});
});
}
public void CreateTimeSeriesSubscriptionTypesTest()
{
//create default endpoint
DXEndpoint.Create();
//try to create subscription with invalid event types parameters
//all attempts to create subscription in this block must be failed with exception
Assert.Catch(typeof(ArgumentException), () =>
{
DXFeed.GetInstance().CreateTimeSeriesSubscription <IDxTimeSeriesEvent>(typeof(IDxCandle), typeof(IDxQuote));
});
Assert.Catch(typeof(ArgumentException), () =>
{
DXFeed.GetInstance().CreateTimeSeriesSubscription <IDxTimeSeriesEvent>(typeof(IDxOrder), typeof(IDxQuote));
});
Assert.Catch(typeof(ArgumentException), () =>
{
DXFeed.GetInstance().CreateTimeSeriesSubscription <IDxTimeSeriesEvent>(typeof(string));
});
var symbol = "SYMA";
var s = DXFeed.GetInstance().CreateTimeSeriesSubscription <IDxTimeSeriesEvent>(typeof(IDxCandle), typeof(IDxGreeks));
s.AddSymbols(symbol);
TestListener eventListener = new TestListener();
s.AddEventListener(eventListener);
EventPlayer <IDxTimeSeriesEvent> eventPlayer = new EventPlayer <IDxTimeSeriesEvent>(s as DXFeedSubscription <IDxTimeSeriesEvent>);
var playedCandle = new PlayedCandle(symbol, Tools.DateToUnixTime(DateTime.Now), 123, 100, 12.34, 56.78, 9.0, 43.21, 1000, 999, 1001, 1002, 1, 777, 888, EventFlag.RemoveSymbol);
eventPlayer.PlayEvents(symbol, playedCandle);
var playedGreeks = new PlayedGreeks(symbol, EventFlag.RemoveSymbol, 1, Tools.DateToUnixTime(DateTime.Now), 456.789, 11, 555, 666, 777, 888, 999);
eventPlayer.PlayEvents(symbol, playedGreeks);
Assert.AreEqual(eventListener.GetEventCount <IDxCandle>(symbol), 1);
Assert.AreEqual(eventListener.GetEventCount <IDxGreeks>(symbol), 1);
//thread-safety case
DXEndpoint.Create();
Parallel.For(ParallelFrom, ParallelTo, i =>
{
Assert.DoesNotThrow(() =>
{
DXFeed.GetInstance().CreateTimeSeriesSubscription <IDxTimeSeriesEvent>(typeof(IDxCandle), typeof(IDxGreeks));
});
});
}
public void RemoveSymbolsTest()
{
object[] symbolsSet = new object[] { "IBM", CandleSymbol.ValueOf("AAPL{=d}"), "C", "XBT/USD" };
isFiresOnSymbolsRemoved = false;
var s = DXEndpoint.Create().Feed.CreateSubscription <IDxOrder>();
s.OnSymbolsRemoved += OnSymbolsRemoved;
s.AddSymbols(symbolsSet);
s.RemoveSymbols(null);
s.RemoveSymbols(new List <object>());
s.RemoveSymbols(new object[] { });
Assert.Catch(typeof(ArgumentNullException), () =>
{
s.RemoveSymbols(new List <object>(new object[] { null }));
});
ICollection <object> removeCollection = new List <object>(
new object[] { CandleSymbol.ValueOf("AAPL{=d}"), "C", "XBT/USD" }
);
s.RemoveSymbols(removeCollection);
Assert.True(isFiresOnSymbolsRemoved);
Assert.AreEqual(1, s.GetSymbols().Count);
Assert.True(s.GetSymbols().SetEquals(new object[] { "IBM" }));
isFiresOnSymbolsRemoved = false;
s.RemoveSymbols("IBM");
Assert.True(isFiresOnSymbolsRemoved);
Assert.AreEqual(0, s.GetSymbols().Count);
var totalSymbolsCount = 0;
foreach (var set in SimulatedSymbolsSet)
{
s.AddSymbols(set);
totalSymbolsCount += set.Length;
}
Assert.AreEqual(totalSymbolsCount, s.GetSymbols().Count);
Parallel.For(ParallelFrom, ParallelTo, i =>
{
Assert.DoesNotThrow(() =>
{
s.RemoveSymbols(SimulatedSymbolsSet[i % SimulatedSymbolsSet.Length]);
});
});
Assert.AreEqual(0, s.GetSymbols().Count);
}
public void StateTest()
{
IDXEndpoint endpoint = DXEndpoint.Create();
Assert.True(endpoint.State == DXEndpointState.Connected || endpoint.State == DXEndpointState.Connecting);
endpoint.Disconnect();
Assert.AreEqual(endpoint.State, DXEndpointState.NotConnected);
endpoint.Connect(demoServerAddress);
Assert.True(endpoint.State == DXEndpointState.Connected || endpoint.State == DXEndpointState.Connecting);
endpoint.Close();
Assert.AreEqual(endpoint.State, DXEndpointState.Closed);
endpoint.Connect(demoServerAddress);
Assert.AreEqual(endpoint.State, DXEndpointState.Closed);
}
public void AddSymbolsTest()
{
object[] symbolsSet1 = new object[] { "IBM", CandleSymbol.ValueOf("AAPL{=d}"), "C" };
object[] symbolsSetString = new object[] { "IBM", "AAPL{=d}", "C" };
object symbolSet2 = "XBT/USD";
isFiresOnSymbolsAdded = false;
var s = DXEndpoint.Create().Feed.CreateSubscription <IDxOrder>();
s.OnSymbolsAdded += OnSymbolsAdded;
s.AddSymbols(null);
s.AddSymbols(new List <object>());
s.AddSymbols(new object[] { });
Assert.Catch(typeof(ArgumentNullException), () =>
{
s.AddSymbols(new List <object>(new object[] { null }));
});
s.AddSymbols(symbolsSet1);
Assert.True(isFiresOnSymbolsAdded);
Assert.AreEqual(symbolsSetString.Length, s.GetSymbols().Count);
Assert.True(s.GetSymbols().SetEquals(symbolsSetString));
isFiresOnSymbolsAdded = false;
object[] newSymbolSet = symbolsSetString.Concat(new object[] { symbolSet2 }).ToArray();
s.AddSymbols(symbolSet2);
Assert.True(isFiresOnSymbolsAdded);
Assert.AreEqual(newSymbolSet.Length, s.GetSymbols().Count);
Assert.True(s.GetSymbols().SetEquals(newSymbolSet));
Parallel.For(ParallelFrom, ParallelTo, i =>
{
Assert.DoesNotThrow(() =>
{
s.AddSymbols(SimulatedSymbolsSet[i % SimulatedSymbolsSet.Length]);
});
});
foreach (var set in SimulatedSymbolsSet)
{
newSymbolSet = newSymbolSet.Concat(set).ToArray();
}
Assert.AreEqual(newSymbolSet.Length, s.GetSymbols().Count);
Assert.True(s.GetSymbols().SetEquals(newSymbolSet));
}
public void CloseTest()
{
isFiresOnClosing = false;
IDXEndpoint endpoint = DXEndpoint.Create();
endpoint.OnClosing += Endpoint_OnClosing;
Assert.True(endpoint.State == DXEndpointState.Connected || endpoint.State == DXEndpointState.Connecting);
endpoint.Close();
Assert.AreEqual(endpoint.State, DXEndpointState.Closed);
Assert.True(isFiresOnClosing);
endpoint.Connect(demoServerAddress);
Assert.AreEqual(endpoint.State, DXEndpointState.Closed);
endpoint.Disconnect();
Assert.AreEqual(endpoint.State, DXEndpointState.Closed);
}
public void EventTypesTest()
{
var orderSubscription = DXEndpoint.Create().Feed.CreateSubscription <IDxOrder>();
Assert.True(orderSubscription.EventTypes.SetEquals(new HashSet <Type>(new Type[] { typeof(IDxOrder) })));
ISet <Type> allTypesSet = DXEndpoint.GetInstance().GetEventTypes();
Type[] subscriptionTypes = allTypesSet.AsEnumerable().ToArray();
var allTypeSubscription = DXEndpoint.GetInstance().Feed.CreateSubscription <IDxEventType>(subscriptionTypes);
Assert.True(allTypeSubscription.EventTypes.SetEquals(allTypesSet));
Parallel.For(ParallelFrom, ParallelTo, i =>
{
Assert.True(allTypeSubscription.EventTypes.SetEquals(allTypesSet));
});
}
/// <summary>
/// Creates detached snapshot subscription for a single event type.
/// </summary>
/// <param name="endpoint">The <see cref="DXEndpoint"/> instance.</param>
/// <param name="time">Unix time in the past - number of milliseconds from 1.1.1970.</param>
/// <param name="source">The source of the event.</param>
/// <exception cref="ArgumentNullException">If <paramref name="endpoint"/> is null.</exception>
/// <exception cref="ArgumentException">If type E is not event class.</exception>
/// <exception cref="DxException">Internal error.</exception>
internal DXFeedSubscription(DXEndpoint endpoint, long time, IndexedEventSource source) : this()
{
if (endpoint == null)
{
throw new ArgumentNullException("endpoint");
}
endpoint.OnClosing += Endpoint_OnClosing;
subscriptionInstance = endpoint.Connection.CreateSnapshotSubscription(
EventTypeUtil.GetEventsType(typeof(E)),
time,
new DXFeedEventHandler <E>(eventListeners, eventListenerLocker));
if (source != IndexedEventSource.DEFAULT)
{
subscriptionInstance.SetSource(source.Name);
}
}
public void ContainEventTypeTest()
{
ISet <Type> allTypesSet = DXEndpoint.GetInstance().GetEventTypes();
var orderSubscription = DXEndpoint.Create().Feed.CreateSubscription <IDxOrder>();
Assert.True(orderSubscription.ContainsEventType(typeof(IDxOrder)));
foreach (Type t in allTypesSet.Except(new Type[] { typeof(IDxOrder) }))
{
Assert.False(orderSubscription.ContainsEventType(t));
}
Type[] subscriptionTypes = new Type[] { typeof(IDxOrder), typeof(IDxCandle) };
var orderCandleSubscription = DXEndpoint.GetInstance().Feed.CreateSubscription <IDxEventType>(subscriptionTypes);
foreach (Type t in subscriptionTypes)
{
Assert.True(orderCandleSubscription.ContainsEventType(t));
}
foreach (Type t in allTypesSet.Except(subscriptionTypes))
{
Assert.False(orderCandleSubscription.ContainsEventType(t));
}
subscriptionTypes = allTypesSet.AsEnumerable().ToArray();
var allTypeSubscription = DXEndpoint.GetInstance().Feed.CreateSubscription <IDxEventType>(subscriptionTypes);
foreach (Type t in allTypesSet)
{
Assert.True(allTypeSubscription.ContainsEventType(t));
}
Assert.False(allTypeSubscription.ContainsEventType(null));
Parallel.For(ParallelFrom, ParallelTo, i =>
{
foreach (Type t in allTypesSet)
{
Assert.True(allTypeSubscription.ContainsEventType(t));
}
});
}
/// <summary>
/// Creates detached subscription for the given list of event types.
/// </summary>
/// <param name="endpoint">The <see cref="DXEndpoint"/> instance.</param>
/// <param name="eventTypes">The list of event types.</param>
/// <exception cref="ArgumentNullException">
/// If <paramref name="endpoint"/> or <paramref name="eventTypes"/> is null.
/// </exception>
/// <exception cref="ArgumentException">
/// If <paramref name="eventTypes"/> are empty or any type of
/// <paramref name="eventTypes"/> is not event class.
/// </exception>
/// <exception cref="DxException">Internal error.</exception>
public DXFeedSubscription(DXEndpoint endpoint, params Type[] eventTypes) : this(eventTypes)
{
if (endpoint == null)
{
throw new ArgumentNullException("endpoint");
}
foreach (Type t in eventTypes)
{
if (!typeof(E).IsAssignableFrom(t))
{
throw new ArgumentException(string.Format("The type {0} is not {1}", t, typeof(E)));
}
}
endpoint.OnClosing += Endpoint_OnClosing;
subscriptionInstance = endpoint.Connection.CreateSubscription(
EventTypeUtil.GetEventsType(eventTypes),
new DXFeedEventHandler <E>(eventListeners, eventListenerLocker));
}
public void CreateSubscriptionTest()
{
var symbol = "SYMA";
var s = DXEndpoint.Create().Feed.CreateSubscription <IDxOrder>();
s.AddSymbols(symbol);
TestListener eventListener = new TestListener();
s.AddEventListener(eventListener);
var playedOrder = new PlayedOrder(symbol, 0, 0x4e54560000000006, 0, 0, 0, 0, 100, 25, Scope.Order, Side.Buy, 'A', OrderSource.NTV, "AAAA");
EventPlayer <IDxOrder> eventPlayer = new EventPlayer <IDxOrder>(s as DXFeedSubscription <IDxOrder>);
eventPlayer.PlayEvents(symbol, playedOrder);
Assert.AreEqual(eventListener.GetEventCount <IDxOrder>(symbol), 1);
IDxOrder receivedOrder = eventListener.GetLastEvent <IDxOrder>().Event;
Assert.AreEqual(symbol, receivedOrder.EventSymbol);
CompareOrders(playedOrder, receivedOrder);
//try to create subscription on closed endpoint
DXEndpoint.GetInstance().Close();
Assert.Catch(typeof(InvalidOperationException), () =>
{
DXFeed.GetInstance().CreateSubscription <IDxOrder>();
});
//thread-safety case
DXEndpoint.Create();
Parallel.For(ParallelFrom, ParallelTo, i =>
{
Assert.DoesNotThrow(() =>
{
DXFeed.GetInstance().CreateSubscription <IDxOrder>();
});
});
}
public void ResetFromTimeStampTest()
{
string symbol = "SYMA";
TestListener eventListener = new TestListener();
var s = DXEndpoint.Create().Feed.CreateTimeSeriesSubscription <IDxCandle>();
s.OnSubscriptionClosed += OnSubscriptionClosed;
s.OnSymbolsAdded += OnSymbolsAdded;
s.OnSymbolsRemoved += OnSymbolsRemoved;
s.AddEventListener(eventListener);
s.AddSymbols(symbol);
Assert.AreEqual(long.MaxValue, s.FromTimeStamp);
//try to change FromTimeStamp property
isFiresOnSubscriptionClosed = false;
isFiresOnSymbolsAdded = false;
isFiresOnSymbolsRemoved = false;
long fromTime = Tools.DateToUnixTime(DateTime.Now.AddMonths(-1));
s.FromTimeStamp = fromTime;
Assert.AreEqual(fromTime, s.FromTimeStamp);
Assert.True(s.GetSymbols().SetEquals(new object[] { symbol }));
Assert.True(s.EventTypes.SetEquals(new Type[] { typeof(IDxCandle) }));
Assert.False(isFiresOnSubscriptionClosed);
Assert.False(isFiresOnSymbolsAdded);
Assert.False(isFiresOnSymbolsRemoved);
var playedCandle = new PlayedCandle(symbol, Tools.DateToUnixTime(DateTime.Now), 123, 100, 12.34, 56.78, 9.0, 43.21, 1000, 999, 1001, 1002, 1, 777, 888, EventFlag.RemoveSymbol);
EventPlayer <IDxCandle> eventPlayer = new EventPlayer <IDxCandle>(s as DXFeedSubscription <IDxCandle>);
eventPlayer.PlayEvents(symbol, playedCandle);
Assert.AreEqual(eventListener.GetEventCount <IDxCandle>(symbol), 1);
IDxCandle receivedCandle = eventListener.GetLastEvent <IDxCandle>().Event;
Assert.AreEqual(symbol, receivedCandle.EventSymbol.ToString());
DXFeedTest.CompareCandles(playedCandle, receivedCandle);
}
public void GetIndexedEventsPromiseTest()
{
//create default endpoint
DXEndpoint.Create();
var symbol = "SYMA";
//try to create promise with invalid parameters
Assert.Catch(typeof(ArgumentException), () =>
{
try
{
DXFeed.GetInstance().GetIndexedEventsPromise <IDxOrder>(null, OrderSource.NTV, CancellationToken.None).Wait();
}
catch (AggregateException ae)
{
foreach (var inner in ae.InnerExceptions)
{
throw inner;
}
}
});
Assert.Catch(typeof(ArgumentException), () =>
{
try
{
DXFeed.GetInstance().GetIndexedEventsPromise <IDxOrder>(symbol, null, CancellationToken.None).Wait();
}
catch (AggregateException ae)
{
foreach (var inner in ae.InnerExceptions)
{
throw inner;
}
}
});
//try to cancel promise
CancellationTokenSource cancelSource = new CancellationTokenSource();
Task <List <IDxOrder> > promise = DXFeed.GetInstance().GetIndexedEventsPromise <IDxOrder>(symbol, OrderSource.NTV, 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().GetIndexedEventsPromise <IDxOrder>(symbol, OrderSource.NTV, 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().GetIndexedEventsPromise <IDxOrder>(symbol, OrderSource.NTV, 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().GetIndexedEventsPromise <IDxOrder>(symbol, OrderSource.NTV, 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
DateTime date = DateTime.Now;
var playedOrders = new PlayedOrder[] {
new PlayedOrder(symbol, 0, 0x4e54560000000006, Tools.DateToUnixTime(date), 0, 0, 100, 100, 25, Scope.Order, Side.Buy, 'A', OrderSource.NTV, "AAAA"),
new PlayedOrder(symbol, 0, 0x4e54560000000005, Tools.DateToUnixTime(date.AddMinutes(-1)), 0, 0, 100.5, 101, 25, Scope.Order, Side.Buy, 'A', OrderSource.NTV, "AAAA"),
new PlayedOrder(symbol, 0, 0x4e54560000000004, Tools.DateToUnixTime(date.AddMinutes(-2)), 0, 0, 101, 102, 25, Scope.Order, Side.Sell, 'A', OrderSource.NTV, "AAAA"),
new PlayedOrder(symbol, 0, 0x4e54560000000003, Tools.DateToUnixTime(date.AddMinutes(-3)), 0, 0, 100, 103, 25, Scope.Order, Side.Buy, 'A', OrderSource.NTV, "AAAA"),
new PlayedOrder(symbol, 0, 0x4e54560000000002, Tools.DateToUnixTime(date.AddMinutes(-4)), 0, 0, 100.4, 104, 25, Scope.Order, Side.Buy, 'A', OrderSource.NTV, "AAAA"),
new PlayedOrder(symbol, 0, 0x4e54560000000001, Tools.DateToUnixTime(date.AddMinutes(-5)), 0, 0, 100.3, 105, 25, Scope.Order, Side.Buy, 'A', OrderSource.NTV, "AAAA"),
new PlayedOrder(symbol, 0, 0x4e54560000000000, Tools.DateToUnixTime(date.AddMinutes(-6)), 0, 0, 100.2, 106, 25, Scope.Order, Side.Buy, 'A', OrderSource.NTV, "AAAA")
};
Task eventPlayerTask = Task.Run(() =>
{
Thread.Sleep(TimeSpan.FromSeconds(1));
EventPlayer <IDxOrder> eventPlayer = new EventPlayer <IDxOrder>(GetSubscriptionFromFeed <IDxOrder>(symbol));
eventPlayer.PlaySnapshot(symbol, playedOrders);
});
cancelSource = new CancellationTokenSource(TimeSpan.FromSeconds(10));
promise = DXEndpoint.Create().Feed.GetIndexedEventsPromise <IDxOrder>(symbol, OrderSource.NTV, cancelSource.Token);
Assert.DoesNotThrow(() =>
{
Task.WaitAll(promise, eventPlayerTask);
});
var receivedOrders = promise.Result;
receivedOrders.Reverse();
Assert.AreEqual(playedOrders.Length, receivedOrders.Count);
for (int i = 0; i < playedOrders.Length; i++)
{
Assert.AreEqual(symbol, receivedOrders[i].EventSymbol);
CompareOrders(playedOrders[i], receivedOrders[i]);
}
//thread-safety case
DXEndpoint.Create();
List <Task> tasks = new List <Task>();
for (int i = 0; i < 10; i++)
{
var threadSymbol = symbol + i.ToString();
var threadPlayedOrders = new PlayedOrder[] {
new PlayedOrder(threadSymbol, 0, 0x4e54560000000006, Tools.DateToUnixTime(date), 0, 0, 100, 100, 25, Scope.Order, Side.Buy, 'A', OrderSource.NTV, "AAAA"),
new PlayedOrder(threadSymbol, 0, 0x4e54560000000005, Tools.DateToUnixTime(date.AddMinutes(-1)), 0, 0, 100.5, 101, 25, Scope.Order, Side.Buy, 'A', OrderSource.NTV, "AAAA"),
new PlayedOrder(threadSymbol, 0, 0x4e54560000000004, Tools.DateToUnixTime(date.AddMinutes(-2)), 0, 0, 101, 102, 25, Scope.Order, Side.Sell, 'A', OrderSource.NTV, "AAAA"),
new PlayedOrder(threadSymbol, 0, 0x4e54560000000003, Tools.DateToUnixTime(date.AddMinutes(-3)), 0, 0, 100, 103, 25, Scope.Order, Side.Buy, 'A', OrderSource.NTV, "AAAA"),
new PlayedOrder(threadSymbol, 0, 0x4e54560000000002, Tools.DateToUnixTime(date.AddMinutes(-4)), 0, 0, 100.4, 104, 25, Scope.Order, Side.Buy, 'A', OrderSource.NTV, "AAAA"),
new PlayedOrder(threadSymbol, 0, 0x4e54560000000001, Tools.DateToUnixTime(date.AddMinutes(-5)), 0, 0, 100.3, 105, 25, Scope.Order, Side.Buy, 'A', OrderSource.NTV, "AAAA"),
new PlayedOrder(threadSymbol, 0, 0x4e54560000000000, Tools.DateToUnixTime(date.AddMinutes(-6)), 0, 0, 100.2, 106, 25, Scope.Order, Side.Buy, 'A', OrderSource.NTV, "AAAA")
};
tasks.Add(Task.Run(() =>
{
Thread.Sleep(TimeSpan.FromSeconds(2));
var eventPlayer = new EventPlayer <IDxOrder>(GetSubscriptionFromFeed <IDxOrder>(threadSymbol));
eventPlayer.PlaySnapshot(threadSymbol, threadPlayedOrders);
}));
var threadPromise = DXEndpoint.GetInstance().Feed
.GetIndexedEventsPromise <IDxOrder>(threadSymbol, OrderSource.NTV, new CancellationTokenSource(TimeSpan.FromSeconds(20)).Token)
.ContinueWith((resultPromise) =>
{
foreach (var o in resultPromise.Result)
{
Assert.AreEqual(threadSymbol, o.EventSymbol);
}
});
tasks.Add(threadPromise);
}
;
Assert.DoesNotThrow(() =>
{
Task.WaitAll(tasks.ToArray());
});
}
public void GetTimeSeriesPromiseTest()
{
//create default endpoint
DXEndpoint.Create();
var symbol = "SYMA";
//try to create promise with invalid parameters
Assert.Catch(typeof(ArgumentException), () =>
{
try
{
DXFeed.GetInstance().GetTimeSeriesPromise <IDxGreeks>(null, 0, 0, CancellationToken.None).Wait();
}
catch (AggregateException ae)
{
foreach (var inner in ae.InnerExceptions)
{
throw inner;
}
}
});
//try to cancel promise
CancellationTokenSource cancelSource = new CancellationTokenSource();
Task <List <IDxGreeks> > promise = DXFeed.GetInstance().GetTimeSeriesPromise <IDxGreeks>(symbol, 0, 0, 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().GetTimeSeriesPromise <IDxGreeks>(symbol, 0, 0, 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().GetTimeSeriesPromise <IDxGreeks>(symbol, 0, 0, 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().GetTimeSeriesPromise <IDxGreeks>(symbol, 0, 0, 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
DateTime date = DateTime.Now;
var playedGreeks = new PlayedGreeks[] {
new PlayedGreeks(symbol, 0, 5, Tools.DateToUnixTime(date), 156.789, 111, 155, 166, 177, 188, 199),
new PlayedGreeks(symbol, 0, 4, Tools.DateToUnixTime(date.AddMinutes(-1)), 256.789, 211, 255, 266, 277, 288, 299),
new PlayedGreeks(symbol, 0, 3, Tools.DateToUnixTime(date.AddMinutes(-2)), 356.789, 311, 355, 366, 377, 388, 399),
new PlayedGreeks(symbol, 0, 2, Tools.DateToUnixTime(date.AddMinutes(-3)), 456.789, 411, 455, 466, 477, 488, 499),
new PlayedGreeks(symbol, 0, 1, Tools.DateToUnixTime(date.AddMinutes(-4)), 556.789, 511, 555, 566, 577, 588, 599),
};
var expectedGreeks = new PlayedGreeks[] {
new PlayedGreeks(symbol, 0, 4, Tools.DateToUnixTime(date.AddMinutes(-1)), 256.789, 211, 255, 266, 277, 288, 299),
new PlayedGreeks(symbol, 0, 3, Tools.DateToUnixTime(date.AddMinutes(-2)), 356.789, 311, 355, 366, 377, 388, 399),
new PlayedGreeks(symbol, 0, 2, Tools.DateToUnixTime(date.AddMinutes(-3)), 456.789, 411, 455, 466, 477, 488, 499)
};
Task eventPlayerTask = Task.Run(() =>
{
Thread.Sleep(TimeSpan.FromSeconds(2));
EventPlayer <IDxGreeks> eventPlayer = new EventPlayer <IDxGreeks>(GetSubscriptionFromFeed <IDxGreeks>(symbol));
eventPlayer.PlaySnapshot(symbol, playedGreeks);
});
cancelSource = new CancellationTokenSource(TimeSpan.FromSeconds(10));
promise = DXEndpoint.Create().Feed.GetTimeSeriesPromise <IDxGreeks>(symbol, Tools.DateToUnixTime(date.AddMinutes(-3)), Tools.DateToUnixTime(date.AddMinutes(-1)), cancelSource.Token);
Assert.DoesNotThrow(() =>
{
Task.WaitAll(promise, eventPlayerTask);
});
var receivedGreeks = promise.Result;
receivedGreeks.Reverse();
Assert.AreEqual(expectedGreeks.Length, receivedGreeks.Count);
for (int i = 0; i < expectedGreeks.Length; i++)
{
Assert.AreEqual(symbol, receivedGreeks[i].EventSymbol.ToString());
CompareGreeks(expectedGreeks[i], receivedGreeks[i]);
}
//thread-safety case
DXEndpoint.Create();
List <Task> tasks = new List <Task>();
for (int i = 0; i < 10; i++)
{
var threadSymbol = symbol + i.ToString();
var threadPlayedGreeks = new PlayedGreeks[] {
new PlayedGreeks(symbol, 0, 5, Tools.DateToUnixTime(date), 156.789, 111, 155, 166, 177, 188, 199),
new PlayedGreeks(symbol, 0, 4, Tools.DateToUnixTime(date.AddMinutes(-1)), 256.789, 211, 255, 266, 277, 288, 299),
new PlayedGreeks(symbol, 0, 3, Tools.DateToUnixTime(date.AddMinutes(-2)), 356.789, 311, 355, 366, 377, 388, 399),
new PlayedGreeks(symbol, 0, 2, Tools.DateToUnixTime(date.AddMinutes(-3)), 456.789, 411, 455, 466, 477, 488, 499),
new PlayedGreeks(symbol, 0, 1, Tools.DateToUnixTime(date.AddMinutes(-4)), 556.789, 511, 555, 566, 577, 588, 599),
};
tasks.Add(Task.Run(() =>
{
Thread.Sleep(TimeSpan.FromSeconds(2));
var eventPlayer = new EventPlayer <IDxGreeks>(GetSubscriptionFromFeed <IDxGreeks>(threadSymbol));
eventPlayer.PlaySnapshot(threadSymbol, threadPlayedGreeks);
}));
var threadPromise = DXEndpoint.GetInstance().Feed
.GetTimeSeriesPromise <IDxGreeks>(threadSymbol, Tools.DateToUnixTime(date.AddMinutes(-3)), Tools.DateToUnixTime(date.AddMinutes(-1)), new CancellationTokenSource(TimeSpan.FromSeconds(20)).Token)
.ContinueWith((resultPromise) =>
{
foreach (var g in resultPromise.Result)
{
Assert.AreEqual(threadSymbol, g.EventSymbol);
}
});
tasks.Add(threadPromise);
}
;
Assert.DoesNotThrow(() =>
{
Task.WaitAll(tasks.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());
});
}
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());
});
}