public void Place_New_Buy_Order_And_Match_Exist_Sell_Orders()
{
orderbook = new FullOrderbook();
var ask_orderId_1 = "ask_order_1";
var ask_isBid_1 = false;
var ask_quantity_1 = 5;
var ask_price_1 = 10;
var ask_timestamp_1 = DateTimeOffset.Now;
var ask_order_1 = new LimitOrder(
ask_orderId_1,
ask_isBid_1,
ask_quantity_1,
ask_price_1,
ask_timestamp_1);
var ask_orderId_2 = "ask_order_2";
var ask_isBid_2 = false;
var ask_quantity_2 = 5;
var ask_price_2 = 11;
var ask_timestamp_2 = DateTimeOffset.Now;
var ask_order_2 = new LimitOrder(
ask_orderId_2,
ask_isBid_2,
ask_quantity_2,
ask_price_2,
ask_timestamp_2);
var ask_orderId_3 = "ask_order_3";
var ask_isBid_3 = false;
var ask_quantity_3 = 5;
var ask_price_3 = 11;
var ask_timestamp_3 = DateTimeOffset.Now;
var ask_order_3 = new LimitOrder(
ask_orderId_3,
ask_isBid_3,
ask_quantity_3,
ask_price_3,
ask_timestamp_3);
var ask_orderId_4 = "ask_order_4";
var ask_isBid_4 = false;
var ask_quantity_4 = 5;
var ask_price_4 = 12;
var ask_timestamp_4 = DateTimeOffset.Now;
var ask_order_4 = new LimitOrder(
ask_orderId_4,
ask_isBid_4,
ask_quantity_4,
ask_price_4,
ask_timestamp_4);
var bid_orderId = "bid_order";
var bid_isBid = true;
var bid_quantity = 17;
var bid_price = 12;
var bid_timestamp = DateTimeOffset.Now;
var bid_order = new LimitOrder(
bid_orderId,
bid_isBid,
bid_quantity,
bid_price,
bid_timestamp);
orderbook.PlaceOrder(ask_order_1);
orderbook.PlaceOrder(ask_order_2);
orderbook.PlaceOrder(ask_order_3);
orderbook.PlaceOrder(ask_order_4);
orderbook.PlaceOrder(bid_order);
//<1>. Should have only one ask level at $12 left.
//<2>. Only one order at this level.
//<3>. TotalLevelQuantity at this level should be 3.
Assert.IsNull(orderbook.BestBidLevel);
//Assert <1>
Assert.IsNotNull(orderbook.BestAskLevel);
var bestAskLevels = orderbook.GetBestAskLevels(3);
Assert.AreEqual(1, bestAskLevels.Count);
Assert.AreEqual(12, orderbook.BestAskLevel.LimitPrice);
//Assert <2>
Assert.AreEqual(1, orderbook.BestAskLevel.NumberOfOrders);
//Assert <3>
Assert.AreEqual(3, orderbook.BestAskLevel.TotalLevelQuantity);
}
public void Place_Mutiple_Sell_Orders_With_Different_Prices()
{
orderbook = new FullOrderbook();
var isBid = false;
var orderId_1 = "order1";
var isBid_1 = isBid;
var quantity_1 = 10;
var price_1 = 100;
var timestamp_1 = DateTimeOffset.Now;
var order_1 = new LimitOrder(
orderId_1,
isBid_1,
quantity_1,
price_1,
timestamp_1);
var orderId_2 = "order2";
var isBid_2 = isBid;
var quantity_2 = 20;
var price_2 = 200;
var timestamp_2 = DateTimeOffset.Now;
var order_2 = new LimitOrder(
orderId_2,
isBid_2,
quantity_2,
price_2,
timestamp_2);
var orderId_3 = "order3";
var isBid_3 = isBid;
var quantity_3 = 30;
var price_3 = 300;
var timestamp_3 = DateTimeOffset.Now;
var order_3 = new LimitOrder(
orderId_3,
isBid_3,
quantity_3,
price_3,
timestamp_3);
List <LimitOrder> testOrders = new List <LimitOrder>()
{
order_1, order_2, order_3
};
orderbook.PlaceOrder(order_1);
orderbook.PlaceOrder(order_2);
orderbook.PlaceOrder(order_3);
Assert.IsNotNull(orderbook.AskLevels);
Assert.IsNotNull(orderbook.BestAskLevel);
var bestAsksFromGetBestAskLevels = orderbook.GetBestAskLevels(3);
Assert.IsNotNull(bestAsksFromGetBestAskLevels);
Assert.AreEqual(3, bestAsksFromGetBestAskLevels.Count);
var askLevelEnumerator = orderbook.AskLevels.GetEnumerator();
for (int i = 0; i < 3; i++)
{
Assert.IsTrue(askLevelEnumerator.MoveNext());
var askLevel = askLevelEnumerator.Current;
var testOrder = testOrders[i];
Assert.AreEqual(testOrder.Quantity, askLevel.TotalLevelQuantity);
Assert.AreEqual(testOrder.LimitPrice, askLevel.LimitPrice);
Assert.AreEqual(1, askLevel.NumberOfOrders);
Assert.IsNotNull(askLevel.Orders);
Assert.IsNotNull(askLevel.Orders.List);
Assert.AreEqual(1, askLevel.Orders.List.Count);
Assert.AreEqual(testOrder.OrderId, askLevel.Orders.List.First.Value.OrderId);
Assert.AreEqual(isBid, askLevel.Orders.List.First.Value.IsBid);
Assert.AreEqual(testOrder.Quantity, askLevel.Orders.List.First.Value.Quantity);
Assert.AreEqual(testOrder.LimitPrice, askLevel.Orders.List.First.Value.LimitPrice);
Assert.AreEqual(testOrder.ReceivedTimestamp, askLevel.Orders.List.First.Value.ReceivedTimestamp);
Assert.IsNotNull(askLevel.Orders.Table);
Assert.AreEqual(1, askLevel.Orders.Table.Count);
Assert.AreSame(askLevel.Orders.Table[testOrder.OrderId],
askLevel.Orders.List.First);
Assert.AreSame(askLevel, bestAsksFromGetBestAskLevels[i]);
}
}
