public void CheckFillExecutions(AlgorithmInfo algo)
{
CompareTestValues(true, Util.CompareDouble(algo.AlgoExecutions.SentSellQty, algo.AlgoExecutions.FillBuyQty),
String.Format("Sent Sell Qty ({0}) is not equal to Fill Qty ({1})", algo.AlgoExecutions.SentSellQty, algo.AlgoExecutions.FillBuyQty));
CompareTestValues(true, Util.CompareDouble(algo.AlgoExecutions.SentBuyQty, algo.AlgoExecutions.FillSellQty),
String.Format("Sent Buy Qty ({0}) is not equal to Fill Qty ({1})", algo.AlgoExecutions.SentBuyQty, algo.AlgoExecutions.FillSellQty));
}
public void CompareStatisticAgainstTargetBook(AlgorithmInfo algo)
{
CompareTestValues(true, algo.AlgoDictionary.ContainsKey(BookType.TARGET) && algo.TradeStatistic != null,
"Data is NULL");
double sellQty = 0, buyQty = 0;
foreach (var ens in algo.AlgoDictionary[BookType.TARGET].Entries)
{
if (ens.Side == Side.SELL)
{
sellQty += ens.Quantity;
}
if (ens.Side == Side.BUY)
{
buyQty += ens.Quantity;
}
}
Debug.WriteLine("Trade Statistic Sell Qty: {0}, Target book: {1}", algo.TradeStatistic.OpenSellQty, sellQty);
Debug.WriteLine("Trade Statistic Buy Qty: {0}, Target book: {1}", algo.TradeStatistic.OpenBuyQty, buyQty);
CompareTestValues(true, Util.CompareDouble(algo.TradeStatistic.OpenBuyQty, buyQty),
String.Format("Buy Qty doesn't matched. OpenSellQty: {0}, Sell Qty from book: {1}", algo.TradeStatistic.OpenBuyQty, buyQty));
CompareTestValues(true, Util.CompareDouble(algo.TradeStatistic.OpenSellQty, sellQty),
String.Format("Sell Qty doesn't matched. OpenBuyQty: {0}, Buy Qty from book: {1}", algo.TradeStatistic.OpenSellQty, sellQty));
}
public void InitialisePositionSize(AlgorithmInfo algo)
{
if (algo.TradeStatistic != null && algo.InitTradeStatistic == null)
{
algo.InitTradeStatistic = (AlgoInstrumentStatisticsDto)algo.TradeStatistic.Clone();
}
;
}
public void OnBestBidAsk(AlgorithmInfo algo)
{
List <L2EntryDto> orders = algo.AlgoDictionary[BookType.QUOTE].Entries
.FindAll(o => o.Side == algo.OrderToSend.Side);
if (orders.Count > 0)
{
algo.OrderToSend.Price = FindBestBidAsk(orders);
}
}
public void CompareQuoteAgainstParams(AlgorithmInfo algo)
{
double originalSellQty = algo.PricerConfigInfo.SellQuoteSizes.Split(' ').Sum(x => Double.Parse(x));
double originalBuyQty = algo.PricerConfigInfo.BuyQuoteSizes.Split(' ').Sum(x => Double.Parse(x));
double sellQty = 0, buyQty = 0;
int originalSellLevels = algo.PricerConfigInfo.SellQuoteSizes.Split(' ').Length;
int originalBuyLevels = algo.PricerConfigInfo.BuyQuoteSizes.Split(' ').Length;
int sellLevels = 0, buyLevels = 0;
foreach (var ens in algo.AlgoDictionary[BookType.QUOTE].Entries)
{
if (ens.Side == Side.SELL)
{
sellQty += ens.Quantity;
sellLevels++;
}
if (ens.Side == Side.BUY)
{
buyQty += ens.Quantity;
buyLevels++;
}
}
Debug.WriteLine("Sell levels: {0}", sellLevels);
if (Util.CompareDouble(sellQty, originalSellQty))
{
Debug.WriteLine("OK! Sell Qty: {0}; Original: {1}", sellQty, originalSellQty);
}
else
{
Debug.WriteLine("Error! Sell Qty: {0}; Original: {1}", sellQty, originalSellQty);
}
Debug.WriteLine("Buy levels: {0}", buyLevels);
if (Util.CompareDouble(buyQty, originalBuyQty))
{
Debug.WriteLine("OK! Buy Qty: {0}; Original: {1}", buyQty, originalBuyQty);
}
else
{
Debug.WriteLine("Error! Buy Qty: {0}; Original: {1}", buyQty, originalBuyQty);
}
CompareTestValues <bool>(true, Util.CompareDouble(sellQty, originalSellQty),
String.Format("Sell qty: {0} is not equal to original qty: {1}", sellQty, originalSellQty));
CompareTestValues <bool>(true, Util.CompareDouble(buyQty, originalBuyQty),
String.Format("Buy qty: {0} is not equal to original qty: {1}", buyQty, originalBuyQty));
CompareTestValues <int>(originalSellLevels, sellLevels,
String.Format("Sell levels: {0} are not equal to original levels: {1}", sellLevels, originalSellLevels));
CompareTestValues <int>(originalBuyLevels, buyLevels,
String.Format("Buy levels: {0} are not equal to original levels: {1}", buyLevels, originalBuyLevels));
}
public void CompareSourceAgainstTargetBook(AlgorithmInfo algo)
{
if ((DateTime.Now - StartTestTime).TotalSeconds < WaitAction)
{
return;
}
CompareTestValues(true, algo.AlgoDictionary.ContainsKey(BookType.SOURCE) &&
Algorithms[0].AlgoDictionary.ContainsKey(BookType.TARGET),
"Book is NULL!");
CompareBooks(algo.AlgoDictionary[BookType.SOURCE],
Algorithms[0].AlgoDictionary[BookType.TARGET]);
}
public void CalculateSizeOrders(AlgorithmInfo algo)
{
Debug.WriteLine(algo.IsChangedOrders);
if (!algo.IsChangedOrders)
{
return;
}
DateTime time = DateTime.Now;
Debug.WriteLine("Orders are received: " + time.Hour + ":" + time.Minute + ":" + time.Second + ":" + time.Millisecond);
algo.CalculateOrdersQty();
_receivedTime = time;
}
public void WaitOrderFill(AlgorithmInfo algo, TraderSubscription traderSubscription)
{
algo.SentOrderStatus = SentOrderStatus.PENDING;
int counter = 0;
traderSubscription.SendOrder(algo.OrderToSend, algo.CheckOrderSendSaveId);
while (TestResult && algo.SentOrderStatus == SentOrderStatus.PENDING && counter++ < 50)
{
Thread.Sleep(100);
}
CompareTestValues(true, algo.SentOrderStatus != SentOrderStatus.PENDING, "Order is not filled during 5 sec.");
Debug.WriteLine("Waiting is over, order status: {0}", algo.SentOrderStatus);
Thread.Sleep(1000);
}
public void CompareSpread(AlgorithmInfo algo)
{
if ((DateTime.Now - StartTestTime).TotalSeconds < WaitAction || !algo.AlgoDictionary.ContainsKey(BookType.TARGET))
{
return;
}
double quoteSpread = AlgorithmInfo.CalculateSpread(algo.AlgoDictionary[BookType.QUOTE].Entries);
double targetSpread = AlgorithmInfo.CalculateSpread(algo.AlgoDictionary[BookType.TARGET].Entries);
double paramSpread = AlgorithmInfo.GetSpreadFromParams(null, algo.PricerConfigInfo.MinSpread);
Debug.WriteLine("Quote Spread: {0}, Target Spread: {1}, Parse spread: {2}, MinSpread: {3}",
quoteSpread, targetSpread, paramSpread, algo.PricerConfigInfo.MinSpread);
CompareTestValues(true, quoteSpread - paramSpread >= -Util.Delta && targetSpread - paramSpread >= -Util.Delta,
String.Format("Spreads from Quotes book: {0} and Target book: {1} are less than original spread: {2}", quoteSpread, targetSpread, paramSpread));
}
public void CheckExecutionsInEvents(AlgorithmInfo algo)
{
Debug.WriteLine("Number of alerts: {0}", algo.Alerts.Count);
foreach (var alert in algo.Alerts)
{
DateTime execTime = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds(alert.Timestamp).ToLocalTime();
if (execTime > StartTestTime)
{
if (algo.OrderToSend.Side == Side.BUY)
{
algo.AlgoExecutions.FillSellQty += AlgorithmInfo.GetExecutionSizeFromAlert(alert.Description);
}
if (algo.OrderToSend.Side == Side.SELL)
{
algo.AlgoExecutions.FillBuyQty += AlgorithmInfo.GetExecutionSizeFromAlert(alert.Description);
}
}
}
}
public void CalculateSizeExecutions(AlgorithmInfo algo, DateTime newTime)
{
Debug.WriteLine("Summary executions size: {0}", algo.ChangePositionSize);
if (Util.CompareDouble(algo.ChangePositionSize, 0))
{
return;
}
StartTestTime = newTime;
double maxExecutionsSizeFromParams = algo.OrderToSend.Side == Side.BUY ? AlgorithmInfo.GetQuoteSize(algo.PricerConfigInfo.SellQuoteSizes)
: AlgorithmInfo.GetQuoteSize(algo.PricerConfigInfo.BuyQuoteSizes);
double maxExecutionsSize = algo.OrderToSend.Quantity <= maxExecutionsSizeFromParams ?
algo.OrderToSend.Quantity : maxExecutionsSizeFromParams;
CompareTestValues(true, Math.Abs(algo.ChangePositionSize - algo.ChangePositionSize) < Util.Delta,
String.Format("Size of executions doesn't match with expected. Summary size of executions: {0}, Allowable size: {1}",
algo.ChangePositionSize, maxExecutionsSize));
_receivedTime = DateTime.Now;
}
public void CalculateExecutionsFromAlerts(AlgorithmInfo algo)
{
Debug.WriteLine("CalculateExecutionsFromAlerts, Number of alerts for executions : {0}", algo.Alerts.Count);
algo.ChangePositionSize = 0;
DateTime newTime = DateTime.MinValue;
foreach (var alert in algo.Alerts)
{
DateTime execTime = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds(alert.Timestamp).ToLocalTime();
if (execTime > StartTestTime)
{
algo.ChangePositionSize += AlgorithmInfo.GetExecutionSizeFromAlert(alert.Description);
newTime = execTime > newTime ? execTime : newTime;
}
}
CalculateSizeExecutions(algo, newTime);
}
public void CalculateExecutions(AlgorithmInfo algo)
{
Debug.WriteLine("CalculateExecutions, Number of executions: {0}", algo.Executions.Count);
algo.ChangePositionSize = 0;
DateTime newTime = DateTime.MinValue;
foreach (var exec in algo.Executions)
{
DateTime execTime = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds(exec.Timestamp).ToLocalTime();
if (execTime > StartTestTime)
{
algo.ChangePositionSize += exec.ExecutionSize;
newTime = execTime > newTime ? execTime : newTime;
}
}
CalculateSizeExecutions(algo, newTime);
}
public void CompareOrdersAgainstOpenQty(AlgorithmInfo algo)
{
DateTime time = DateTime.Now;
Debug.WriteLine("CompareOrdersAgainstOpenQty, Seconds after received executions {0}, Current Time: {1}",
(time - _receivedTime).TotalSeconds, time.Hour + ":" + time.Minute + ":" + time.Second + ":" + time.Millisecond);
Debug.WriteLine("Open Buy Qty: {0}, Orders Buy Qty: {1}, Open Sell Qty: {2}, Orders Sell Qty: {3}",
algo.TradeStatistic.OpenBuyQty, algo.OrdersBuyQty, algo.TradeStatistic.OpenSellQty, algo.OrdersSellQty);
if ((DateTime.Now - _receivedTime).TotalSeconds < WaitAction)
{
return;
}
Debug.WriteLine("Enter inside");
CompareTestValues(true, Util.CompareDouble(algo.TradeStatistic.OpenBuyQty, algo.OrdersBuyQty),
String.Format("Open Buy Qty is different: {0}, Orders Buy Qty: {1}", algo.TradeStatistic.OpenBuyQty, algo.OrdersBuyQty));
CompareTestValues(true, Util.CompareDouble(algo.TradeStatistic.OpenSellQty, algo.OrdersSellQty),
String.Format("Open Sell Qty is different: {0}, Orders Sell Qty: {1}", algo.TradeStatistic.OpenSellQty, algo.OrdersSellQty));
_receivedTime = DateTime.Now;
}
public void MonitorChangesPosition(AlgorithmInfo algo)
{
InitialisePositionSize(algo);
Debug.WriteLine("MonitorChangesPosition, Initial Position Size: {0}, Seconds after received executions {1}",
algo.InitTradeStatistic.CurrentPositionSize, (DateTime.Now - _receivedTime).TotalSeconds);
if (algo.TradeStatistic != null && !Util.CompareDouble(algo.ChangePositionSize, 0.0) &&
(DateTime.Now - _receivedTime).TotalSeconds > WaitAction)
{
bool isBuyOrder = algo.OrderToSend.Side == Side.BUY;
algo.ChangePositionSize = isBuyOrder ? -algo.ChangePositionSize : algo.ChangePositionSize;
Console.WriteLine(algo.OrderToSend.Side);
Debug.WriteLine("Enter inside. Initial position size: {0}, Change size: {1}, Current position size: {2} " +
"TradeSellQty: {3}, TradeBuyQty {4}", algo.InitTradeStatistic.CurrentPositionSize,
algo.ChangePositionSize, algo.TradeStatistic.CurrentPositionSize,
algo.TradeStatistic.TradeSellQty, algo.TradeStatistic.TradeBuyQty);
CompareTestValues(true, CompareChangesStatistic(algo.InitTradeStatistic.CurrentPositionSize,
algo.TradeStatistic.CurrentPositionSize, algo.ChangePositionSize),
"Position Size is different from expected");
if (isBuyOrder)
{
CompareTestValues(true,
CompareChangesStatistic(algo.InitTradeStatistic.TradeSellQty, algo.TradeStatistic.TradeSellQty,
Math.Abs(algo.ChangePositionSize)),
"Trade Sell Qty is different from expected");
}
else
{
CompareTestValues(true,
CompareChangesStatistic(algo.InitTradeStatistic.TradeBuyQty, algo.TradeStatistic.TradeBuyQty,
Math.Abs(algo.ChangePositionSize)),
"Trade Buy Qty is different from expected");
}
algo.InitTradeStatistic = (AlgoInstrumentStatisticsDto)algo.TradeStatistic.Clone();
algo.ChangePositionSize = 0;
}
}
