public void TestExplicitlySettingMarketPriceAllowsMarketToMarketTrades()
{
var book = new SimpleOrderBook();
var order0 = new SimpleOrder(sideBuy, prcMkt, q100);
var order1 = new SimpleOrder(sideSell, prcMkt, q100);
Assert.True(Utils.AddAndVerify(book, order0, ExpectNoMatch));
Assert.True(Utils.AddAndVerify(book, order1, ExpectNoMatch));
{
var fc0 = new FillChecker(order0, 0, 0);
var fc1 = new FillChecker(order1, 0, 0);
book.MarketPrice = prc0;
fc0.AssertFillSuccess();
fc1.AssertFillSuccess();
}
var order2 = new SimpleOrder(sideBuy, prcMkt, q100);
var order3 = new SimpleOrder(sideSell, prcMkt, q100);
{
var fc0 = new FillChecker(order0, q100, q100 * prc0);
var fc1 = new FillChecker(order1, q100, q100 * prc0);
var fc2 = new FillChecker(order2, q100, q100 * prc0);
var fc3 = new FillChecker(order3, q100, q100 * prc0);
Assert.True(Utils.AddAndVerify(book, order2, ExpectMatch, ExpectComplete));
Assert.True(Utils.AddAndVerify(book, order3, ExpectMatch, ExpectComplete));
fc0.AssertFillSuccess();
fc1.AssertFillSuccess();
fc2.AssertFillSuccess();
fc3.AssertFillSuccess();
}
}
public void TestBidsMultimapSortCorrect()
{
var bids = new TrackerMap();
var order0 = new SimpleOrder(true, 1250, 100);
var order1 = new SimpleOrder(true, 1255, 100);
var order2 = new SimpleOrder(true, 1240, 100);
var order3 = new SimpleOrder(true, Constants.MarketOrderPrice, 100);
var order4 = new SimpleOrder(true, 1245, 100);
bids.Add(new ComparablePrice(true, order0.Price), new SimpleTracker(order0, OrderConditions.NoConditions));
bids.Add(new ComparablePrice(true, order1.Price), new SimpleTracker(order1, OrderConditions.NoConditions));
bids.Add(new ComparablePrice(true, order2.Price), new SimpleTracker(order2, OrderConditions.NoConditions));
bids.Add(new ComparablePrice(true, order3.Price), new SimpleTracker(order3, OrderConditions.NoConditions));
bids.Add(new ComparablePrice(true, order4.Price), new SimpleTracker(order4, OrderConditions.NoConditions));
var expectedOrder = new[] { order3, order1, order0, order4, order2 };
var index = 0;
foreach (var pair in bids)
{
Assert.AreEqual(expectedOrder[index].Price, pair.Value.Order.Price);
Assert.AreEqual(expectedOrder[index], pair.Value.Order);
++index;
}
//TODO missing assertions here
}
public void TestTradeSetsMarketPrice()
{
var book = new SimpleOrderBook();
var order0 = new SimpleOrder(sideBuy, prcMkt, q100);
var order1 = new SimpleOrder(sideSell, prcMkt, q100);
Assert.True(Utils.AddAndVerify(book, order0, ExpectNoMatch));
Assert.True(Utils.AddAndVerify(book, order1, ExpectNoMatch));
Assert.Equal((Price)0, book.MarketPrice);
var order2 = new SimpleOrder(sideBuy, prc0, q100);
{
var fc0 = new FillChecker(order0, 0, 0);
var fc1 = new FillChecker(order1, q100, q100 * prc0);
var fc2 = new FillChecker(order2, q100, q100 * prc0);
Assert.True(Utils.AddAndVerify(book, order2, ExpectMatch, ExpectComplete));
fc0.AssertFillSuccess();
fc1.AssertFillSuccess();
fc2.AssertFillSuccess();
}
Assert.Equal(prc0, book.MarketPrice);
var order3 = new SimpleOrder(sideSell, prcMkt, q100);
{
var fc0 = new FillChecker(order0, q100, q100 * prc0);
var fc3 = new FillChecker(order3, q100, q100 * prc0);
Assert.True(Utils.AddAndVerify(book, order3, ExpectMatch, ExpectComplete));
fc0.AssertFillSuccess();
fc3.AssertFillSuccess();
}
Assert.Equal(prc0, book.MarketPrice);
}
public void TestOneAonBidOneAonAsk()
{
var order_book = new SimpleOrderBook();
var bid1 = new SimpleOrder(buySide, prc1, qty1); // AON
var ask1 = new SimpleOrder(sellSide, prc1, qty1); // AON
// Prime the order book: No Matches
Assert.IsTrue(AddAndVerify(order_book, bid1, expectNoMatch, expectNoComplete, AON));
// Verify sizes
Assert.AreEqual(1, order_book.Bids.Count());
Assert.AreEqual(0, order_book.Asks.Count());
// Verify depth
var dc = new DepthCheck(order_book.Depth);
Assert.IsTrue(dc.VerifyBid(prc1, 1, qty1));
// Add matching order
{
var fc1 = new FillChecker(bid1, qty1, qty1 * prc1);
var fc3 = new FillChecker(ask1, qty1, qty1 * prc1);
Assert.IsTrue(AddAndVerify(order_book, ask1, expectMatch, expectComplete, AON));
fc1.AssertFillSuccess();
fc3.AssertFillSuccess();
}
// Verify sizes
Assert.AreEqual(0, order_book.Bids.Count());
Assert.AreEqual(0, order_book.Asks.Count());
}
public void SimpleOrder_Returns_Null_On_FirstOrDefault_When_Empty()
{
var orders = new SimpleOrder();
var item = orders.FirstOrDefault();
Assert.That(item == null, Is.True);
}
public void TestAsksMultimapSortCorrect()
{
var asks = new TrackerMap();
var order0 = new SimpleOrder(false, 3250, 100);
var order1 = new SimpleOrder(false, 3235, 800);
var order2 = new SimpleOrder(false, 3230, 200);
var order3 = new SimpleOrder(false, 0, 200);
var order4 = new SimpleOrder(false, 3245, 100);
var order5 = new SimpleOrder(false, 3265, 200);
asks.Add(new ComparablePrice(false, order0.Price), new SimpleTracker(order0, OrderConditions.NoConditions));
asks.Add(new ComparablePrice(false, order1.Price), new SimpleTracker(order1, OrderConditions.NoConditions));
asks.Add(new ComparablePrice(false, order2.Price), new SimpleTracker(order2, OrderConditions.NoConditions));
asks.Add(new ComparablePrice(false, order3.Price), new SimpleTracker(order3, OrderConditions.NoConditions));
asks.Add(new ComparablePrice(false, order4.Price), new SimpleTracker(order4, OrderConditions.NoConditions));
asks.Add(new ComparablePrice(false, order5.Price), new SimpleTracker(order5, OrderConditions.NoConditions));
var expectedOrder = new[] { order3, order2, order1, order4, order0, order5 };
var index = 0;
foreach (var pair in asks)
{
Assert.AreEqual(expectedOrder[index].Price, pair.Value.Order.Price);
Assert.AreEqual(expectedOrder[index], pair.Value.Order);
++index;
}
//TODO missing assertions here
}
public void TestFokAskPartialMatch()
{
var order_book = new SimpleOrderBook();
var ask2 = new SimpleOrder(false, 1252, 100);
var ask1 = new SimpleOrder(false, 1251, 100);
var ask0 = new SimpleOrder(false, 1250, 300);
var bid0 = new SimpleOrder(true, 1250, 100);
var bid1 = new SimpleOrder(true, 1249, 100);
var bid2 = new SimpleOrder(true, 1248, 100);
// No match
Assert.IsTrue(AddAndVerify(order_book, ask1, false));
Assert.IsTrue(AddAndVerify(order_book, ask2, false));
Assert.IsTrue(AddAndVerify(order_book, bid0, false));
Assert.IsTrue(AddAndVerify(order_book, bid1, false));
Assert.IsTrue(AddAndVerify(order_book, bid2, false));
// Verify sizes
Assert.AreEqual(3, order_book.Bids.Count());
Assert.AreEqual(2, order_book.Asks.Count());
// Verify depth
var dc = new DepthCheck(order_book.Depth);
Assert.IsTrue(dc.VerifyBid(1250, 1, 100));
Assert.IsTrue(dc.VerifyBid(1249, 1, 100));
Assert.IsTrue(dc.VerifyBid(1248, 1, 100));
Assert.IsTrue(dc.VerifyAsk(1251, 1, 100));
Assert.IsTrue(dc.VerifyAsk(1252, 1, 100));
// Partial Match - will not fill and will cancel order
{
var fc0 = new FillChecker(bid0, 0, 0);
var fc1 = new FillChecker(bid1, 0, 0);
var fc2 = new FillChecker(bid2, 0, 0);
var fc3 = new FillChecker(ask0, 0, 0, FOK);
var fc4 = new FillChecker(ask1, 0, 0);
var fc5 = new FillChecker(ask2, 0, 0);
Assert.IsTrue(AddAndVerify(order_book, ask0, false, false, FOK));
fc0.AssertFillSuccess();
fc1.AssertFillSuccess();
fc2.AssertFillSuccess();
fc3.AssertFillSuccess();
fc4.AssertFillSuccess();
fc5.AssertFillSuccess();
}
// Verify sizes
Assert.AreEqual(3, order_book.Bids.Count());
Assert.AreEqual(2, order_book.Asks.Count());
// Verify depth
dc.Reset();
Assert.IsTrue(dc.VerifyBid(1250, 1, 100));
Assert.IsTrue(dc.VerifyBid(1249, 1, 100));
Assert.IsTrue(dc.VerifyBid(1248, 1, 100));
Assert.IsTrue(dc.VerifyAsk(1251, 1, 100));
Assert.IsTrue(dc.VerifyAsk(1252, 1, 100));
}
public void TestIocBidFullMatch()
{
var order_book = new SimpleOrderBook();
var ask2 = new SimpleOrder(false, 1252, 100);
var ask1 = new SimpleOrder(false, 1251, 100);
var ask0 = new SimpleOrder(false, 1250, 400);
var bid0 = new SimpleOrder(true, 1250, 300);
var bid1 = new SimpleOrder(true, 1249, 100);
var bid2 = new SimpleOrder(true, 1248, 100);
// No match
Assert.True(AddAndVerify(order_book, ask0, false));
Assert.True(AddAndVerify(order_book, ask1, false));
Assert.True(AddAndVerify(order_book, ask2, false));
Assert.True(AddAndVerify(order_book, bid1, false));
Assert.True(AddAndVerify(order_book, bid2, false));
// Verify sizes
Assert.Equal(2, order_book.Bids.Count());
Assert.Equal(3, order_book.Asks.Count());
// Verify depth
var dc = new DepthCheck(order_book.Depth);
Assert.True(dc.VerifyBid(1249, 1, 100));
Assert.True(dc.VerifyBid(1248, 1, 100));
Assert.True(dc.VerifyAsk(1250, 1, 400));
Assert.True(dc.VerifyAsk(1251, 1, 100));
Assert.True(dc.VerifyAsk(1252, 1, 100));
// Full Match - will complete order
{
var fc0 = new FillChecker(bid0, 300, 1250 * 300, IOC);
var fc1 = new FillChecker(bid1, 0, 0);
var fc2 = new FillChecker(bid2, 0, 0);
var fc3 = new FillChecker(ask0, 300, 1250 * 300);
var fc4 = new FillChecker(ask1, 0, 0);
var fc5 = new FillChecker(ask2, 0, 0);
Assert.True(AddAndVerify(order_book, bid0, true, true, IOC));
fc0.AssertFillSuccess();
fc1.AssertFillSuccess();
fc2.AssertFillSuccess();
fc3.AssertFillSuccess();
fc4.AssertFillSuccess();
fc5.AssertFillSuccess();
}
// Verify sizes
Assert.Equal(2, order_book.Bids.Count());
Assert.Equal(3, order_book.Asks.Count());
// Verify depth
dc.Reset();
Assert.True(dc.VerifyBid(1249, 1, 100));
Assert.True(dc.VerifyBid(1248, 1, 100));
Assert.True(dc.VerifyAsk(1250, 1, 100));
Assert.True(dc.VerifyAsk(1251, 1, 100));
Assert.True(dc.VerifyAsk(1252, 1, 100));
}
private static void Display(SimpleOrder order)
{
Console.WriteLine();
foreach (OrderItem item in order)
{
Console.WriteLine(item);
}
}
public void TestRegAskMatchMulti()
{
var order_book = new SimpleOrderBook();
var ask0 = new SimpleOrder(sellSide, prc2, qty1);
var ask1 = new SimpleOrder(sellSide, prc0, qty4);
var bid1 = new SimpleOrder(buySide, prc1, qty1); // AON
var bid2 = new SimpleOrder(buySide, prc1, qty1); // AON
var bid0 = new SimpleOrder(buySide, prc0, qty7);
// Calculate some expected results
// ask1(400) matches bid 1(100), bid2(100), and part(200) of bid0
// leaving 500 shares of bid 0)
Quantity bid0FillQty = qty4 - qty1 - qty1;
Quantity bid0RemainQty = qty7 - bid0FillQty;
decimal bid0FillAmount = bid0FillQty * prc0;
decimal bid1FillAmount = prc1 * qty1;
decimal bid2FillAmount = prc1 * qty1;
decimal ask1FillAmount = bid1FillAmount + bid2FillAmount + bid0FillAmount;
// No match
Assert.IsTrue(AddAndVerify(order_book, ask0, expectNoMatch));
Assert.IsTrue(AddAndVerify(order_book, bid0, expectNoMatch));
Assert.IsTrue(AddAndVerify(order_book, bid1, expectNoMatch, expectNoComplete, AON));
Assert.IsTrue(AddAndVerify(order_book, bid2, expectNoMatch, expectNoComplete, AON));
// Verify sizes
Assert.AreEqual(3, order_book.Bids.Count());
Assert.AreEqual(1, order_book.Asks.Count());
// Verify depth
var dc = new DepthCheck(order_book.Depth);
Assert.IsTrue(dc.VerifyBid(prc1, 2, qty2));
Assert.IsTrue(dc.VerifyBid(prc0, 1, qty7));
Assert.IsTrue(dc.VerifyAsk(prc2, 1, qty1));
// Match - complete
{
var fc0 = new FillChecker(bid1, qty1, prc1 * qty1);
var fc1 = new FillChecker(bid2, qty1, prc1 * qty1);
var fc2 = new FillChecker(bid0, qty2, prc0 * qty2);
var fc3 = new FillChecker(ask1, qty4, ask1FillAmount);
Assert.IsTrue(AddAndVerify(order_book, ask1, expectMatch, expectComplete));
fc0.AssertFillSuccess();
fc1.AssertFillSuccess();
fc2.AssertFillSuccess();
fc3.AssertFillSuccess();
}
// Verify depth
dc.Reset();
Assert.IsTrue(dc.VerifyBid(prc0, 1, bid0RemainQty));
Assert.IsTrue(dc.VerifyAsk(prc2, 1, qty1));
// Verify sizes
Assert.AreEqual(1, order_book.Bids.Count());
Assert.AreEqual(1, order_book.Asks.Count());
}
public void TestAonAskNoMatchMulti()
{
var order_book = new SimpleOrderBook();
var ask0 = new SimpleOrder(sellSide, prc2, qty1); // no match (price)
var ask1 = new SimpleOrder(sellSide, prc0, qty6); // AON
var bid0 = new SimpleOrder(buySide, prc0, qty4); // AON no match
var bid1 = new SimpleOrder(buySide, prc1, qty1); // AON
var bid2 = new SimpleOrder(buySide, prc1, qty4);
// No match
Assert.IsTrue(AddAndVerify(order_book, ask0, expectNoMatch));
Assert.IsTrue(AddAndVerify(order_book, bid0, expectNoMatch, expectNoComplete, AON));
Assert.IsTrue(AddAndVerify(order_book, bid1, expectNoMatch, expectNoComplete, AON)); //AON)); //noConditions
Assert.IsTrue(AddAndVerify(order_book, bid2, expectNoMatch));
// Verify sizes
Assert.AreEqual(3, order_book.Bids.Count());
Assert.AreEqual(1, order_book.Asks.Count());
// Verify depth
var dc = new DepthCheck(order_book.Depth);
Assert.IsTrue(dc.VerifyBid(prc1, 2, qty1 + qty4));
Assert.IsTrue(dc.VerifyBid(prc0, 1, qty4));
Assert.IsTrue(dc.VerifyAsk(prc2, 1, qty1));
// This test was bogus -- testing a bug in the matching algorithm
// I fixed the bug and the test started to fail.
// So fixed the test to expect:
// Ask1 (600 AON) should match bid0 (400 AON) + bid1(100) + bid 2(100 of 400)
//
// Now we need a new test of an AON that should NOT match!
// No match
{
// ASSERT_NO_THROW(
var fc0 = new FillChecker(bid0, qty4, prc0 * qty4);
var fc1 = new FillChecker(bid1, qty1, qty1 * prc1);
var fc2 = new FillChecker(bid2, qty1, prc1 * qty1);
var fc3 = new FillChecker(ask1, qty6, prc0 * qty4 + qty1 * prc1 + prc1 * qty1);
Assert.IsTrue(AddAndVerify(order_book, ask1, expectMatch, expectComplete, AON));
fc0.AssertFillSuccess();
fc1.AssertFillSuccess();
fc2.AssertFillSuccess();
fc3.AssertFillSuccess();
//);
}
// Verify depth
dc.Reset();
Assert.IsTrue(dc.VerifyBid(prc1, 1, qty4 - qty1));
// Verify sizes
Assert.AreEqual(1, order_book.Bids.Count());
Assert.AreEqual(1, order_book.Asks.Count());
}
public void TestAonBidMatchMulti()
{
var order_book = new SimpleOrderBook();
var ask3 = new SimpleOrder(sellSide, prc2, qty1);
var ask2 = new SimpleOrder(sellSide, prc2, qty1);
var ask1 = new SimpleOrder(sellSide, prc1, qty4); // AON no match
var ask0 = new SimpleOrder(sellSide, prc1, qty4);
var bid1 = new SimpleOrder(buySide, MARKET_ORDER_PRICE, qty6); // AON
var bid0 = new SimpleOrder(buySide, prc0, qty1);
// No match
Assert.IsTrue(AddAndVerify(order_book, bid0, expectNoMatch));
Assert.IsTrue(AddAndVerify(order_book, ask0, expectNoMatch));
Assert.IsTrue(AddAndVerify(order_book, ask1, expectNoMatch, expectNoComplete, AON));
Assert.IsTrue(AddAndVerify(order_book, ask2, expectNoMatch));
Assert.IsTrue(AddAndVerify(order_book, ask3, expectNoMatch));
// Verify sizes
Assert.AreEqual(1, order_book.Bids.Count());
Assert.AreEqual(4, order_book.Asks.Count());
// Verify depth
var dc = new DepthCheck(order_book.Depth);
Assert.IsTrue(dc.VerifyBid(prc0, 1, qty1));
Assert.IsTrue(dc.VerifyAsk(prc1, 2, qty4 + qty4));
Assert.IsTrue(dc.VerifyAsk(prc2, 2, qty1 + qty1));
// Match - complete
{
//ASSERT_NO_THROW(
var fc1 = new FillChecker(bid1, qty6, prc1 * qty2 + prc1 * qty4);
var fc2 = new FillChecker(ask0, qty2, prc1 * qty2);
var fc3 = new FillChecker(ask1, qty4, prc1 * qty4);
var fc4 = new FillChecker(ask2, 0, prc2 * (Quantity)0);
var fc5 = new FillChecker(ask3, 0, prc2 * (Quantity)0);
Assert.IsTrue(AddAndVerify(order_book, bid1, expectMatch, expectComplete, AON));
fc1.AssertFillSuccess();
fc2.AssertFillSuccess();
fc3.AssertFillSuccess();
fc4.AssertFillSuccess();
fc5.AssertFillSuccess();
//);
}
// Verify depth
dc.Reset();
Assert.IsTrue(dc.VerifyBid(prc0, 1, qty1));
Assert.IsTrue(dc.VerifyAsk(prc1, 1, qty2));
Assert.IsTrue(dc.VerifyAsk(prc2, 2, qty1 + qty1));
// Verify sizes
Assert.AreEqual(1, order_book.Bids.Count());
Assert.AreEqual(3, order_book.Asks.Count());
}
public void TestDepthCallbacks()
{
var buy0 = new SimpleOrder(true, 3250, 100);
var buy1 = new SimpleOrder(true, 3249, 800);
var buy2 = new SimpleOrder(true, 3248, 300);
var buy3 = new SimpleOrder(true, 3247, 200);
var buy4 = new SimpleOrder(true, 3246, 600);
var buy5 = new SimpleOrder(true, 3245, 300);
var buy6 = new SimpleOrder(true, 3244, 100);
var sell0 = new SimpleOrder(false, 3250, 300);
var sell1 = new SimpleOrder(false, 3251, 200);
var sell2 = new SimpleOrder(false, 3252, 200);
var sell3 = new SimpleOrder(false, 3253, 400);
var sell4 = new SimpleOrder(false, 3254, 300);
var sell5 = new SimpleOrder(false, 3255, 100);
var sell6 = new SimpleOrder(false, 3255, 100);
var listener = new DepthCbListener();
var order_book = new DepthOrderBook();
order_book.SetDepthListener(listener);
// Add buy orders, should be accepted
order_book.Add(buy0);
order_book.Add(buy1);
order_book.Add(buy2);
order_book.Add(buy3);
order_book.Add(buy4);
Assert.Equal(5, listener.changes_.Count);
listener.Reset();
// Add buy orders past end, should be accepted, but not affect depth
order_book.Add(buy5);
order_book.Add(buy6);
Assert.Equal(0, listener.changes_.Count);
listener.Reset();
// Add sell orders, should be accepted and affect depth
order_book.Add(sell5);
order_book.Add(sell4);
order_book.Add(sell3);
order_book.Add(sell2);
order_book.Add(sell1);
order_book.Add(sell0);
Assert.Equal(6, listener.changes_.Count);
listener.Reset();
// Add sell order past end, should be accepted, but not affect depth
order_book.Add(sell6);
Assert.Equal(0, listener.changes_.Count);
listener.Reset();
}
public void TestTradeCallbacks()
{
var order0 = new SimpleOrder(false, 3250, 100);
var order1 = new SimpleOrder(true, 3250, 800);
var order2 = new SimpleOrder(false, 3230, 0);
var order3 = new SimpleOrder(false, 3240, 200);
var order4 = new SimpleOrder(true, 3250, 600);
var listener = new TradeCbListener();
var order_book = new OrderBook();
order_book.SetTradeListener(listener);
// Add order, should be accepted
order_book.Add(order0);
Assert.Equal(0, listener.quantities_.Count);
listener.Reset();
// Add matching order, should result in a trade
order_book.Add(order1);
Assert.Equal(1, listener.quantities_.Count);
Assert.Equal(1, listener.costs_.Count);
Assert.Equal((Quantity)100, listener.quantities_[0]);
Assert.Equal(100 * 3250, listener.costs_[0]);
listener.Reset();
// Add invalid order, should be rejected
order_book.Add(order2);
Assert.Equal(0, listener.quantities_.Count);
listener.Reset();
// Cancel only valid order, should be cancelled
order_book.Cancel(order1);
Assert.Equal(0, listener.quantities_.Count);
listener.Reset();
// Cancel filled order, should be rejected
order_book.Cancel(order0);
Assert.Equal(0, listener.quantities_.Count);
listener.Reset();
// Add a new order and replace it, should be replaced
order_book.Add(order3);
order_book.Replace(order3, 0, 3250);
Assert.Equal(0, listener.quantities_.Count);
listener.Reset();
// Add matching order, should be accepted, followed by a fill
order_book.Add(order4);
Assert.Equal(1, listener.quantities_.Count);
Assert.Equal(1, listener.costs_.Count);
listener.Reset();
// Replace matched order, with too large of a size decrease, replace
// should be rejected
order_book.Replace(order3, -500, 0);
Assert.Equal(0, listener.quantities_.Count);
}
public void TestAonAskNoMatch()
{
var order_book = new SimpleOrderBook();
var ask0 = new SimpleOrder(sellSide, prc2, qty1);
var ask1 = new SimpleOrder(sellSide, prc1, qty4); // AON
var bid1 = new SimpleOrder(buySide, prc1, qty1);
var bid2 = new SimpleOrder(buySide, prc1, qty1);
var bid0 = new SimpleOrder(buySide, prc0, qty7);
// No match
Assert.IsTrue(AddAndVerify(order_book, ask0, expectNoMatch));
Assert.IsTrue(AddAndVerify(order_book, bid0, expectNoMatch));
Assert.IsTrue(AddAndVerify(order_book, bid1, expectNoMatch));
Assert.IsTrue(AddAndVerify(order_book, bid2, expectNoMatch));
// Verify sizes
Assert.AreEqual(3, order_book.Bids.Count());
Assert.AreEqual(1, order_book.Asks.Count());
// Verify depth
var dc = new DepthCheck(order_book.Depth);
Assert.IsTrue(dc.VerifyBid(prc1, 2, qty2));
Assert.IsTrue(dc.VerifyBid(prc0, 1, qty7));
Assert.IsTrue(dc.VerifyAsk(prc2, 1, qty1));
// Match - complete
{
var fc0 = new FillChecker(bid1, qtyNone, prcNone);
var fc1 = new FillChecker(bid2, qtyNone, prcNone);
var fc2 = new FillChecker(bid0, qtyNone, prcNone);
var fc3 = new FillChecker(ask1, qtyNone, prcNone);
Assert.IsTrue(AddAndVerify(order_book, ask1, expectNoMatch, expectNoComplete, AON));
fc0.AssertFillSuccess();
fc1.AssertFillSuccess();
fc2.AssertFillSuccess();
fc3.AssertFillSuccess();
}
// Verify depth
dc.Reset();
Assert.IsTrue(dc.VerifyBid(prc1, 2, qty2));
Assert.IsTrue(dc.VerifyBid(prc0, 1, qty7));
Assert.IsTrue(dc.VerifyAsk(prc1, 1, qty4));
Assert.IsTrue(dc.VerifyAsk(prc2, 1, qty1));
// Verify sizes
Assert.AreEqual(3, order_book.Bids.Count());
Assert.AreEqual(2, order_book.Asks.Count());
}
public void TestOrderCallbacks()
{
var order0 = new SimpleOrder(false, 3250, 100);
var order1 = new SimpleOrder(true, 3250, 800);
var order2 = new SimpleOrder(false, 3230, 0);
var order3 = new SimpleOrder(false, 3240, 200);
var order4 = new SimpleOrder(true, 3250, 600);
var listener = new OrderCbListener();
var order_book = new OrderBook();
order_book.SetOrderListener(listener);
// Add order, should be accepted
order_book.Add(order0);
Assert.AreEqual(1, listener.accepts_.Count);
listener.Reset();
// Add matching order, should be accepted, followed by a fill
order_book.Add(order1);
Assert.AreEqual(1, listener.accepts_.Count);
Assert.AreEqual(1, listener.fills_.Count);
listener.Reset();
// Add invalid order, should be rejected
order_book.Add(order2);
Assert.AreEqual(1, listener.rejects_.Count);
listener.Reset();
// Cancel only valid order, should be cancelled
order_book.Cancel(order1);
Assert.AreEqual(1, listener.cancels_.Count);
listener.Reset();
// Cancel filled order, should be rejected
order_book.Cancel(order0);
Assert.AreEqual(1, listener.cancel_rejects_.Count);
listener.Reset();
// Add a new order and replace it, should be replaced
order_book.Add(order3);
order_book.Replace(order3, 0, 3250);
Assert.AreEqual(1, listener.accepts_.Count);
Assert.AreEqual(1, listener.replaces_.Count);
listener.Reset();
// Add matching order, should be accepted, followed by a fill
order_book.Add(order4);
Assert.AreEqual(1, listener.accepts_.Count);
Assert.AreEqual(1, listener.fills_.Count);
listener.Reset();
// Replace matched order, with too large of a size decrease, replace
// should be rejected
order_book.Replace(order3, -500, 0);
Assert.AreEqual(0, listener.replaces_.Count);
Assert.AreEqual(1, listener.replace_rejects_.Count);
}
public void TestNoMktToMktWithoutPreviousTrade()
{
var book = new SimpleOrderBook();
var order0 = new SimpleOrder(sideBuy, prcMkt, q100);
var order1 = new SimpleOrder(sideSell, prcMkt, q100);
Assert.True(Utils.AddAndVerify(book, order0, ExpectNoMatch));
Assert.True(Utils.AddAndVerify(book, order1, ExpectNoMatch));
var fc0 = new FillChecker(order0, 0, 0);
var fc1 = new FillChecker(order1, 0, 0);
Assert.Equal((Price)0, book.MarketPrice);
}
public void TestStopMarketOrdersTradeWhenStopPriceReached()
{
var book = new SimpleOrderBook();
var order0 = new SimpleOrder(sideBuy, prc53, q100);
var order1 = new SimpleOrder(sideSell, prc57, q100);
book.MarketPrice = prc55;
// Enter seed orders and be sure they don't trade with each other.
Assert.IsTrue(Utils.AddAndVerify(book, order0, expectNoMatch));
Assert.IsTrue(Utils.AddAndVerify(book, order1, expectNoMatch));
// enter stop orders. Be sure they don't trade yet
var order2 = new SimpleOrder(sideBuy, prcMkt, q100, prc56);
var order3 = new SimpleOrder(sideSell, prcMkt, q100, prc54);
Assert.IsTrue(Utils.AddAndVerify(book, order2, expectNoMatch));
Assert.IsTrue(Utils.AddAndVerify(book, order3, expectNoMatch));
var order4 = new SimpleOrder(sideBuy, prc56, q1000, 0, OrderConditions.AllOrNone);
var order5 = new SimpleOrder(sideSell, prc56, q1000, 0, OrderConditions.AllOrNone);
{
var fc0 = new FillChecker(order0, 0, 0);
var fc1 = new FillChecker(order1, q100, q100 * prc57);
var fc2 = new FillChecker(order2, q100, q100 * prc57);
Assert.IsTrue(Utils.AddAndVerify(book, order4, expectNoMatch, expectNoComplete, OrderConditions.AllOrNone));
Assert.IsTrue(Utils.AddAndVerify(book, order5, expectMatch, expectComplete, OrderConditions.AllOrNone));
fc0.AssertFillSuccess();
fc1.AssertFillSuccess();
fc2.AssertFillSuccess();
}
Assert.AreEqual(prc57, book.MarketPrice);
var order6 = new SimpleOrder(sideBuy, prc54, q1000, 0, OrderConditions.AllOrNone);
var order7 = new SimpleOrder(sideSell, prc54, q1000, 0, OrderConditions.AllOrNone);
{
var fc0 = new FillChecker(order0, q100, q100 * prc53);
var fc3 = new FillChecker(order3, q100, q100 * prc53);
// Trade at 54 which should trigger order3 which should trade with order 0 at order 0's price
Assert.IsTrue(Utils.AddAndVerify(book, order6, expectNoMatch, expectNoComplete, OrderConditions.AllOrNone));
Assert.IsTrue(Utils.AddAndVerify(book, order7, expectMatch, expectComplete, OrderConditions.AllOrNone));
fc0.AssertFillSuccess();
fc3.AssertFillSuccess();
}
Assert.AreEqual(prc53, book.MarketPrice);
}
public void TestAonBidNoMatchMulti()
{
var order_book = new SimpleOrderBook();
var ask2 = new SimpleOrder(sellSide, prc2, qty4); // AON no match
var ask1 = new SimpleOrder(sellSide, prc2, qty1);
var ask0 = new SimpleOrder(sellSide, prc1, qty4);
var bid1 = new SimpleOrder(buySide, MARKET_ORDER_PRICE, qty6); // AON
var bid0 = new SimpleOrder(buySide, prc0, qty1);
// No match
Assert.IsTrue(AddAndVerify(order_book, bid0, expectNoMatch));
Assert.IsTrue(AddAndVerify(order_book, ask0, expectNoMatch));
Assert.IsTrue(AddAndVerify(order_book, ask1, expectNoMatch));
Assert.IsTrue(AddAndVerify(order_book, ask2, expectNoMatch, expectNoComplete, AON));
// Verify sizes
Assert.AreEqual(1, order_book.Bids.Count());
Assert.AreEqual(3, order_book.Asks.Count());
// Verify depth
var dc = new DepthCheck(order_book.Depth);
Assert.IsTrue(dc.VerifyBid(prc0, 1, qty1));
Assert.IsTrue(dc.VerifyAsk(prc1, 1, qty4));
Assert.IsTrue(dc.VerifyAsk(prc2, 2, qty4 + qty1));
// Match - complete
{
//ASSERT_NO_THROW(
var fc0 = new FillChecker(bid0, qtyNone, prcNone);
var fc1 = new FillChecker(bid1, qty6, qty2 * prc1 + qty4 * prc2); // filled 600 @ 751000
var fc2 = new FillChecker(ask0, qty2, qty2 * prc1); // filled 200 @ 250200
var fc3 = new FillChecker(ask1, qtyNone, prcNone); // 0
var fc4 = new FillChecker(ask2, qty4, qty4 * prc2); // filled 400 @ 500800
Assert.IsTrue(AddAndVerify(order_book, bid1, expectMatch, expectComplete, AON));
fc0.AssertFillSuccess();
fc1.AssertFillSuccess();
fc2.AssertFillSuccess();
fc3.AssertFillSuccess();
fc4.AssertFillSuccess();
//);
}
// Verify depth
dc.Reset();
Assert.IsTrue(dc.VerifyBid(prc0, 1, qty1));
Assert.IsTrue(dc.VerifyAsk(prc1, 1, qty2));
}
public void TestReplaceAonBidPriceMatch()
{
var order_book = new SimpleOrderBook();
var ask2 = new SimpleOrder(sellSide, prc3, qty1);
var ask1 = new SimpleOrder(sellSide, prc2, qty1);
var ask0 = new SimpleOrder(sellSide, prc1, qty1);
var bid1 = new SimpleOrder(buySide, prc1, qty2); // AON
var bid0 = new SimpleOrder(buySide, prc0, qty1);
// No match
Assert.True(AddAndVerify(order_book, bid0, expectNoMatch));
Assert.True(AddAndVerify(order_book, bid1, expectNoMatch, expectNoComplete, AON));
Assert.True(AddAndVerify(order_book, ask0, expectNoMatch));
Assert.True(AddAndVerify(order_book, ask1, expectNoMatch));
Assert.True(AddAndVerify(order_book, ask2, expectNoMatch));
// Verify sizes
Assert.Equal(2, order_book.Bids.Count());
Assert.Equal(3, order_book.Asks.Count());
// Verify depth
var dc = new DepthCheck(order_book.Depth);
Assert.True(dc.VerifyBid(prc1, 1, qty2));
Assert.True(dc.VerifyBid(prc0, 1, qty1));
Assert.True(dc.VerifyAsk(prc1, 1, qty1));
Assert.True(dc.VerifyAsk(prc2, 1, qty1));
Assert.True(dc.VerifyAsk(prc3, 1, qty1));
// Match - complete
{
var fc1 = new FillChecker(ask0, qty1, prc1 * qty1);
var fc2 = new FillChecker(ask1, qty1, prc2 * qty1);
Assert.True(ReplaceAndVerify(
order_book, bid1, qtyNone, prc2, OrderState.Complete, qty2));
fc1.AssertFillSuccess();
fc2.AssertFillSuccess();
}
// Verify depth
dc.Reset();
Assert.True(dc.VerifyBid(prc0, 1, qty1));
Assert.True(dc.VerifyAsk(prc3, 1, qty1));
// Verify sizes
Assert.Equal(1, order_book.Bids.Count());
Assert.Equal(1, order_book.Asks.Count());
}
private static GetOrderListResult PackageResults(int page, int count, List <Order> result)
{
var orderResult = new GetOrderListResult()
{
TotalItems = count, Page = page
};
foreach (var order in result)
{
var simpleOrder = new SimpleOrder();
Mapper.Map(order, simpleOrder);
orderResult.Items.Add(simpleOrder);
}
return(orderResult);
}
public void TestRegBidMatchMulti()
{
var order_book = new SimpleOrderBook();
var ask2 = new SimpleOrder(sellSide, prc1, qty7);
var ask1 = new SimpleOrder(sellSide, prc1, qty1); // AON
var ask0 = new SimpleOrder(sellSide, prc1, qty1); // AON
var bid1 = new SimpleOrder(buySide, prc1, qty4);
var bid0 = new SimpleOrder(buySide, prc0, qty1);
// No match
Assert.True(AddAndVerify(order_book, bid0, expectNoMatch));
Assert.True(AddAndVerify(order_book, ask0, expectNoMatch, expectNoComplete, AON));
Assert.True(AddAndVerify(order_book, ask1, expectNoMatch, expectNoComplete, AON));
Assert.True(AddAndVerify(order_book, ask2, expectNoMatch, expectNoComplete));
// Verify sizes
Assert.Equal(1, order_book.Bids.Count());
Assert.Equal(3, order_book.Asks.Count());
// Verify depth
var dc = new DepthCheck(order_book.Depth);
Assert.True(dc.VerifyBid(prc0, 1, qty1));
Assert.True(dc.VerifyAsk(prc1, 3, qty7 + qty1 + qty1));
// Match - complete
{
var fc0 = new FillChecker(bid1, qty4, prc1 * qty4);
var fc1 = new FillChecker(ask0, qty1, prc1 * qty1);
var fc2 = new FillChecker(ask1, qty1, prc1 * qty1);
var fc3 = new FillChecker(ask2, qty2, prc1 * qty2);
Assert.True(AddAndVerify(order_book, bid1, expectMatch, expectComplete));
fc0.AssertFillSuccess();
fc1.AssertFillSuccess();
fc2.AssertFillSuccess();
fc3.AssertFillSuccess();
}
// Verify depth
dc.Reset();
Assert.True(dc.VerifyBid(prc0, 1, qty1));
Assert.True(dc.VerifyAsk(prc1, 1, qty4 + qty1));
// Verify sizes
Assert.Equal(1, order_book.Bids.Count());
Assert.Equal(1, order_book.Asks.Count());
}
public void TestStopMarketOrdersOnMarketTradeImmediately()
{
var book = new SimpleOrderBook();
var order0 = new SimpleOrder(sideBuy, prc55, q100);
var order1 = new SimpleOrder(sideSell, prcMkt, q100);
Assert.IsTrue(Utils.AddAndVerify(book, order0, expectNoMatch));
Assert.IsTrue(Utils.AddAndVerify(book, order1, expectMatch, expectComplete));
Assert.AreEqual(prc55, book.MarketPrice);
var order2 = new SimpleOrder(sideBuy, prcMkt, q100, prc55);
var order3 = new SimpleOrder(sideSell, prcMkt, q100, prc55);
Assert.IsTrue(Utils.AddAndVerify(book, order2, expectNoMatch));
Assert.IsTrue(Utils.AddAndVerify(book, order3, expectMatch, expectComplete));
}
public int PlaceSimpleOrder(SimpleOrder simpleOrder)
{
try
{
IBUser user = _userManager.GetUser(simpleOrder.UserName);
if (user != null)
{
IBApi.Contract contract = IBContractSamples.GetContract(simpleOrder);
IBApi.Order order = IBOrderSamples.GetOrder(simpleOrder);
return(user.PlaceOrder(contract, order, simpleOrder.Fund, simpleOrder.Strategy, simpleOrder.Folder));
}
return(-1);
}
catch (Exception ex)
{
_Logger.Error(ex);
throw ex;
}
}
public void TestOneAonBidTwoAsk()
{
var order_book = new SimpleOrderBook();
var bid1 = new SimpleOrder(buySide, prc1, qty3); // AON
var ask1 = new SimpleOrder(sellSide, prc1, qty1); // No Conditions
var ask2 = new SimpleOrder(sellSide, prc1, qty2); // No Conditions
// Prime the order book: No Matches
Assert.IsTrue(AddAndVerify(order_book, bid1, expectNoMatch, expectNoComplete,
AON)); //AON)); //noConditions
// Add an order that does NOT meet the AON condition
Assert.IsTrue(AddAndVerify(order_book, ask1, expectNoMatch, expectNoComplete, NoConditions));
// Verify sizes
Assert.AreEqual(1, order_book.Bids.Count());
Assert.AreEqual(1, order_book.Asks.Count());
// Verify depth
var dc = new DepthCheck(order_book.Depth);
Assert.IsTrue(dc.VerifyBid(prc1, 1, qty3));
Assert.IsTrue(dc.VerifyAsk(prc1, 1, qty1));
// Add matching order
{
var fc1 = new FillChecker(bid1, qty3, qty3 * prc1);
var fc2 = new FillChecker(ask1, qty1, qty1 * prc1);
var fc3 = new FillChecker(ask2, qty2, qty2 * prc1);
Assert.IsTrue(AddAndVerify(order_book, ask2, expectMatch, expectComplete, NoConditions));
fc1.AssertFillSuccess();
fc2.AssertFillSuccess();
fc3.AssertFillSuccess();
}
// Verify sizes
Assert.AreEqual(0, order_book.Bids.Count());
Assert.AreEqual(0, order_book.Asks.Count());
}
public void TestStopOrdersOffMarketNoTrade()
{
var book = new SimpleOrderBook();
var order0 = new SimpleOrder(sideBuy, prc55, q100);
var order1 = new SimpleOrder(sideSell, prcMkt, q100);
// Enter order to generate a trade establishing market price
Assert.IsTrue(Utils.AddAndVerify(book, order0, expectNoMatch));
Assert.IsTrue(Utils.AddAndVerify(book, order1, expectMatch, expectComplete));
Assert.AreEqual(prc55, book.MarketPrice);
var order2 = new SimpleOrder(sideBuy, prcMkt, q100, prc56);
var order3 = new SimpleOrder(sideSell, prcMkt, q100, prc54);
Assert.IsTrue(Utils.AddAndVerify(book, order2, expectNoMatch));
Assert.IsTrue(Utils.AddAndVerify(book, order3, expectNoMatch));
// Orders were accepted, but not traded
Assert.AreEqual(OrderState.Accepted, order2.State);
Assert.AreEqual(OrderState.Accepted, order3.State);
}
public SimpleOrder PostSaveForm([FromForm] SimpleOrder item)
{
return(_simpleOrders.Create(item));
}
public static void Main()
{
SimpleOrder weekly = new SimpleOrder();
weekly.Changed += new
EventHandler <SimpleOrderChangedEventArgs>(ChangedHandler);
// The Add method, inherited from Collection, takes OrderItem.
//
weekly.Add(new OrderItem(110072674, "Widget", 400, 45.17));
weekly.Add(new OrderItem(110072675, "Sprocket", 27, 5.3));
weekly.Add(new OrderItem(101030411, "Motor", 10, 237.5));
weekly.Add(new OrderItem(110072684, "Gear", 175, 5.17));
Display(weekly);
// The Contains method of KeyedCollection takes TKey.
//
Console.WriteLine("\nContains(101030411): {0}",
weekly.Contains(101030411));
// The default Item property of KeyedCollection takes the key
// type, Integer. The property is read-only.
//
Console.WriteLine("\nweekly[101030411].Description: {0}",
weekly[101030411].Description);
// The Remove method of KeyedCollection takes a key.
//
Console.WriteLine("\nRemove(101030411)");
weekly.Remove(101030411);
// The Insert method, inherited from Collection, takes an
// index and an OrderItem.
//
Console.WriteLine("\nInsert(2, new OrderItem(...))");
weekly.Insert(2, new OrderItem(111033401, "Nut", 10, .5));
// The default Item property is overloaded. One overload comes
// from KeyedCollection<int, OrderItem>; that overload
// is read-only, and takes Integer because it retrieves by key.
// The other overload comes from Collection<OrderItem>, the
// base class of KeyedCollection<int, OrderItem>; it
// retrieves by index, so it also takes an Integer. The compiler
// uses the most-derived overload, from KeyedCollection, so the
// only way to access SimpleOrder by index is to cast it to
// Collection<OrderItem>. Otherwise the index is interpreted
// as a key, and KeyNotFoundException is thrown.
//
Collection <OrderItem> coweekly = weekly;
Console.WriteLine("\ncoweekly[2].Description: {0}",
coweekly[2].Description);
Console.WriteLine("\ncoweekly[2] = new OrderItem(...)");
coweekly[2] = new OrderItem(127700026, "Crank", 27, 5.98);
OrderItem temp = coweekly[2];
// The IndexOf method, inherited from Collection<OrderItem>,
// takes an OrderItem instead of a key.
//
Console.WriteLine("\nIndexOf(temp): {0}", weekly.IndexOf(temp));
// The inherited Remove method also takes an OrderItem.
//
Console.WriteLine("\nRemove(temp)");
weekly.Remove(temp);
Console.WriteLine("\nRemoveAt(0)");
weekly.RemoveAt(0);
// Increase the quantity for a line item.
Console.WriteLine("\ncoweekly(1) = New OrderItem(...)");
coweekly[1] = new OrderItem(coweekly[1].PartNumber,
coweekly[1].Description, coweekly[1].Quantity + 1000,
coweekly[1].UnitPrice);
Display(weekly);
Console.WriteLine();
weekly.Clear();
}
private static SimpleOrderCollection PrepareSimpleOrders()
{
SimpleOrder order15 = new SimpleOrder() { OrderNo = "15", OrderName = "第15号订单" };
SimpleOrder order1 = new SimpleOrder() { OrderNo = "01", OrderName = "第1号订单" };
SimpleOrder order10 = new SimpleOrder() { OrderNo = "10", OrderName = "第10号订单" };
SimpleOrderCollection result = new SimpleOrderCollection();
result.Add(order15);
result.Add(order1);
result.Add(order10);
return result;
}
public void TestAonAskMatchMulti()
{
var order_book = new SimpleOrderBook();
var ask0 = new SimpleOrder(sellSide, prc2, qty1); // no match due to price
var ask1 = new SimpleOrder(sellSide, prc0, qty6); // AON
var bid1 = new SimpleOrder(buySide, prc1, qty1); // AON
var bid2 = new SimpleOrder(buySide, prc1, qty1);
var bid3 = new SimpleOrder(buySide, prc1, qty1);
var bid0 = new SimpleOrder(buySide, prc0, qty7);
// No match
Assert.IsTrue(AddAndVerify(order_book, ask0, expectNoMatch));
Assert.IsTrue(AddAndVerify(order_book, bid0, expectNoMatch));
Assert.IsTrue(AddAndVerify(order_book, bid1, expectNoMatch, expectNoComplete, AON));
Assert.IsTrue(AddAndVerify(order_book, bid2, expectNoMatch));
Assert.IsTrue(AddAndVerify(order_book, bid3, expectNoMatch));
// Verify sizes
Assert.AreEqual(4, order_book.Bids.Count());
Assert.AreEqual(1, order_book.Asks.Count());
// Verify depth
var dc = new DepthCheck(order_book.Depth);
Assert.IsTrue(dc.VerifyBid(prc1, 3, qty3));
Assert.IsTrue(dc.VerifyBid(prc0, 1, qty7));
Assert.IsTrue(dc.VerifyAsk(prc2, 1, qty1));
// Match - complete
{
// ASSERT_NO_THROW(
decimal b1Cost = prc1 * qty1;
var fc0 = new FillChecker(bid1, qty1, b1Cost);
decimal b2Cost = prc1 * qty1;
var fc1 = new FillChecker(bid2, qty1, b2Cost);
decimal b3Cost = prc1 * qty1;
var fc2 = new FillChecker(bid3, qty1, b3Cost);
Quantity b0Fill = qty6 - qty1 - qty1 - qty1;
decimal b0Cost = b0Fill * prc0;
var fc3 = new FillChecker(bid0, b0Fill, b0Cost);
decimal a1Cost = b0Cost + b1Cost + b2Cost + b3Cost;
var fc4 = new FillChecker(ask1, qty6, a1Cost);
Assert.IsTrue(AddAndVerify(order_book, ask1, expectMatch, expectComplete, AON));
fc0.AssertFillSuccess();
fc1.AssertFillSuccess();
fc2.AssertFillSuccess();
fc3.AssertFillSuccess();
fc4.AssertFillSuccess();
// );
}
// Verify depth
dc.Reset();
Assert.IsTrue(dc.VerifyBid(prc0, 1, qty4));
Assert.IsTrue(dc.VerifyAsk(prc2, 1, qty1));
// Verify sizes
Assert.AreEqual(1, order_book.Bids.Count());
Assert.AreEqual(1, order_book.Asks.Count());
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "My API", Version = "v1"
});
});
services.AddCors(options =>
{
options.AddPolicy(name: MyAllowSpecificOrigins,
builder =>
{
builder.AllowAnyOrigin()
.AllowAnyHeader()
.AllowAnyMethod();
});
});
services.AddSingleton <InMemStore <Message> >(x => new InMemStore <Message>(Message.TestData()));
services.AddSingleton <InMemStore <Client> >(x => new InMemStore <Client>(Client.Init()));
services.AddSingleton <InMemStore <Bonsai> >(x => new InMemStore <Bonsai>(Bonsai.Init()));
services.AddSingleton <InMemStore <CheckoutOption> >(x => new InMemStore <CheckoutOption>(CheckoutOption.Init()));
services.AddSingleton <InMemStore <SimpleOrder> >(x => new InMemStore <SimpleOrder>(SimpleOrder.Init()));
}
