SPARK-287 spreader_WAITING_FOR_CANCEL_ACK done

This commit is contained in:
Taha Afzal committed 2017-12-12 18:33:52 -05:00
1 parent 9ad8a11ac7
commit 89f3f86c92
1 file changed
+124 -212
@@ -1846,8 +1846,6 @@ TEST_CASE ("spreader_WORKING", "[spreader]")
LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_error");
}
}
TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]")
{
ContractLeg leg_1, leg_2;
@@ -1914,12 +1912,40 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]")
spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (45), Price (2001), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(45), Price(2002), Quantity(55), Quantity(25), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (45), Quantity(30), Price(2000), Quantity(70), Quantity(25), false);
// std::vector<SpreaderHedgerData>& hedgers_leg_2 = leg_data_2.get_hedgers();
// bts_assert (hedgers_leg_2.size() == 1);
// SingleFillHedger& hedger = hedgers_leg_2[0].hedger();
// verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20));
LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.initializing");
// send another fill on leg 2 (10)
spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (55), Price (2001), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
// verify the hedgers
// leg 1 should have 3 hedgers, for each of the 3 fills
bts_assert (leg_data_1.n_hedgers() == 3);
for (size_t i = 0; i < leg_data_1.n_hedgers(); i++)
spreader.on_child_update (leg_data_1.get_hedger(i).order_update_message().order_key, api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr);
for (size_t i = 0; i < leg_data_2.n_hedgers(); i++)
spreader.on_child_update (leg_data_2.get_hedger(i).order_update_message().order_key, api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr);
verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
bts_assert (leg_data_2.n_hedgers () == 2);
verify_complete_hedger_state (leg_data_2.get_hedger (0).hedger(), HedgerState::WORKING, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20));
verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), HedgerState::WORKING, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10));
LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.initializing");
// now cancel the spreader
spreader.on_cancel (bts::api::orderman::CancelSpreaderOrder());
auto validate_state = [&]() -> void
{
verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity);
bts_assert (leg_data_1.n_hedgers () == 3);
bts_assert (leg_data_2.n_hedgers () == 2);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
verify_complete_hedger_state (leg_data_2.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20));
verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10));
};
validate_state ();
SECTION("1. init")
{
}
@@ -1930,250 +1956,136 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]")
{
spreader.on_disconnect ();
verify_basic_spreader_state (spreader, SpreaderState::END, spreader_price, spreader_quantity);
// all spreaders should be in the end state
LOG(OrderMan, Diag, "spreader_WORKING.on_disconnect");
// all quoters should go to end state
for (size_t i = 0; i < bookkeeping_data.count(); i++)
{
SpreaderLegData& leg_data = bookkeeping_data.get_leg_data (i);
bts_assert (leg_data.quoter()->test_only_func_quoter_state() == QuoterState::END);
// all hedgers should be in the end state
for (size_t h = 0; h < leg_data.n_hedgers(); h++)
bts_assert (leg_data.get_hedger (h).hedger().test_only_func_hedger_state() == HedgerState::END);
}
LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_disconnect");
}
SECTION("4. on_update")
{
api::orderman::UpdateSpreaderOrder u; u.set_price(-0.05); u.set_quantity (200);
spreader.on_update (u);
verify_basic_spreader_state (spreader, SpreaderState::WORKING, Price (-0.05), Quantity (200));
// check spreader states
LOG(OrderMan, Diag, "spreader_WORKING.on_update");
validate_state();
// order changes dont go through
validate_state();
LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_update");
}
SECTION("5. on_cancel")
{
api::orderman::CancelSpreaderOrder c;
spreader.on_cancel(c);
verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity);
// check spreader states
LOG(OrderMan, Diag, "spreader_WORKING.on_cancel");
// already in cancel state, no change
validate_state();
LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_cancel");
}
SECTION("6. on_book")
{
SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data ();
SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0);
SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1);
// send a book a on leg 1, this should make
// leg 2 send out an order - verify that
Book book_leg_1 = get_book (SecurityKey (leg_1.security().id()), 5,
new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10},
new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {10, 15, 25, 50, 10}, true);
spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_1);
validate_book (book_leg_1, leg_data_1.book());
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_SIZE, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(0), Quantity(0), Quantity(100), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false);
// send a book on leg 2, this should make
// leg 1 send out an order, so orders on
// both legs should be out there now
Book book_leg_2 = get_book (SecurityKey (leg_2.security().id()), 5,
new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {20, 20, 20, 20, 20},
new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {10, 10, 10, 10, 10}, true);
spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_2);
validate_book (book_leg_2, leg_data_2.book());
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false);
bts_assert (leg_data_1.order_key().value() != leg_data_2.order_key().value());
spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_NEW,
Quantity (0), Price (0), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false);
spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_NEW,
Quantity (0), Price (0), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false);
// change the books and make sure the quoter
// adjusts its order
book_leg_1 = get_book (SecurityKey (leg_1.security().id()), 5,
new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10},
new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {10, 10, 10, 10, 10}, true);
spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_1);
validate_book (book_leg_1, leg_data_1.book());
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2003), Quantity(50), Quantity(100), false);
book_leg_2 = get_book (SecurityKey (leg_2.security().id()), 5,
new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {1, 2, 10, 1, 1},
new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {10, 10, 10, 10, 10}, true);
spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_2);
validate_book (book_leg_2, leg_data_2.book());
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(15), Quantity(100), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2003), Quantity(50), Quantity(100), false);
// remove the markets and the orders should be cancelled
book_leg_1 = get_book (SecurityKey (leg_1.security().id()), 5,
new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {0, 0, 0, 0, 0},
new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {0, 0, 0, 0, 0}, true);
book_leg_2 = get_book (SecurityKey (leg_2.security().id()), 5,
new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {0, 0, 0, 0, 0},
new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {0, 0, 0, 0, 0}, true);
spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_1);
spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_2);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(15), Quantity(100), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2003), Quantity(50), Quantity(100), false);
LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// like 4 and 5, should have no effect
set_spreader_orders (spreader, new double[5] {1999, 1998, 1997, 1996, 1995}, new uint16_t[5] {1, 0, 0, 0, 0},
new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {1, 1, 2, 0, 0},
new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {1, 0, 0, 0, 0},
new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {1, 0, 0, 0, 0});
validate_state ();
LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_book");
}
SECTION("7. on_time")
{
}
SECTION("8. on_quoter_order_error")
{
// get orders in working state
// and send an error
set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10},
new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {10, 15, 25, 50, 10},
new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {20, 20, 20, 20, 20},
new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {10, 10, 10, 10, 10});
// verify working orders
SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data ();
SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false);
// send an error now, both quoters should
// go to cancel waiting
std::string err_msg = "error";
spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), &err_msg);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false);
LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_error");
spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (30), Price (2000), &err_msg);
validate_state();
LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_quoter_order_error");
}
SECTION("9. on_quoter_order_fill")
{
set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10},
new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {10, 15, 25, 50, 10},
new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {20, 20, 20, 20, 20},
new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {10, 10, 10, 10, 10});
// verify working orders
SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data ();
SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false);
// now send a 20 lot fill in leg 1,
// verify leg 1's order data
// verify leg 2's order data
// verify that there a hedging order is worked
spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (20), Price (2000), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false);
std::vector<SpreaderHedgerData>& hedgers_leg_2 = leg_data_2.get_hedgers();
bts_assert (hedgers_leg_2.size() == 1);
SingleFillHedger& hedger = hedgers_leg_2[0].hedger();
verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20));
LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_error");
// send another fill on leg 1, this will update the filled
// state of leg 1, but no other action will take place
spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (40), Price (2000.5), nullptr);
verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity);
bts_assert (leg_data_1.n_hedgers () == 3);
bts_assert (leg_data_2.n_hedgers () == 2);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (40), Quantity(55), Price(2003), Quantity(45), Quantity(5), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
verify_complete_hedger_state (leg_data_2.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20));
verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10));
LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_quoter_order_fill");
}
SECTION("10. on_quoter_order_status_update")
{
// already done in 9
// cancelled update
spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (30), Price (2000), nullptr);
verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity);
bts_assert (leg_data_1.n_hedgers () == 3);
bts_assert (leg_data_2.n_hedgers () == 2);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (0), Quantity(55), Price(0), Quantity(0), Quantity(15), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
verify_complete_hedger_state (leg_data_2.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20));
verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10));
LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_quoter_order_status_update");
}
SECTION("11. on_hedger_order_error")
{
//create the same scenario as 9, but send an error on the hedger order
set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10},
new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {10, 15, 25, 50, 10},
new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {20, 20, 20, 20, 20},
new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {10, 10, 10, 10, 10});
// verify working orders
SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data ();
SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false);
spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (20), Price (2000), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false);
std::vector<SpreaderHedgerData>& hedgers_leg_2 = leg_data_2.get_hedgers();
bts_assert (hedgers_leg_2.size() == 1);
SingleFillHedger& hedger = hedgers_leg_2[0].hedger();
verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20));
bts::orderman::OrderKey hedger_order_key = hedgers_leg_2[0].order_update_message().order_key;
spreader.on_child_update (hedger_order_key, api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr);
verify_complete_hedger_state (hedger, HedgerState::WORKING, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20));
std::string err_msg = "error";
spreader.on_child_update (hedger_order_key, api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), &err_msg);
verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false);
verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_CANCEL_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20));
// verify that all quoter and hedgers should
LOG(OrderMan, Diag, "spreader_WORKING.on_hedger_order_error");
spreader.on_child_update (leg_data_1.get_hedger (0).order_update_message().order_key, api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), &err_msg);
validate_state ();
LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_hedger_order_error");
}
SECTION("12. on_hedger_order_update")
{
//create the same scenario as 9, but send an error on the hedger order
set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10},
new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {10, 15, 25, 50, 10},
new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {20, 20, 20, 20, 20},
new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {10, 10, 10, 10, 10});
// verify working orders
SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data ();
SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false);
spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (20), Price (2000), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false);
std::vector<SpreaderHedgerData>& hedgers_leg_2 = leg_data_2.get_hedgers();
bts_assert (hedgers_leg_2.size() == 1);
SingleFillHedger& hedger = hedgers_leg_2[0].hedger();
verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20));
// send fill on the hedger order
bts::orderman::OrderKey hedger_order_key = hedgers_leg_2[0].order_update_message().order_key;
spreader.on_child_update (hedger_order_key, api::orderman::OrderStatus::OS_NEW, Quantity (5), Price (2000), nullptr);
verify_complete_hedger_state (hedger, HedgerState::WORKING, Price(1999), Quantity(20), Quantity(5), Price (1999), Quantity(20), Quantity (15));
// verify that all quoter and hedgers should
LOG(OrderMan, Diag, "spreader_WORKING.on_hedger_order_update");
// send a fill
spreader.on_child_update (leg_data_1.get_hedger (0).order_update_message().order_key, api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (10), Price (2000), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(15), Quantity (10), Price(2002), Quantity (15), Quantity (5));
verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
verify_complete_hedger_state (leg_data_2.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20));
verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10));
LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_hedger_order_update");
}
SECTION("13. on_external_error")
{
SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data ();
SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1);
set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10},
new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {10, 15, 25, 50, 10},
new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {20, 20, 20, 20, 20},
new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {10, 10, 10, 10, 10});
spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (20), Price (2000), nullptr);
SpreaderHedgerData& hedger_data = leg_data_2.get_hedgers()[0];
spreader.on_child_update (hedger_data.order_update_message().order_key, api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr);
std::string err_msg = "external error";
{
std::string err_msg = "error";
spreader.on_external_error (err_msg);
verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false);
verify_complete_hedger_state (hedger_data.hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20));
LOG(OrderMan, Diag, "spreader_WORKING.on_external_error");
validate_state ();
LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_external_error");
}
SECTION("14. on_check_termination")
{
// get active orders working, send a terminal
// status on each order and verify that the
// spreader reached a terminal state
SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data ();
SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1);
set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10},
new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {10, 15, 25, 50, 10},
new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {20, 20, 20, 20, 20},
new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {10, 10, 10, 10, 10});
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// completely fill leg 1, this should cxl the leg 2 quoting order and send a hedge
// fill the hedge completely
// this should cause on_check_termination to return true
spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_FILLED, Quantity (100), Price (1999), nullptr);
// leg1's quoter should be in end state
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(0), Quantity(0), Quantity(0), true);
// leg 2 should cancel its order now
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(100), Price(2002), Quantity(100), Quantity(0), true);
spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(100), Price(0), Quantity(0), Quantity(0), true);
bts_assert (leg_data_2.get_hedgers().size() == 1);
SpreaderHedgerData leg_2_hedger_data = leg_data_2.get_hedgers()[0];
verify_complete_hedger_state (leg_2_hedger_data.hedger(), HedgerState::WAITING_FOR_FIRST_ACK, Price(1998), Quantity(100), Quantity(0), Price (1998), Quantity(100), Quantity (100));
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// send a fill, this should make the spreader go to end
spreader.on_child_update (leg_2_hedger_data.order_update_message().order_key, api::orderman::OrderStatus::OS_FILLED, Quantity (100), Price (1998), nullptr);
verify_complete_hedger_state (leg_2_hedger_data.hedger(), HedgerState::END, Price(1998), Quantity(100), Quantity(100), Price (0), Quantity(0), Quantity (0));
// send cancel for orders, once all quoters and hedgers
// are cancelled, spreader should come to end
spreader.on_child_update (leg_data_1.order_update_message().order_key, api::orderman::OrderStatus::OS_CANCELED, Quantity (30), Price (2000), nullptr);
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (0), Quantity(55), Price(0), Quantity(0), Quantity(15), false);
spreader.on_child_update (leg_data_2.order_update_message().order_key, api::orderman::OrderStatus::OS_CANCELED, Quantity (55), Price (2000), nullptr);
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(0), Quantity(0), Quantity(15), false);
verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity);
spreader.on_child_update (leg_data_1.get_hedger (0).order_update_message().order_key, api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr);
verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::END, Price (2002), Quantity(15), Quantity (0), Price(0), Quantity (0), Quantity (15));
spreader.on_child_update (leg_data_1.get_hedger (1).order_update_message().order_key, api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr);
verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::END, Price (2002), Quantity(30), Quantity (0), Price(0), Quantity (0), Quantity (30));
spreader.on_child_update (leg_data_1.get_hedger (2).order_update_message().order_key, api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr);
verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::END, Price (2002), Quantity(10), Quantity (0), Price(0), Quantity (0), Quantity (10));
spreader.on_child_update (leg_data_2.get_hedger (0).order_update_message().order_key, api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr);
verify_complete_hedger_state (leg_data_2.get_hedger (0).hedger(), HedgerState::END, Price (1999), Quantity(20), Quantity (0), Price(0), Quantity (0), Quantity (20));
verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity);
spreader.on_child_update (leg_data_2.get_hedger (1).order_update_message().order_key, api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr);
verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), HedgerState::END, Price (1999), Quantity(10), Quantity (0), Price(0), Quantity (0), Quantity (10));
verify_basic_spreader_state (spreader, SpreaderState::END, spreader_price, spreader_quantity);
LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_error");
LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_check_termination");
}
}