restoring tests

This commit is contained in:
Taha Afzal committed 2018-12-17 16:17:08 -05:00
1 parent e82db39f8c
commit fb14a9c3af
3 files changed
+493 -481

No files matched your search

@@ -72,6 +72,9 @@ public:
UnhedgedDelta& unhedged_delta() {return _unhedged_delta;}
// returns the number of active hedgers
size_t n_hedgers() const { return _hedger_data_vector.size(); }
size_t n_active_hedgers() const {
return _hedger_manager.n_active_hedgers();
}
// returns the hedger at a given index
SingleFillHedger& get_hedger(size_t index) {
bts_assert(index<_hedger_data_vector.size());
@@ -44,6 +44,13 @@ public:
for (SingleFillHedger& hedger : _hedgers)
hedger.terminate();
}
size_t n_active_hedgers() {
size_t rv=0;
for (SingleFillHedger& hedger : _hedgers)
if(hedger.is_active_order())
rv++;
return rv;
}
};
}}
@@ -1759,334 +1759,336 @@ TEST_CASE ("spreader_START", "[spreader]")
LOG(OrderMan, Diag, "spreader_START.on_cancel");
}
}
// TEST_CASE ("spreader_WORKING", "[spreader]")
// {
// bts::orderman::OrderKey order_key(0);
// Price spreader_price = Price (1); Quantity spreader_quantity = Quantity (100);
// ContractLeg leg_1, leg_2;
// fill_future_contract_leg (leg_1, 2468, "ES", bts::api::Venue::VENUE_GLBX, 2017, 12, 15, 1.0, 1.0, api::Side::SIDE_BUY, 1.0, 0.25);
// fill_future_contract_leg (leg_2, 13579, "ES", bts::api::Venue::VENUE_GLBX, 2018, 3, 15, -1.0, -1.0, api::Side::SIDE_SELL, 1.0, 0.25);
// std::vector<ContractLeg> contract_legs;
// contract_legs.push_back(leg_1);contract_legs.push_back(leg_2);
// Security synthetic_security;
// fill_synthetic_security (synthetic_security, 2000, "synthetic_security", contract_legs);
// // execution params/order def
// LegSpreaderParams lsp_1, lsp_2, lsp_3;
// fill_leg_spreader_params(lsp_1, 1.0, true, 1.0);fill_leg_spreader_params(lsp_2, -1.0, true, 1.0);
// std::vector<LegSpreaderParams> spreader_params;
// spreader_params.push_back(lsp_1);spreader_params.push_back(lsp_2);
// bts::api::orderman::OrderDefinition order_def;
// fill_spreader_order_definition(order_def, Side::SIDE_BUY, synthetic_security, spreader_params);
// // putting it together in SpreaderBookkeepingData
// SpreaderPreActivationOrderServices::TestOnlySpreaderPreActivationOrderServices testonly_spreader_pao_services = _create_spreader_pao_services(synthetic_security);
// SpreaderPreActivationOrderServices pao_services (&testonly_spreader_pao_services);
// std::vector<LegPropertyData> leg_props;
// SpreaderUtils::resolve_synthetic_spread(pao_services, order_def, leg_props);
// SpreaderManagerForTest spreader_manager (order_key, order_def, pao_services, leg_props);
// SpreaderOrder spreader;
// REQUIRE(spreader.test_only_func_spreader_state() == SpreaderState::START);
// // on_init_new and activate
// spreader.test_only_on_init_new (order_def, pao_services);
// SpreaderOrderServices order_services (nullptr);
// spreader.test_only_on_activate(spreader_price, spreader_quantity, order_services);
// SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data();
// verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// 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::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_SIZE, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(0), Quantity(0), Quantity(100), false);
TEST_CASE ("spreader_WORKING", "[spreader]")
{
bts::orderman::OrderKey order_key(0);
Price spreader_price = Price (1); Quantity spreader_quantity = Quantity (100);
ContractLeg leg_1, leg_2;
fill_future_contract_leg (leg_1, 2468, "ES", bts::api::Venue::VENUE_GLBX, 2017, 12, 15, 1.0, 1.0, api::Side::SIDE_BUY, 1.0, 0.25);
fill_future_contract_leg (leg_2, 13579, "ES", bts::api::Venue::VENUE_GLBX, 2018, 3, 15, -1.0, -1.0, api::Side::SIDE_SELL, 1.0, 0.25);
std::vector<ContractLeg> contract_legs;
contract_legs.push_back(leg_1);contract_legs.push_back(leg_2);
Security synthetic_security;
fill_synthetic_security (synthetic_security, 2000, "synthetic_security", contract_legs);
// execution params/order def
LegSpreaderParams lsp_1, lsp_2, lsp_3;
fill_leg_spreader_params(lsp_1, 1.0, true, 1.0);fill_leg_spreader_params(lsp_2, -1.0, true, 1.0);
std::vector<LegSpreaderParams> spreader_params;
spreader_params.push_back(lsp_1);spreader_params.push_back(lsp_2);
bts::api::orderman::OrderDefinition order_def;
fill_spreader_order_definition(order_def, Side::SIDE_BUY, synthetic_security, spreader_params);
// putting it together in SpreaderBookkeepingData
SpreaderPreActivationOrderServices::TestOnlySpreaderPreActivationOrderServices testonly_spreader_pao_services = _create_spreader_pao_services(synthetic_security);
SpreaderPreActivationOrderServices pao_services (&testonly_spreader_pao_services);
std::vector<LegPropertyData> leg_props;
SpreaderUtils::resolve_synthetic_spread(pao_services, order_def, leg_props);
SpreaderManagerForTest spreader_manager (order_key, order_def, pao_services, leg_props);
SpreaderOrder spreader;
REQUIRE(spreader.test_only_func_spreader_state() == SpreaderState::START);
// on_init_new and activate
spreader.test_only_on_init_new (order_def, pao_services);
SpreaderOrderServices order_services (nullptr);
spreader.test_only_on_activate(spreader_price, spreader_quantity, order_services);
SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data();
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
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::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_SIZE, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(0), Quantity(0), Quantity(100), false);
// set_spreader_orders (spreader, new double[5] {1999, 1998, 1997, 1996, 1995}, new uint16_t[5] {50, 50, 10, 10, 30},
// 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] {25, 25, 20, 20, 10}, 0, 0, 0, 0);
// // verify working orders
// 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 fill on leg 1 (20)
// spreader.test_only_on_child_order_update (leg_data_1.order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (20), Price (2000));
// 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);
// // send another fill on leg 1 (10)
// spreader.test_only_on_child_order_update (leg_data_1.order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (30), Price (2000));
// verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(0), Price(2000), Quantity(100), Quantity(70), false);
// verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(2002), Quantity(70), Quantity(70), false);
// // send fill on leg 2 (15)
// spreader.test_only_on_child_order_update (leg_data_2.order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (15), Price (2001));
// verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(15), Price(2001), Quantity(85), Quantity(55), false);
// verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (15), Quantity(30), Price(2002), Quantity(70), Quantity(55), false);
// // send another fill on leg 2 (30)
// spreader.test_only_on_child_order_update (leg_data_2.order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (45), Price (2001));
// 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);
// // send another fill on leg 2 (10)
// spreader.test_only_on_child_order_update (leg_data_2.order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (55), Price (2001));
// 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
// for (size_t i = 0; i < leg_data_1.n_hedgers(); i++)
// spreader.test_only_on_child_order_update (leg_data_1.get_hedger(i).order_state().order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0));
// for (size_t i = 0; i < leg_data_2.n_hedgers(); i++)
// spreader.test_only_on_child_order_update (leg_data_2.get_hedger(i).order_state().order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0));
// REQUIRE (leg_data_1.n_hedgers () == 3);
// REQUIRE (leg_data_2.n_hedgers () == 2);
// 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_complete_hedger_state (leg_data_1.get_hedger(0), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
// verify_complete_hedger_state (leg_data_1.get_hedger(1), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
// verify_complete_hedger_state (leg_data_1.get_hedger(2), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
// verify_complete_hedger_state (leg_data_2.get_hedger(0), HedgerState::WORKING, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20));
// verify_complete_hedger_state (leg_data_2.get_hedger(1), HedgerState::WORKING, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10));
set_spreader_orders (spreader, new double[5] {1999, 1998, 1997, 1996, 1995}, new uint16_t[5] {50, 50, 10, 10, 30},
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] {25, 25, 20, 20, 10}, 0, 0, 0, 0);
// verify working orders
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 fill on leg 1 (20)
spreader.test_only_on_child_order_update (leg_data_1.order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (20), Price (2000));
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);
// send another fill on leg 1 (10)
spreader.test_only_on_child_order_update (leg_data_1.order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (30), Price (2000));
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(0), Price(2000), Quantity(100), Quantity(70), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(2002), Quantity(70), Quantity(70), false);
// send fill on leg 2 (15)
spreader.test_only_on_child_order_update (leg_data_2.order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (15), Price (2001));
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(15), Price(2001), Quantity(85), Quantity(55), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (15), Quantity(30), Price(2002), Quantity(70), Quantity(55), false);
// send another fill on leg 2 (30)
spreader.test_only_on_child_order_update (leg_data_2.order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (45), Price (2001));
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);
// send another fill on leg 2 (10)
spreader.test_only_on_child_order_update (leg_data_2.order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (55), Price (2001));
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
for (size_t i = 0; i < leg_data_1.n_hedgers(); i++)
if(leg_data_1.get_hedger(i).is_active_order())
spreader.test_only_on_child_order_update (leg_data_1.get_hedger(i).order_state().order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0));
for (size_t i = 0; i < leg_data_2.n_hedgers(); i++)
if(leg_data_2.get_hedger(i).is_active_order())
spreader.test_only_on_child_order_update (leg_data_2.get_hedger(i).order_state().order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0));
REQUIRE (leg_data_1.n_active_hedgers () == 3);
REQUIRE (leg_data_2.n_active_hedgers () == 2);
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_complete_hedger_state (leg_data_1.get_hedger(0), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
verify_complete_hedger_state (leg_data_1.get_hedger(1), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger(2), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
verify_complete_hedger_state (leg_data_2.get_hedger(0), HedgerState::WORKING, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20));
verify_complete_hedger_state (leg_data_2.get_hedger(1), HedgerState::WORKING, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10));
// auto generic_validate_quoters = [&](QuoterState quoter_state, bool quoter_cancelled_by_spreader) -> void
// {
// verify_complete_quoter_state (leg_data_1.quoter(), quoter_state, quoter_cancelled_by_spreader, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false);
// verify_complete_quoter_state (leg_data_2.quoter(), quoter_state, quoter_cancelled_by_spreader, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
// };
// auto generic_validate_hedgers = [&](HedgerState hedger_state) -> void
// {
// REQUIRE (leg_data_1.n_hedgers () == 3);
// REQUIRE (leg_data_2.n_hedgers () == 2);
// verify_complete_hedger_state (leg_data_1.get_hedger(0), hedger_state, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
// verify_complete_hedger_state (leg_data_1.get_hedger(1), hedger_state, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
// verify_complete_hedger_state (leg_data_1.get_hedger(2), hedger_state, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
// verify_complete_hedger_state (leg_data_2.get_hedger(0), hedger_state, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20));
// verify_complete_hedger_state (leg_data_2.get_hedger(1), hedger_state, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10));
// };
// SECTION("1. init")
// {
// }
// SECTION("2. on_connect")
// {
// }
// SECTION("4. on_update")
// {
// // updating the spreader order should cause
// // the quoters to requote. hedgers should
// // be as is
// spreader_price = Price (0);
// spreader_quantity = Quantity (200);
// spreader.on_update (spreader_price, spreader_quantity,trace::CorID());
// verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity (30), Quantity(55), Price(1998), Quantity(130), Quantity(115), false);
// verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity (55), Quantity(30), Price(2004), Quantity(165), Quantity(115), false);
// // nothing changes with the hedgers
// generic_validate_hedgers (HedgerState::WORKING);
// LOG(OrderMan, Diag, "spreader_WORKING.on_update");
// }
// SECTION("5. on_cancel")
// {
// spreader.on_cancel(trace::CorID());
// verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity);
// generic_validate_quoters (QuoterState::WAITING_FOR_CANCEL_ACK, true);
// generic_validate_hedgers (HedgerState::WAITING_FOR_CANCEL_ACK);
// LOG(OrderMan, Diag, "spreader_WORKING.on_cancel");
// }
// SECTION("6. on_book")
// {
// // 1. change the market such that it translates to no changes in order
// // leg 1 needs 15 more to get filled. the 15 cumulative size level in leg2
// // comes out to be at 2002, which gives leg1 = spreader_price + leg2 = 1 + 2002 = 2003.
// // changing leg 2's books such that 15 still comes at 2002
auto generic_validate_quoters = [&](QuoterState quoter_state, bool quoter_cancelled_by_spreader) -> void
{
verify_complete_quoter_state (leg_data_1.quoter(), quoter_state, quoter_cancelled_by_spreader, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false);
verify_complete_quoter_state (leg_data_2.quoter(), quoter_state, quoter_cancelled_by_spreader, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false);
};
auto generic_validate_hedgers = [&](HedgerState hedger_state) -> void
{
REQUIRE (leg_data_1.n_active_hedgers () == 3);
REQUIRE (leg_data_2.n_active_hedgers () == 2);
verify_complete_hedger_state (leg_data_1.get_hedger(0), hedger_state, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
verify_complete_hedger_state (leg_data_1.get_hedger(1), hedger_state, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger(2), hedger_state, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
verify_complete_hedger_state (leg_data_2.get_hedger(0), hedger_state, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20));
verify_complete_hedger_state (leg_data_2.get_hedger(1), hedger_state, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10));
};
SECTION("1. init")
{
}
SECTION("2. on_connect")
{
}
SECTION("4. on_update")
{
// updating the spreader order should cause
// the quoters to requote. hedgers should
// be as is
spreader_price = Price (0);
spreader_quantity = Quantity (200);
spreader.on_update (spreader_price, spreader_quantity,trace::CorID());
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity (30), Quantity(55), Price(1998), Quantity(130), Quantity(115), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity (55), Quantity(30), Price(2004), Quantity(165), Quantity(115), false);
// nothing changes with the hedgers
generic_validate_hedgers (HedgerState::WORKING);
LOG(OrderMan, Diag, "spreader_WORKING.on_update");
}
SECTION("5. on_cancel")
{
spreader.on_cancel(trace::CorID());
verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity);
generic_validate_quoters (QuoterState::WAITING_FOR_CANCEL_ACK, true);
generic_validate_hedgers (HedgerState::WAITING_FOR_CANCEL_ACK);
LOG(OrderMan, Diag, "spreader_WORKING.on_cancel");
}
SECTION("6. on_book")
{
// 1. change the market such that it translates to no changes in order
// leg 1 needs 15 more to get filled. the 15 cumulative size level in leg2
// comes out to be at 2002, which gives leg1 = spreader_price + leg2 = 1 + 2002 = 2003.
// changing leg 2's books such that 15 still comes at 2002
// uint32_t leg_1_id = leg_data_1.leg_property_data().security_key(),
// leg_2_id = leg_data_2.leg_property_data().security_key();
// bts::orderman::Book modified_book = get_book (SecurityKey (leg_2_id), 5,
// new double[5] {2004, 2003, 2002, 2001, 2000},
// new uint16_t[5] {5, 5, 5, 0, 0},
// new double[5] {2005, 2006, 2007, 2008, 2009},
// new uint16_t[5] {0, 0, 0, 0, 0},
// true);
// spreader.test_only_on_book_update (modified_book, trace::CorID());
// verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// generic_validate_quoters (QuoterState::WORKING, false);
// generic_validate_hedgers (HedgerState::WORKING);
// LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// // 2. change the market to induce a price change
// // we will go back to the prevoius market but make it thinner
// // to force leg 1's quoter to go deeper into leg 2's book
// modified_book = get_book (SecurityKey (leg_2_id), 5,
// new double[5] {2002, 2001, 2000, 1999, 1998},
// new uint16_t[5] {1, 1, 1, 1, 11},
// new double[5] {2003, 2004, 2005, 2006, 2007},
// new uint16_t[5] {25, 25, 20, 20, 10},
// true);
// //spreader.on_book (bts::orderman::trace::CorID(), modified_book);
// spreader.test_only_on_book_update (modified_book,trace::CorID());
// verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(1999), 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);
// generic_validate_hedgers (HedgerState::WORKING);
// LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// // 3. shrink to market to force a size change
// // the remaining target is 15, so we'll make the total
// // less than 15
// modified_book = get_book (SecurityKey (leg_2_id), 5,
// new double[5] {2002, 2001, 2000, 1999, 1998},
// new uint16_t[5] {1, 1, 1, 1, 0},
// new double[5] {2003, 2004, 2005, 2006, 2007},
// new uint16_t[5] {25, 25, 20, 20, 10},
// true);
// //spreader.on_book (bts::orderman::trace::CorID(), modified_book);
// spreader.test_only_on_book_update (modified_book,trace::CorID());
// verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2000), Quantity(34), 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);
// generic_validate_hedgers (HedgerState::WORKING);
// LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// // 4. change the market to force both a price and size change
// modified_book = get_book (SecurityKey (leg_2_id), 5,
// new double[5] {2002, 2001, 2000, 1999, 1998},
// new uint16_t[5] {1, 1, 13, 1, 1},
// new double[5] {2003, 2004, 2005, 2006, 2007},
// new uint16_t[5] {25, 25, 20, 20, 10},
// true);
// //spreader.on_book (bts::orderman::trace::CorID(), modified_book);
// spreader.test_only_on_book_update (modified_book, trace::CorID());
// verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2001), 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);
// generic_validate_hedgers (HedgerState::WORKING);
// LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// // 5. remove the market
// // this should pull the order
// modified_book = get_book (SecurityKey (leg_2_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] {25, 25, 20, 20, 10},
// true);
// //spreader.on_book (bts::orderman::trace::CorID(), modified_book);
// spreader.test_only_on_book_update (modified_book, trace::CorID());
// verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2001), 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);
// generic_validate_hedgers (HedgerState::WORKING);
// LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// }
// SECTION("7. on_time")
// {
// }
// SECTION("8. on_quoter_order_error")
// {
// spreader.test_only_on_child_order_update (leg_data_1.order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_ERROR, Quantity (30), Price (2000));
// verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity);
// // the one that has an error goes to the end, the others are waiting on cancel ack's
// REQUIRE(spreader.test_only_func_spreader_full_data().get_leg_data(0).quoter().test_only_func_quoter_state() == QuoterState::END);
// REQUIRE(spreader.test_only_func_spreader_full_data().get_leg_data(1).quoter().test_only_func_quoter_state() == QuoterState::WAITING_FOR_CANCEL_ACK);
// generic_validate_hedgers (HedgerState::WAITING_FOR_CANCEL_ACK);
// LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_error");
// }
// SECTION("9. on_quoter_order_fill")
// {
// // add one more hedge
// spreader.test_only_on_child_order_update (leg_data_2.order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (65), Price (2001));
// for (size_t i = 0; i < leg_data_1.n_hedgers(); i++)
// spreader.test_only_on_child_order_update (leg_data_1.get_hedger(i).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0));
// for (size_t i = 0; i < leg_data_2.n_hedgers(); i++)
// spreader.test_only_on_child_order_update (leg_data_2.get_hedger(i).order_state().order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0));
// REQUIRE (leg_data_1.n_hedgers () == 4);
// REQUIRE (leg_data_2.n_hedgers () == 2);
// verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(65), Price(2003), Quantity(35), Quantity(5), false);
// verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (65), Quantity(30), Price(1999), Quantity(70), Quantity(5), false);
// verify_complete_hedger_state (leg_data_1.get_hedger (0), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
// verify_complete_hedger_state (leg_data_1.get_hedger (1), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
// verify_complete_hedger_state (leg_data_1.get_hedger (2), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
// verify_complete_hedger_state (leg_data_1.get_hedger (3), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
// verify_complete_hedger_state (leg_data_2.get_hedger (0), HedgerState::WORKING, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20));
// verify_complete_hedger_state (leg_data_2.get_hedger (1), HedgerState::WORKING, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10));
// LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_fill");
// }
// SECTION("10. on_quoter_order_status_update")
// {
// // since order update has already been done in 9, lets fill
// // it completely
// spreader.test_only_on_child_order_update (leg_data_2.order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (70), Price (2001));
// for (size_t i = 0; i < leg_data_1.n_hedgers(); i++)
// spreader.test_only_on_child_order_update (leg_data_1.get_hedger(i).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0));
// for (size_t i = 0; i < leg_data_2.n_hedgers(); i++)
// spreader.test_only_on_child_order_update (leg_data_2.get_hedger(i).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0));
// REQUIRE (leg_data_1.n_hedgers () == 4);
// REQUIRE (leg_data_2.n_hedgers () == 2);
// verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (30), Quantity(70), Price(2003), Quantity(45), Quantity(0), true);
// verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(0), Quantity(0), Quantity(0), true);
// verify_complete_hedger_state (leg_data_1.get_hedger(0), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
// verify_complete_hedger_state (leg_data_1.get_hedger(1), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
// verify_complete_hedger_state (leg_data_1.get_hedger(2), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
// verify_complete_hedger_state (leg_data_1.get_hedger(3), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
// verify_complete_hedger_state (leg_data_2.get_hedger(0), HedgerState::WORKING, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20));
// verify_complete_hedger_state (leg_data_2.get_hedger(1), HedgerState::WORKING, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10));
// LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_fill");
// }
// SECTION("11. on_hedger_order_error")
// {
// spreader.test_only_on_child_order_update (leg_data_1.get_hedger(0).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_ERROR, Quantity (0), Price (0));
// verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity);
// generic_validate_quoters (QuoterState::WAITING_FOR_CANCEL_ACK, true);
// REQUIRE(leg_data_1.get_hedger(0).test_only_func_hedger_state() == HedgerState::END);
// REQUIRE(leg_data_1.get_hedger(1).test_only_func_hedger_state() == HedgerState::WAITING_FOR_CANCEL_ACK);
// REQUIRE(leg_data_1.get_hedger(2).test_only_func_hedger_state() == HedgerState::WAITING_FOR_CANCEL_ACK);
// REQUIRE(leg_data_2.get_hedger(0).test_only_func_hedger_state() == HedgerState::WAITING_FOR_CANCEL_ACK);
// REQUIRE(leg_data_2.get_hedger(1).test_only_func_hedger_state() == HedgerState::WAITING_FOR_CANCEL_ACK);
// LOG(OrderMan, Diag, "spreader_WORKING.on_hedger_order_error");
// }
// SECTION("12. on_hedger_order_update")
// {
// // send as fill for the hedger
// spreader.test_only_on_child_order_update (leg_data_1.get_hedger(0).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (10), Price (2002));
// verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// generic_validate_quoters (QuoterState::WORKING, false);
// REQUIRE (leg_data_1.n_hedgers () == 3);
// REQUIRE (leg_data_2.n_hedgers () == 2);
// verify_complete_hedger_state (leg_data_1.get_hedger (0), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (10), Price(2002), Quantity (15), Quantity (5));
// verify_complete_hedger_state (leg_data_1.get_hedger (1), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
// verify_complete_hedger_state (leg_data_1.get_hedger (2), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
// verify_complete_hedger_state (leg_data_2.get_hedger (0), HedgerState::WORKING, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20));
// verify_complete_hedger_state (leg_data_2.get_hedger (1), HedgerState::WORKING, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10));
// LOG(OrderMan, Diag, "spreader_WORKING.on_hedger_order_update");
// }
// SECTION("14. on_check_termination")
// {
// // the only way to do a termination and transit
// // to END is if the orders get filled. If we cancel
// // it leaves this state; if we send terminal status
// // on the quoters, and its not fully filled, the quoters
// // resubmit and continue
// // leg has 30 hedge deduction, and 55 filled, another 15 will fill it completely
// spreader.test_only_on_child_order_update (leg_data_2.order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (70), Price (2001));
// REQUIRE (leg_data_1.n_hedgers () == 4);
// REQUIRE (leg_data_2.n_hedgers () == 2);
// verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (30), Quantity(70), Price(2003), Quantity(45), Quantity(0), true);
// verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(0), Quantity(0), Quantity(0), true);
// verify_complete_hedger_state (leg_data_1.get_hedger (0), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
// verify_complete_hedger_state (leg_data_1.get_hedger (1), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
// verify_complete_hedger_state (leg_data_1.get_hedger (2), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
// verify_complete_hedger_state (leg_data_1.get_hedger (3), HedgerState::WAITING_FOR_FIRST_ACK, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));//new hedger
// verify_complete_hedger_state (leg_data_2.get_hedger (0), HedgerState::WORKING, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20));
// verify_complete_hedger_state (leg_data_2.get_hedger (1), HedgerState::WORKING, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10));
// verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// // now bring the quoter and hedgers to their end states
// // when all of them are at the end state, the spreader
// // should also go to end
// spreader.test_only_on_child_order_update (leg_data_1.order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED, Quantity (30), Price (2001));
// verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(70), Price(0), Quantity(0), Quantity(0), true);
// verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// // // all the quoters are done now
// spreader.test_only_on_child_order_update (leg_data_1.get_hedger (0).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (15), Price (2002));
// verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// spreader.test_only_on_child_order_update (leg_data_1.get_hedger (1).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (30), Price (2002));
// verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// spreader.test_only_on_child_order_update (leg_data_1.get_hedger (2).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (10), Price (2002));
// verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// spreader.test_only_on_child_order_update (leg_data_1.get_hedger (3).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (15), Price (2002));
// verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// spreader.test_only_on_child_order_update (leg_data_2.get_hedger (0).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (20), Price (1999));
// verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// spreader.test_only_on_child_order_update (leg_data_2.get_hedger (1).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (10), Price (1999));
// verify_basic_spreader_state (spreader, SpreaderState::END, spreader_price, spreader_quantity);
// LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_fill");
// }
// }
uint32_t leg_1_id = leg_data_1.leg_property_data().security_key(),
leg_2_id = leg_data_2.leg_property_data().security_key();
bts::orderman::Book modified_book = get_book (SecurityKey (leg_2_id), 5,
new double[5] {2004, 2003, 2002, 2001, 2000},
new uint16_t[5] {5, 5, 5, 0, 0},
new double[5] {2005, 2006, 2007, 2008, 2009},
new uint16_t[5] {0, 0, 0, 0, 0},
true);
spreader.test_only_on_book_update (modified_book, trace::CorID());
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
generic_validate_quoters (QuoterState::WORKING, false);
generic_validate_hedgers (HedgerState::WORKING);
LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// 2. change the market to induce a price change
// we will go back to the prevoius market but make it thinner
// to force leg 1's quoter to go deeper into leg 2's book
modified_book = get_book (SecurityKey (leg_2_id), 5,
new double[5] {2002, 2001, 2000, 1999, 1998},
new uint16_t[5] {1, 1, 1, 1, 11},
new double[5] {2003, 2004, 2005, 2006, 2007},
new uint16_t[5] {25, 25, 20, 20, 10},
true);
//spreader.on_book (bts::orderman::trace::CorID(), modified_book);
spreader.test_only_on_book_update (modified_book,trace::CorID());
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(1999), 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);
generic_validate_hedgers (HedgerState::WORKING);
LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// 3. shrink to market to force a size change
// the remaining target is 15, so we'll make the total
// less than 15
modified_book = get_book (SecurityKey (leg_2_id), 5,
new double[5] {2002, 2001, 2000, 1999, 1998},
new uint16_t[5] {1, 1, 1, 1, 0},
new double[5] {2003, 2004, 2005, 2006, 2007},
new uint16_t[5] {25, 25, 20, 20, 10},
true);
//spreader.on_book (bts::orderman::trace::CorID(), modified_book);
spreader.test_only_on_book_update (modified_book,trace::CorID());
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2000), Quantity(34), 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);
generic_validate_hedgers (HedgerState::WORKING);
LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// 4. change the market to force both a price and size change
modified_book = get_book (SecurityKey (leg_2_id), 5,
new double[5] {2002, 2001, 2000, 1999, 1998},
new uint16_t[5] {1, 1, 13, 1, 1},
new double[5] {2003, 2004, 2005, 2006, 2007},
new uint16_t[5] {25, 25, 20, 20, 10},
true);
//spreader.on_book (bts::orderman::trace::CorID(), modified_book);
spreader.test_only_on_book_update (modified_book, trace::CorID());
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2001), 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);
generic_validate_hedgers (HedgerState::WORKING);
LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// 5. remove the market
// this should pull the order
modified_book = get_book (SecurityKey (leg_2_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] {25, 25, 20, 20, 10},
true);
//spreader.on_book (bts::orderman::trace::CorID(), modified_book);
spreader.test_only_on_book_update (modified_book, trace::CorID());
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2001), 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);
generic_validate_hedgers (HedgerState::WORKING);
LOG(OrderMan, Diag, "spreader_WORKING.on_book");
}
SECTION("7. on_time")
{
}
SECTION("8. on_quoter_order_error")
{
spreader.test_only_on_child_order_update (leg_data_1.order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_ERROR, Quantity (30), Price (2000));
verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity);
// the one that has an error goes to the end, the others are waiting on cancel ack's
REQUIRE(spreader.test_only_func_spreader_full_data().get_leg_data(0).quoter().test_only_func_quoter_state() == QuoterState::END);
REQUIRE(spreader.test_only_func_spreader_full_data().get_leg_data(1).quoter().test_only_func_quoter_state() == QuoterState::WAITING_FOR_CANCEL_ACK);
generic_validate_hedgers (HedgerState::WAITING_FOR_CANCEL_ACK);
LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_error");
}
SECTION("9. on_quoter_order_fill")
{
// add one more hedge
spreader.test_only_on_child_order_update (leg_data_2.order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (65), Price (2001));
for (size_t i = 0; i < leg_data_1.n_active_hedgers(); i++)
spreader.test_only_on_child_order_update (leg_data_1.get_hedger(i).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0));
for (size_t i = 0; i < leg_data_2.n_active_hedgers(); i++)
spreader.test_only_on_child_order_update (leg_data_2.get_hedger(i).order_state().order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0));
REQUIRE (leg_data_1.n_active_hedgers () == 4);
REQUIRE (leg_data_2.n_active_hedgers () == 2);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(65), Price(2003), Quantity(35), Quantity(5), false);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (65), Quantity(30), Price(1999), Quantity(70), Quantity(5), false);
verify_complete_hedger_state (leg_data_1.get_hedger (0), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
verify_complete_hedger_state (leg_data_1.get_hedger (1), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger (2), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
verify_complete_hedger_state (leg_data_1.get_hedger (3), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
verify_complete_hedger_state (leg_data_2.get_hedger (0), HedgerState::WORKING, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20));
verify_complete_hedger_state (leg_data_2.get_hedger (1), HedgerState::WORKING, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10));
LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_fill");
}
SECTION("10. on_quoter_order_status_update")
{
// since order update has already been done in 9, lets fill
// it completely
spreader.test_only_on_child_order_update (leg_data_2.order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (70), Price (2001));
for (size_t i = 0; i < leg_data_1.n_active_hedgers(); i++)
spreader.test_only_on_child_order_update (leg_data_1.get_hedger(i).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0));
for (size_t i = 0; i < leg_data_2.n_active_hedgers(); i++)
spreader.test_only_on_child_order_update (leg_data_2.get_hedger(i).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0));
REQUIRE (leg_data_1.n_active_hedgers () == 4);
REQUIRE (leg_data_2.n_active_hedgers () == 2);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (30), Quantity(70), Price(2003), Quantity(45), Quantity(0), true);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(0), Quantity(0), Quantity(0), true);
verify_complete_hedger_state (leg_data_1.get_hedger(0), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
verify_complete_hedger_state (leg_data_1.get_hedger(1), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger(2), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
verify_complete_hedger_state (leg_data_1.get_hedger(3), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
verify_complete_hedger_state (leg_data_2.get_hedger(0), HedgerState::WORKING, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20));
verify_complete_hedger_state (leg_data_2.get_hedger(1), HedgerState::WORKING, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10));
LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_fill");
}
SECTION("11. on_hedger_order_error")
{
spreader.test_only_on_child_order_update (leg_data_1.get_hedger(0).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_ERROR, Quantity (0), Price (0));
verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity);
generic_validate_quoters (QuoterState::WAITING_FOR_CANCEL_ACK, true);
REQUIRE(leg_data_1.get_hedger(0).test_only_func_hedger_state() == HedgerState::END);
REQUIRE(leg_data_1.get_hedger(1).test_only_func_hedger_state() == HedgerState::WAITING_FOR_CANCEL_ACK);
REQUIRE(leg_data_1.get_hedger(2).test_only_func_hedger_state() == HedgerState::WAITING_FOR_CANCEL_ACK);
REQUIRE(leg_data_2.get_hedger(0).test_only_func_hedger_state() == HedgerState::WAITING_FOR_CANCEL_ACK);
REQUIRE(leg_data_2.get_hedger(1).test_only_func_hedger_state() == HedgerState::WAITING_FOR_CANCEL_ACK);
LOG(OrderMan, Diag, "spreader_WORKING.on_hedger_order_error");
}
SECTION("12. on_hedger_order_update")
{
// send as fill for the hedger
spreader.test_only_on_child_order_update (leg_data_1.get_hedger(0).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (10), Price (2002));
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
generic_validate_quoters (QuoterState::WORKING, false);
REQUIRE (leg_data_1.n_active_hedgers () == 3);
REQUIRE (leg_data_2.n_active_hedgers () == 2);
verify_complete_hedger_state (leg_data_1.get_hedger (0), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (10), Price(2002), Quantity (15), Quantity (5));
verify_complete_hedger_state (leg_data_1.get_hedger (1), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger (2), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
verify_complete_hedger_state (leg_data_2.get_hedger (0), HedgerState::WORKING, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20));
verify_complete_hedger_state (leg_data_2.get_hedger (1), HedgerState::WORKING, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10));
LOG(OrderMan, Diag, "spreader_WORKING.on_hedger_order_update");
}
SECTION("14. on_check_termination")
{
// the only way to do a termination and transit
// to END is if the orders get filled. If we cancel
// it leaves this state; if we send terminal status
// on the quoters, and its not fully filled, the quoters
// resubmit and continue
// leg has 30 hedge deduction, and 55 filled, another 15 will fill it completely
spreader.test_only_on_child_order_update (leg_data_2.order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (70), Price (2001));
REQUIRE (leg_data_1.n_active_hedgers () == 4);
REQUIRE (leg_data_2.n_active_hedgers () == 2);
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (30), Quantity(70), Price(2003), Quantity(45), Quantity(0), true);
verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(0), Quantity(0), Quantity(0), true);
verify_complete_hedger_state (leg_data_1.get_hedger (0), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));
verify_complete_hedger_state (leg_data_1.get_hedger (1), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30));
verify_complete_hedger_state (leg_data_1.get_hedger (2), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10));
verify_complete_hedger_state (leg_data_1.get_hedger (3), HedgerState::WAITING_FOR_FIRST_ACK, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15));//new hedger
verify_complete_hedger_state (leg_data_2.get_hedger (0), HedgerState::WORKING, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20));
verify_complete_hedger_state (leg_data_2.get_hedger (1), HedgerState::WORKING, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10));
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// now bring the quoter and hedgers to their end states
// when all of them are at the end state, the spreader
// should also go to end
spreader.test_only_on_child_order_update (leg_data_1.order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED, Quantity (30), Price (2001));
verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(70), Price(0), Quantity(0), Quantity(0), true);
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// // all the quoters are done now
spreader.test_only_on_child_order_update (leg_data_1.get_hedger (0).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (15), Price (2002));
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
spreader.test_only_on_child_order_update (leg_data_1.get_hedger (1).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (30), Price (2002));
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
spreader.test_only_on_child_order_update (leg_data_1.get_hedger (2).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (10), Price (2002));
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
spreader.test_only_on_child_order_update (leg_data_1.get_hedger (3).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (15), Price (2002));
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
spreader.test_only_on_child_order_update (leg_data_2.get_hedger (0).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (20), Price (1999));
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
spreader.test_only_on_child_order_update (leg_data_2.get_hedger (1).order_state().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (10), Price (1999));
verify_basic_spreader_state (spreader, SpreaderState::END, spreader_price, spreader_quantity);
LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_fill");
}
}
// TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]")
// {
// bts::orderman::OrderKey order_key(0);
@@ -2318,162 +2320,162 @@ TEST_CASE ("spreader_START", "[spreader]")
// LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_check_termination");
// }
// }
// TEST_CASE ("find_target_price_in_book", "[spreader]"){
// SECTION("0.05"){
// Quantity out_level_qty, out_cum_qty;
// bts::orderman::Book book;
// uint16_t sizes[] = { 11, 13, 17, 19, 23 };
// double prices[] = { 22, 21.15, 20.10, 20.05, 20.00 };
// fill_book (book, prices, sizes, bts::api::Side::SIDE_BUY);
// // middle
// bool res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_BUY, Price(20.10), 0.05, out_level_qty, out_cum_qty);
// REQUIRE(res);
// REQUIRE(out_level_qty.value()==17);
// REQUIRE(out_cum_qty.value()==41);
// // first
// res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_BUY, Price(22.00), 0.05, out_level_qty, out_cum_qty);
// REQUIRE(res);
// REQUIRE(out_level_qty.value()==11);
// REQUIRE(out_cum_qty.value()==11);
// // last
// res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_BUY, Price(20.00), 0.05, out_level_qty, out_cum_qty);
// REQUIRE(res);
// REQUIRE(out_level_qty.value()==23);
// REQUIRE(out_cum_qty.value()==83);
// // not found
// res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_BUY, Price(21.00), 0.05, out_level_qty, out_cum_qty);
// REQUIRE(!res);
// // rounding error
// res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_BUY, Price(20.04999999), 0.05, out_level_qty, out_cum_qty);
// REQUIRE(res);
// REQUIRE(out_level_qty.value()==19);
// REQUIRE(out_cum_qty.value()==60);
// }
// SECTION("1/32"){
// Quantity out_level_qty, out_cum_qty;
// bts::orderman::Book book;
// uint16_t sizes[] = { 12, 91, 5, 24, 33 };
// double prices[] = { 100.21875, 100.28125, 101, 101.53125, 101.71875 };
// fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL);
// // first
// bool res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_SELL, Price(100.21875), 0.03125, out_level_qty, out_cum_qty);
// REQUIRE(res);
// REQUIRE(out_level_qty.value()==12);
// REQUIRE(out_cum_qty.value()==12);
// // middle
// res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_SELL, Price(101.53125), 0.03125, out_level_qty, out_cum_qty);
// REQUIRE(res);
// REQUIRE(out_level_qty.value()==24);
// REQUIRE(out_cum_qty.value()==132);
// // end
// res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_SELL, Price(101.71875), 0.03125, out_level_qty, out_cum_qty);
// REQUIRE(res);
// REQUIRE(out_level_qty.value()==33);
// REQUIRE(out_cum_qty.value()==165);
// // absent
// res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_SELL, Price(101.5625), 0.03125, out_level_qty, out_cum_qty);
// REQUIRE(!res);
// REQUIRE(out_level_qty.value()==0);
// REQUIRE(out_cum_qty.value()==0);
// res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_BUY, Price(101.71875), 0.03125, out_level_qty, out_cum_qty);
// REQUIRE(!res);
// REQUIRE(out_level_qty.value()==0);
// REQUIRE(out_cum_qty.value()==0);
// // rounding
// res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_SELL, Price(101.531249999999), 0.03125, out_level_qty, out_cum_qty);
// REQUIRE(res);
// REQUIRE(out_level_qty.value()==24);
// REQUIRE(out_cum_qty.value()==132);
// }
// }
// TEST_CASE ("prehedge_payless", "[spreader]"){
// SECTION("payup_true_abs_threshold"){
// bts::orderman::Book book;
// Price out_price;
// uint16_t sizes[] = { 12, 14, 17, 19, 23 };
// double prices[] = { 21.00, 21.05, 21.10, 22, 23 };
// fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL);
// spark::PreHedgeQuantityBasedPayLessTicks payless_params;
// payless_params.set_payless_ticks(1);
// payless_params.mutable_quantity_threshold()->set_absolute(25);
// auto res = SpreaderUtils::prehedge_quantity_base_payless_ticks_reprice(payless_params, book, api::Side::SIDE_BUY,
// 0.05, Price(21.05), Quantity(5), out_price);
// REQUIRE(res);
// REQUIRE(out_price.value()==21.00);
// }
// SECTION("payup_false_abs_threshold"){
// bts::orderman::Book book;
// Price out_price;
// uint16_t sizes[] = { 10, 14, 17, 19, 23 };
// double prices[] = { 21.00, 21.05, 21.10, 22, 23 };
// fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL);
// spark::PreHedgeQuantityBasedPayLessTicks payless_params;
// payless_params.set_payless_ticks(1);
// payless_params.mutable_quantity_threshold()->set_absolute(25);
// auto res = SpreaderUtils::prehedge_quantity_base_payless_ticks_reprice(payless_params, book, api::Side::SIDE_BUY,
// 0.05, Price(21.05), Quantity(5), out_price);
// REQUIRE(!res);
// REQUIRE(out_price.value()==21.05);
// }
// SECTION("payup_true_ratio_threshold"){
// bts::orderman::Book book;
// Price out_price;
// uint16_t sizes[] = { 11, 14, 26, 19, 23 };
// double prices[] = { 21.00, 21.05, 21.10, 22, 23 };
// fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL);
// spark::PreHedgeQuantityBasedPayLessTicks payless_params;
// payless_params.set_payless_ticks(2);
// payless_params.mutable_quantity_threshold()->set_ratio(5);
// auto res = SpreaderUtils::prehedge_quantity_base_payless_ticks_reprice(payless_params, book, api::Side::SIDE_BUY,
// 0.05, Price(21.10), Quantity(10), out_price);
// REQUIRE(res);
// REQUIRE(out_price.value()==21.00);
// }
// SECTION("payup_true_ratio_threshold"){
// bts::orderman::Book book;
// Price out_price;
// uint16_t sizes[] = { 11, 14, 26, 19, 23 };
// double prices[] = { 21.00, 21.05, 21.10, 22, 23 };
// fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL);
// spark::PreHedgeQuantityBasedPayLessTicks payless_params;
// payless_params.set_payless_ticks(2);
// payless_params.mutable_quantity_threshold()->set_ratio(6);
// auto res = SpreaderUtils::prehedge_quantity_base_payless_ticks_reprice(payless_params, book, api::Side::SIDE_BUY,
// 0.05, Price(21.10), Quantity(10), out_price);
// REQUIRE(!res);
// REQUIRE(out_price.value()==21.10);
// }
// }
// TEST_CASE ("prehedge_payup", "[spreader]"){
// SECTION("payup_true_abs_threshold"){
// bts::orderman::Book book;
// Price out_price;
// uint16_t sizes[] = { 12, 18, 20, 19, 23 };
// double prices[] = { 21.00, 21.05, 21.10, 22, 23 };
// fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL);
// spark::PreHedgeQuantityBasedPayupTicks payup_params;
// payup_params.set_payup_ticks(1);
// payup_params.mutable_quantity_threshold()->set_absolute(55);
// auto res = SpreaderUtils::prehedge_quantity_base_payup_ticks_reprice(payup_params, book, api::Side::SIDE_BUY,
// 0.05, Price(21.10), Quantity(5), out_price);
// REQUIRE(res);
// REQUIRE(bts::securities::test_price_equality(out_price.value(),21.15,0.05));
// }
// SECTION("payup_false_abs_threshold"){
// bts::orderman::Book book;
// Price out_price;
// uint16_t sizes[] = { 12, 18, 20, 19, 23 };
// double prices[] = { 21.00, 21.05, 21.10, 22, 23 };
// fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL);
// spark::PreHedgeQuantityBasedPayupTicks payup_params;
// payup_params.set_payup_ticks(1);
// payup_params.mutable_quantity_threshold()->set_absolute(50);
// auto res = SpreaderUtils::prehedge_quantity_base_payup_ticks_reprice(payup_params, book, api::Side::SIDE_BUY,
// 0.05, Price(21.10), Quantity(5), out_price);
// REQUIRE(!res);
// REQUIRE(bts::securities::test_price_equality(out_price.value(),21.10,0.05));
// }
// }
TEST_CASE ("find_target_price_in_book", "[spreader]"){
SECTION("0.05"){
Quantity out_level_qty, out_cum_qty;
bts::orderman::Book book;
uint16_t sizes[] = { 11, 13, 17, 19, 23 };
double prices[] = { 22, 21.15, 20.10, 20.05, 20.00 };
fill_book (book, prices, sizes, bts::api::Side::SIDE_BUY);
// middle
bool res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_BUY, Price(20.10), 0.05, out_level_qty, out_cum_qty);
REQUIRE(res);
REQUIRE(out_level_qty.value()==17);
REQUIRE(out_cum_qty.value()==41);
// first
res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_BUY, Price(22.00), 0.05, out_level_qty, out_cum_qty);
REQUIRE(res);
REQUIRE(out_level_qty.value()==11);
REQUIRE(out_cum_qty.value()==11);
// last
res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_BUY, Price(20.00), 0.05, out_level_qty, out_cum_qty);
REQUIRE(res);
REQUIRE(out_level_qty.value()==23);
REQUIRE(out_cum_qty.value()==83);
// not found
res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_BUY, Price(21.00), 0.05, out_level_qty, out_cum_qty);
REQUIRE(!res);
// rounding error
res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_BUY, Price(20.04999999), 0.05, out_level_qty, out_cum_qty);
REQUIRE(res);
REQUIRE(out_level_qty.value()==19);
REQUIRE(out_cum_qty.value()==60);
}
SECTION("1/32"){
Quantity out_level_qty, out_cum_qty;
bts::orderman::Book book;
uint16_t sizes[] = { 12, 91, 5, 24, 33 };
double prices[] = { 100.21875, 100.28125, 101, 101.53125, 101.71875 };
fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL);
// first
bool res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_SELL, Price(100.21875), 0.03125, out_level_qty, out_cum_qty);
REQUIRE(res);
REQUIRE(out_level_qty.value()==12);
REQUIRE(out_cum_qty.value()==12);
// middle
res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_SELL, Price(101.53125), 0.03125, out_level_qty, out_cum_qty);
REQUIRE(res);
REQUIRE(out_level_qty.value()==24);
REQUIRE(out_cum_qty.value()==132);
// end
res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_SELL, Price(101.71875), 0.03125, out_level_qty, out_cum_qty);
REQUIRE(res);
REQUIRE(out_level_qty.value()==33);
REQUIRE(out_cum_qty.value()==165);
// absent
res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_SELL, Price(101.5625), 0.03125, out_level_qty, out_cum_qty);
REQUIRE(!res);
REQUIRE(out_level_qty.value()==0);
REQUIRE(out_cum_qty.value()==0);
res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_BUY, Price(101.71875), 0.03125, out_level_qty, out_cum_qty);
REQUIRE(!res);
REQUIRE(out_level_qty.value()==0);
REQUIRE(out_cum_qty.value()==0);
// rounding
res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_SELL, Price(101.531249999999), 0.03125, out_level_qty, out_cum_qty);
REQUIRE(res);
REQUIRE(out_level_qty.value()==24);
REQUIRE(out_cum_qty.value()==132);
}
}
TEST_CASE ("prehedge_payless", "[spreader]"){
SECTION("payup_true_abs_threshold"){
bts::orderman::Book book;
Price out_price;
uint16_t sizes[] = { 12, 14, 17, 19, 23 };
double prices[] = { 21.00, 21.05, 21.10, 22, 23 };
fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL);
spark::PreHedgeQuantityBasedPayLessTicks payless_params;
payless_params.set_payless_ticks(1);
payless_params.mutable_quantity_threshold()->set_absolute(25);
auto res = SpreaderUtils::prehedge_quantity_base_payless_ticks_reprice(payless_params, book, api::Side::SIDE_BUY,
0.05, Price(21.05), Quantity(5), out_price);
REQUIRE(res);
REQUIRE(out_price.value()==21.00);
}
SECTION("payup_false_abs_threshold"){
bts::orderman::Book book;
Price out_price;
uint16_t sizes[] = { 10, 14, 17, 19, 23 };
double prices[] = { 21.00, 21.05, 21.10, 22, 23 };
fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL);
spark::PreHedgeQuantityBasedPayLessTicks payless_params;
payless_params.set_payless_ticks(1);
payless_params.mutable_quantity_threshold()->set_absolute(25);
auto res = SpreaderUtils::prehedge_quantity_base_payless_ticks_reprice(payless_params, book, api::Side::SIDE_BUY,
0.05, Price(21.05), Quantity(5), out_price);
REQUIRE(!res);
REQUIRE(out_price.value()==21.05);
}
SECTION("payup_true_ratio_threshold"){
bts::orderman::Book book;
Price out_price;
uint16_t sizes[] = { 11, 14, 26, 19, 23 };
double prices[] = { 21.00, 21.05, 21.10, 22, 23 };
fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL);
spark::PreHedgeQuantityBasedPayLessTicks payless_params;
payless_params.set_payless_ticks(2);
payless_params.mutable_quantity_threshold()->set_ratio(5);
auto res = SpreaderUtils::prehedge_quantity_base_payless_ticks_reprice(payless_params, book, api::Side::SIDE_BUY,
0.05, Price(21.10), Quantity(10), out_price);
REQUIRE(res);
REQUIRE(out_price.value()==21.00);
}
SECTION("payup_true_ratio_threshold"){
bts::orderman::Book book;
Price out_price;
uint16_t sizes[] = { 11, 14, 26, 19, 23 };
double prices[] = { 21.00, 21.05, 21.10, 22, 23 };
fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL);
spark::PreHedgeQuantityBasedPayLessTicks payless_params;
payless_params.set_payless_ticks(2);
payless_params.mutable_quantity_threshold()->set_ratio(6);
auto res = SpreaderUtils::prehedge_quantity_base_payless_ticks_reprice(payless_params, book, api::Side::SIDE_BUY,
0.05, Price(21.10), Quantity(10), out_price);
REQUIRE(!res);
REQUIRE(out_price.value()==21.10);
}
}
TEST_CASE ("prehedge_payup", "[spreader]"){
SECTION("payup_true_abs_threshold"){
bts::orderman::Book book;
Price out_price;
uint16_t sizes[] = { 12, 18, 20, 19, 23 };
double prices[] = { 21.00, 21.05, 21.10, 22, 23 };
fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL);
spark::PreHedgeQuantityBasedPayupTicks payup_params;
payup_params.set_payup_ticks(1);
payup_params.mutable_quantity_threshold()->set_absolute(55);
auto res = SpreaderUtils::prehedge_quantity_base_payup_ticks_reprice(payup_params, book, api::Side::SIDE_BUY,
0.05, Price(21.10), Quantity(5), out_price);
REQUIRE(res);
REQUIRE(bts::securities::test_price_equality(out_price.value(),21.15,0.05));
}
SECTION("payup_false_abs_threshold"){
bts::orderman::Book book;
Price out_price;
uint16_t sizes[] = { 12, 18, 20, 19, 23 };
double prices[] = { 21.00, 21.05, 21.10, 22, 23 };
fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL);
spark::PreHedgeQuantityBasedPayupTicks payup_params;
payup_params.set_payup_ticks(1);
payup_params.mutable_quantity_threshold()->set_absolute(50);
auto res = SpreaderUtils::prehedge_quantity_base_payup_ticks_reprice(payup_params, book, api::Side::SIDE_BUY,
0.05, Price(21.10), Quantity(5), out_price);
REQUIRE(!res);
REQUIRE(bts::securities::test_price_equality(out_price.value(),21.10,0.05));
}
}
// // n legged spreader price evaluation /////////////////////
// ///////////////////////////////////////////////////////////
// TEST_CASE ("nlegs_compute_driver", "[spreader]"){