More tests for SpreaderWrapper
This commit is contained in:
1 parent
bd39d407aa
commit
36bbcf849c
1 file changed
+775
-5
@@ -4218,6 +4218,466 @@ TEST_CASE("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") {
|
||||
"spreader_WAITING_FOR_CANCEL_ACK.on_check_termination");
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("spreader_standlone_WAITING_FOR_CANCEL_ACK", "[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);
|
||||
// post hedge time out here
|
||||
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 pao_services(synthetic_security);
|
||||
std::vector<LegPropertyData> leg_props;
|
||||
std::vector<bts::api::orderman::OrderDefinition> quoter_ord_defs,
|
||||
hedger_ord_defs;
|
||||
SpreaderUtils::resolve_synthetic_spread(
|
||||
pao_services, order_def, leg_props, quoter_ord_defs, hedger_ord_defs);
|
||||
SpreaderManagerForTest spreader_manager(
|
||||
order_key, order_def, pao_services, leg_props, quoter_ord_defs,
|
||||
hedger_ord_defs);
|
||||
integration::SpreaderWrapper spreader_w(order_def, nullptr);
|
||||
REQUIRE(spreader_w.spreader_state() == SpreaderState::START);
|
||||
// on_init_new and activate
|
||||
SpreaderOrderServices order_services(nullptr);
|
||||
spreader_w.activate(spreader_price, spreader_quantity);
|
||||
SpreaderBookkeepingData &bookkeeping_data = spreader_w.bookkeeping_data();
|
||||
verify_basic_spreader_state(
|
||||
spreader_w.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_w.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_w.on_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_w.on_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_w.on_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_w.on_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_w.on_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_active_hedgers(); i++)
|
||||
spreader_w.on_order_update(
|
||||
{leg_data_1.get_hedger_test_only(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_active_hedgers(); i++)
|
||||
spreader_w.on_order_update(
|
||||
{leg_data_2.get_hedger_test_only(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_test_only(0), HedgerState::WORKING, Price(2002),
|
||||
Quantity(15), Quantity(0), Price(2002), Quantity(15), Quantity(15));
|
||||
verify_complete_hedger_state(
|
||||
leg_data_1.get_hedger_test_only(1), HedgerState::WORKING, Price(2002),
|
||||
Quantity(30), Quantity(0), Price(2002), Quantity(30), Quantity(30));
|
||||
verify_complete_hedger_state(
|
||||
leg_data_1.get_hedger_test_only(2), HedgerState::WORKING, Price(2002),
|
||||
Quantity(10), Quantity(0), Price(2002), Quantity(10), Quantity(10));
|
||||
verify_complete_hedger_state(
|
||||
leg_data_2.get_hedger_test_only(0), HedgerState::WORKING, Price(1999),
|
||||
Quantity(20), Quantity(0), Price(1999), Quantity(20), Quantity(20));
|
||||
verify_complete_hedger_state(
|
||||
leg_data_2.get_hedger_test_only(1), 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
|
||||
bts::TimeStamp cancel_timestamp = std::chrono::system_clock::now();
|
||||
// TODO
|
||||
// speader_w.test_only_on_time(cancel_timestamp);
|
||||
spreader_w.cancel();
|
||||
auto validate_state = [&]() -> void {
|
||||
verify_basic_spreader_state(
|
||||
spreader_w.spreader(), SpreaderState::WAITING_FOR_CANCEL_ALL,
|
||||
spreader_price, spreader_quantity);
|
||||
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::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_test_only(0),
|
||||
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_test_only(1),
|
||||
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_test_only(2),
|
||||
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_test_only(0),
|
||||
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_test_only(1),
|
||||
HedgerState::WAITING_FOR_CANCEL_ACK, Price(1999), Quantity(10),
|
||||
Quantity(0), Price(1999), Quantity(10), Quantity(10));
|
||||
};
|
||||
validate_state();
|
||||
SECTION("1. init") {}
|
||||
SECTION("2. on_connect") {}
|
||||
SECTION("4. on_update") {
|
||||
spreader_w.update_spreader(Price(-0.05), Quantity(200));
|
||||
validate_state();
|
||||
// order changes dont go through
|
||||
validate_state();
|
||||
LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_update");
|
||||
}
|
||||
SECTION("5. on_cancel") {
|
||||
spreader_w.cancel();
|
||||
// already in cancel state, no change
|
||||
validate_state();
|
||||
LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_cancel");
|
||||
}
|
||||
SECTION("6. on_book") {
|
||||
// like 4 and 5, should have no effect
|
||||
set_spreader_orders(
|
||||
spreader_w.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}, 30, 2000, 55, 2001);
|
||||
validate_state();
|
||||
LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_book");
|
||||
}
|
||||
SECTION("8. on_quoter_order_error") {
|
||||
spreader_w.on_order_update(
|
||||
{leg_data_1.order_key(),
|
||||
bts::api::orderman::OrderStatus::ORDER_STATUS_DISCONNECTED,
|
||||
Quantity(30), Price(2000)});
|
||||
validate_state();
|
||||
LOG(OrderMan, Diag,
|
||||
"spreader_WAITING_FOR_CANCEL_ACK.on_quoter_order_error");
|
||||
}
|
||||
SECTION("9. on_quoter_order_fill") {
|
||||
// send another fill on leg 1, this will update the filled
|
||||
// state of leg 1, but no other action will take place
|
||||
spreader_w.on_order_update(
|
||||
{leg_data_1.order_key(),
|
||||
bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(40),
|
||||
Price(2000.5)});
|
||||
verify_basic_spreader_state(
|
||||
spreader_w.spreader(), SpreaderState::WAITING_FOR_CANCEL_ALL,
|
||||
spreader_price, spreader_quantity);
|
||||
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::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_test_only(0),
|
||||
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_test_only(1),
|
||||
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_test_only(2),
|
||||
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_test_only(0),
|
||||
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_test_only(1),
|
||||
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") {
|
||||
// cancelled update
|
||||
spreader_w.on_order_update(
|
||||
{leg_data_1.order_key(),
|
||||
bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED, Quantity(30),
|
||||
Price(2000)});
|
||||
verify_basic_spreader_state(
|
||||
spreader_w.spreader(), SpreaderState::WAITING_FOR_CANCEL_ALL,
|
||||
spreader_price, spreader_quantity);
|
||||
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::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_test_only(0),
|
||||
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_test_only(1),
|
||||
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_test_only(2),
|
||||
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_test_only(0),
|
||||
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_test_only(1),
|
||||
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") {
|
||||
std::string err_msg = "error";
|
||||
spreader_w.on_order_update(
|
||||
{leg_data_1.get_hedger_test_only(0).order_state().order_key(),
|
||||
bts::api::orderman::OrderStatus::ORDER_STATUS_DISCONNECTED,
|
||||
Quantity(0), Price(0)});
|
||||
validate_state();
|
||||
LOG(OrderMan, Diag,
|
||||
"spreader_WAITING_FOR_CANCEL_ACK.on_hedger_order_error");
|
||||
}
|
||||
SECTION("12. on_hedger_order_update") {
|
||||
// send a fill
|
||||
spreader_w.on_order_update(
|
||||
{leg_data_1.get_hedger_test_only(0).order_state().order_key(),
|
||||
bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(10),
|
||||
Price(2000)});
|
||||
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_test_only(0),
|
||||
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_test_only(1),
|
||||
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_test_only(2),
|
||||
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_test_only(0),
|
||||
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_test_only(1),
|
||||
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("14. on_check_termination") {
|
||||
// send cancel for orders, once all quoters and hedgers
|
||||
// are cancelled, spreader should come to end
|
||||
spreader_w.on_order_update(
|
||||
{leg_data_1.order_update_message().order_key(),
|
||||
bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED, Quantity(30),
|
||||
Price(2000)});
|
||||
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_w.on_order_update(
|
||||
{leg_data_2.order_update_message().order_key(),
|
||||
bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED, Quantity(55),
|
||||
Price(2000)});
|
||||
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_w.spreader(), SpreaderState::WAITING_FOR_CANCEL_ALL,
|
||||
spreader_price, spreader_quantity);
|
||||
spreader_w.on_order_update(
|
||||
{leg_data_1.get_hedger_test_only(0).order_state().order_key(),
|
||||
bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED, Quantity(0),
|
||||
Price(0)});
|
||||
verify_complete_hedger_state(
|
||||
leg_data_1.get_hedger_test_only(0), HedgerState::END, Price(2002),
|
||||
Quantity(15), Quantity(0), Price(0), Quantity(0), Quantity(15));
|
||||
spreader_w.on_order_update(
|
||||
{leg_data_1.get_hedger_test_only(1).order_state().order_key(),
|
||||
bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED, Quantity(0),
|
||||
Price(0)});
|
||||
verify_complete_hedger_state(
|
||||
leg_data_1.get_hedger_test_only(1), HedgerState::END, Price(2002),
|
||||
Quantity(30), Quantity(0), Price(0), Quantity(0), Quantity(30));
|
||||
spreader_w.on_order_update(
|
||||
{leg_data_1.get_hedger_test_only(2).order_state().order_key(),
|
||||
bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED, Quantity(0),
|
||||
Price(0)});
|
||||
verify_complete_hedger_state(
|
||||
leg_data_1.get_hedger_test_only(2), HedgerState::END, Price(2002),
|
||||
Quantity(10), Quantity(0), Price(0), Quantity(0), Quantity(10));
|
||||
spreader_w.on_order_update(
|
||||
{leg_data_2.get_hedger_test_only(0).order_state().order_key(),
|
||||
bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED, Quantity(0),
|
||||
Price(0)});
|
||||
verify_complete_hedger_state(
|
||||
leg_data_2.get_hedger_test_only(0), HedgerState::END, Price(1999),
|
||||
Quantity(20), Quantity(0), Price(0), Quantity(0), Quantity(20));
|
||||
verify_basic_spreader_state(
|
||||
spreader_w.spreader(), SpreaderState::WAITING_FOR_CANCEL_ALL,
|
||||
spreader_price, spreader_quantity);
|
||||
spreader_w.on_order_update(
|
||||
{leg_data_2.get_hedger_test_only(1).order_state().order_key(),
|
||||
bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED, Quantity(0),
|
||||
Price(0)});
|
||||
verify_complete_hedger_state(
|
||||
leg_data_2.get_hedger_test_only(1), HedgerState::END, Price(1999),
|
||||
Quantity(10), Quantity(0), Price(0), Quantity(0), Quantity(10));
|
||||
verify_basic_spreader_state(
|
||||
spreader_w.spreader(), SpreaderState::END, spreader_price,
|
||||
spreader_quantity);
|
||||
LOG(OrderMan, Diag,
|
||||
"spreader_WAITING_FOR_CANCEL_ACK.on_check_termination");
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("find_target_price_in_book", "[spreader]") {
|
||||
SECTION("0.05") {
|
||||
Quantity out_cum_qty;
|
||||
@@ -4981,6 +5441,7 @@ TEST_CASE("spreader_perf_2legs", "[spreader]") {
|
||||
<< " unit time(usecs):" << hedge_time << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("spreader_perf_4legs", "[spreader]") {
|
||||
bool recomp = false; // gen_rand(0,10) > 5;
|
||||
bts::orderman::OrderKey order_key(0);
|
||||
@@ -5284,6 +5745,312 @@ TEST_CASE("spreader_perf_4legs", "[spreader]") {
|
||||
REQUIRE(t_qty.value() == 10);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("spreader_standalone_perf_4legs", "[spreader]") {
|
||||
bool recomp = false; // gen_rand(0,10) > 5;
|
||||
bts::orderman::OrderKey order_key(0);
|
||||
Price spreader_price = Price(40);
|
||||
Quantity spreader_quantity = Quantity(250);
|
||||
ContractLeg leg_1, leg_2, leg_3, qleg_4;
|
||||
fill_future_contract_leg(
|
||||
leg_1, 2468, "SI", bts::api::Venue::VENUE_GLBX, 2019, 1, 15, 1.0, 1.0,
|
||||
api::Side::SIDE_BUY, 1.0, 0.005);
|
||||
fill_future_contract_leg(
|
||||
leg_2, 2469, "SI", bts::api::Venue::VENUE_GLBX, 2019, 2, 15, 1.0, 1.0,
|
||||
api::Side::SIDE_BUY, 1.0, 0.005);
|
||||
fill_future_contract_leg(
|
||||
leg_3, 2470, "SI", bts::api::Venue::VENUE_GLBX, 2019, 3, 15, 1.0, 1.0,
|
||||
api::Side::SIDE_BUY, 1.0, 0.005);
|
||||
fill_future_contract_leg(
|
||||
qleg_4, 2471, "SI", bts::api::Venue::VENUE_GLBX, 2019, 4, 15, -1.0, -1.0,
|
||||
api::Side::SIDE_SELL, 1.0, 0.005);
|
||||
std::vector<ContractLeg> contract_legs;
|
||||
contract_legs.push_back(leg_1);
|
||||
contract_legs.push_back(leg_2);
|
||||
contract_legs.push_back(leg_3);
|
||||
contract_legs.push_back(qleg_4);
|
||||
Security synthetic_security;
|
||||
fill_synthetic_security(
|
||||
synthetic_security, 2000, "synthetic_security", contract_legs);
|
||||
// execution params/order def
|
||||
LegSpreaderParams lsp_1, lsp_2, lsp_3, qlsp_4;
|
||||
fill_leg_spreader_params(lsp_1, 1.0, false, 1.0);
|
||||
fill_leg_spreader_params(lsp_2, 1.0, false, 1.0);
|
||||
fill_leg_spreader_params(lsp_3, 1.0, false, 1.0);
|
||||
fill_leg_spreader_params(qlsp_4, -1.0, true, 1.0);
|
||||
std::vector<LegSpreaderParams> spreader_params;
|
||||
spreader_params.push_back(lsp_1);
|
||||
spreader_params.push_back(lsp_2);
|
||||
spreader_params.push_back(lsp_3);
|
||||
spreader_params.push_back(qlsp_4);
|
||||
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 pao_services(synthetic_security);
|
||||
std::vector<LegPropertyData> leg_props;
|
||||
std::vector<bts::api::orderman::OrderDefinition> quoter_ord_defs,
|
||||
hedger_ord_defs;
|
||||
SpreaderUtils::resolve_synthetic_spread(
|
||||
pao_services, order_def, leg_props, quoter_ord_defs, hedger_ord_defs);
|
||||
SpreaderManagerForTest spreader_manager(
|
||||
order_key, order_def, pao_services, leg_props, quoter_ord_defs,
|
||||
hedger_ord_defs);
|
||||
// SpreaderOrder spreader(spreader_manager.alt_order_gateway());
|
||||
integration::SpreaderWrapper spreader_w(order_def, nullptr);
|
||||
REQUIRE(spreader_w.spreader_state() == SpreaderState::START);
|
||||
// on_init_new and activate
|
||||
// spreader.test_only_on_init_new(order_def, pao_services);
|
||||
SpreaderOrderServices order_services(nullptr);
|
||||
spreader_w.activate(spreader_price, spreader_quantity);
|
||||
SpreaderBookkeepingData &bookkeeping_data = spreader_w.bookkeeping_data();
|
||||
verify_basic_spreader_state(
|
||||
spreader_w.spreader(), SpreaderState::WORKING, spreader_price,
|
||||
spreader_quantity);
|
||||
SpreaderLegData &qleg_data_4 = bookkeeping_data.get_leg_data(3);
|
||||
verify_complete_quoter_state(
|
||||
qleg_data_4.quoter(), QuoterState::WAITING_FOR_SIZE, false,
|
||||
spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0),
|
||||
Quantity(0), spreader_quantity, false);
|
||||
Book book_1 = get_book(
|
||||
SecurityKey(leg_1.security().id()), 5,
|
||||
new double[5]{20, 19.995, 19.990, 19.985, 19.980},
|
||||
new uint16_t[5]{100, 50, 75, 150, 25},
|
||||
new double[5]{20.005, 20.010, 20.015, 20.020, 20.025},
|
||||
new uint16_t[5]{25, 125, 175, 225, 100}, true),
|
||||
book_1_alt = get_book(
|
||||
SecurityKey(leg_1.security().id()), 5,
|
||||
new double[5]{20.005, 19.990, 19.890, 19.885, 19.780},
|
||||
new uint16_t[5]{10, 25, 75, 15, 25},
|
||||
new double[5]{20.010, 20.015, 20.025, 20.030, 20.035},
|
||||
new uint16_t[5]{10, 25, 75, 15, 25}, true),
|
||||
book_2 = get_book(
|
||||
SecurityKey(leg_2.security().id()), 5,
|
||||
new double[5]{20.030, 20.025, 20.020, 20.015, 20.010},
|
||||
new uint16_t[5]{100, 100, 200, 250, 75},
|
||||
new double[5]{20.035, 20.040, 20.045, 20.050, 20.055},
|
||||
new uint16_t[5]{250, 275, 100, 5, 15}, true),
|
||||
book_2_alt = get_book(
|
||||
SecurityKey(leg_2.security().id()), 5,
|
||||
new double[5]{20.050, 20.035, 20.030, 20.035, 20.030},
|
||||
new uint16_t[5]{10, 10, 20, 250, 75},
|
||||
new double[5]{20.055, 20.060, 20.065, 20.070, 20.085},
|
||||
new uint16_t[5]{25, 275, 100, 5, 15}, true),
|
||||
book_3 = get_book(
|
||||
SecurityKey(leg_3.security().id()), 5,
|
||||
new double[5]{19.985, 19.980, 19.975, 19.970, 19.965},
|
||||
new uint16_t[5]{75, 250, 125, 100, 300},
|
||||
new double[5]{19.990, 19.995, 20.000, 20.005, 20.010},
|
||||
new uint16_t[5]{100, 150, 250, 25, 125}, true),
|
||||
book_3_alt = get_book(
|
||||
SecurityKey(leg_3.security().id()), 5,
|
||||
new double[5]{19.885, 19.875, 19.870, 19.765, 19.760},
|
||||
new uint16_t[5]{75, 25, 125, 100, 300},
|
||||
new double[5]{19.890, 19.895, 19.900, 19.910, 19.915},
|
||||
new uint16_t[5]{100, 50, 50, 125, 125}, true);
|
||||
spreader_w.update_book(book_1);
|
||||
spreader_w.update_book(book_2);
|
||||
spreader_w.update_book(book_3);
|
||||
verify_complete_quoter_state(
|
||||
qleg_data_4.quoter(), QuoterState::WAITING_FOR_FIRST_ACK, false,
|
||||
spreader_price, spreader_quantity, Quantity(0), Quantity(0),
|
||||
Price(20.045), spreader_quantity, spreader_quantity, false);
|
||||
spreader_w.on_order_update(
|
||||
{qleg_data_4.order_key(),
|
||||
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
|
||||
Price(0)});
|
||||
verify_complete_quoter_state(
|
||||
qleg_data_4.quoter(), QuoterState::WORKING, false, spreader_price,
|
||||
spreader_quantity, Quantity(0), Quantity(0), Price(20.045),
|
||||
spreader_quantity, spreader_quantity, false);
|
||||
SECTION("Testing Hedge Reuse") {
|
||||
Quantity t_qty;
|
||||
Price t_price;
|
||||
// to keep the compiler warning happy
|
||||
LOG(OrderMan, Info, "{} {} {}", book_1_alt.n_levels(),
|
||||
book_2_alt.n_levels(), book_3_alt.n_levels());
|
||||
// this sends fills, makes sure the hedgers are
|
||||
// working, and on fill and recycled
|
||||
// the hedge prices used are
|
||||
// 20.015, 20.035 and 19.995
|
||||
SpreaderLegData &qleg_data_4 = bookkeeping_data.get_leg_data(3);
|
||||
// lets concentrate on the hedges sent on leg 1
|
||||
SpreaderLegData &hleg_1 = bookkeeping_data.get_leg_data(0);
|
||||
auto &hm_1 = hleg_1.hedger_manager();
|
||||
REQUIRE(hm_1.n_active_hedgers() == 0);
|
||||
// send a 1 lot quoter fill /////////
|
||||
/////////////////////////////////////
|
||||
spreader_w.on_order_update(
|
||||
{qleg_data_4.order_key(),
|
||||
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(1),
|
||||
Price(20.045)});
|
||||
REQUIRE(hm_1.n_active_hedgers() == 1);
|
||||
// legs 2 and 3
|
||||
REQUIRE(securities::test_price_equality(
|
||||
bookkeeping_data.get_leg_data(1)
|
||||
.hedger_manager()
|
||||
.test_only_get_hedger_at(0)
|
||||
.order_state()
|
||||
.out_price()
|
||||
.value(),
|
||||
20.035, 0.005));
|
||||
REQUIRE(securities::test_price_equality(
|
||||
bookkeeping_data.get_leg_data(2)
|
||||
.hedger_manager()
|
||||
.test_only_get_hedger_at(0)
|
||||
.order_state()
|
||||
.out_price()
|
||||
.value(),
|
||||
recomp ? 19.990 : 19.995, 0.005));
|
||||
// back to leg1's hedger, this is what will
|
||||
// be mainly tested here on
|
||||
{
|
||||
auto &hedger_1_1 = hm_1.test_only_get_hedger_at(0);
|
||||
REQUIRE(hedger_1_1.order_state().out_quantity().value() == 1);
|
||||
REQUIRE(securities::test_price_equality(
|
||||
hedger_1_1.order_state().out_price().value(),
|
||||
recomp ? 20.005 : 20.015, 0.005));
|
||||
REQUIRE(hedger_1_1.state() == HedgerState::WAITING_FOR_FIRST_ACK);
|
||||
spreader_w.on_order_update(
|
||||
{hedger_1_1.order_state().order_key(),
|
||||
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
|
||||
Price(0)});
|
||||
REQUIRE(hedger_1_1.state() == HedgerState::WORKING);
|
||||
// fill h1 and it goes back to start ////
|
||||
/////////////////////////////////////////
|
||||
spreader_w.on_order_update(
|
||||
{hedger_1_1.order_state().order_key(),
|
||||
api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(1),
|
||||
Price(20.015)});
|
||||
REQUIRE(hedger_1_1.state() == HedgerState::START);
|
||||
}
|
||||
REQUIRE(hm_1.n_active_hedgers() == 0);
|
||||
hm_1.total_fills(t_qty, t_price);
|
||||
REQUIRE(t_qty.value() == 1);
|
||||
REQUIRE(securities::test_price_equality(t_price.value(), 20.015, 0.005));
|
||||
////////////////////////////
|
||||
// send another 1 lot q fill
|
||||
spreader_w.on_order_update(
|
||||
{qleg_data_4.order_key(),
|
||||
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(2),
|
||||
Price(20.045)});
|
||||
REQUIRE(hm_1.n_active_hedgers() == 1);
|
||||
// since 2 and 3 were never filled, they should have 2 hedgers
|
||||
REQUIRE(
|
||||
bookkeeping_data.get_leg_data(1)
|
||||
.hedger_manager()
|
||||
.n_active_hedgers() == 2);
|
||||
REQUIRE(
|
||||
bookkeeping_data.get_leg_data(2)
|
||||
.hedger_manager()
|
||||
.n_active_hedgers() == 2);
|
||||
{
|
||||
auto &hedger_1_1 = hm_1.test_only_get_hedger_at(0);
|
||||
REQUIRE(hedger_1_1.order_state().out_quantity().value() == 1);
|
||||
REQUIRE(securities::test_price_equality(
|
||||
hedger_1_1.order_state().out_price().value(),
|
||||
recomp ? 20.005 : 20.015, 0.005));
|
||||
REQUIRE(hedger_1_1.state() == HedgerState::WAITING_FOR_FIRST_ACK);
|
||||
spreader_w.on_order_update(
|
||||
{hedger_1_1.order_state().order_key(),
|
||||
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
|
||||
Price(0)});
|
||||
REQUIRE(hedger_1_1.state() == HedgerState::WORKING);
|
||||
// fill h1 ///////
|
||||
//////////////////
|
||||
spreader_w.on_order_update(
|
||||
{hedger_1_1.order_state().order_key(),
|
||||
api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(1),
|
||||
Price(20.025)});
|
||||
REQUIRE(hedger_1_1.state() == HedgerState::START);
|
||||
}
|
||||
REQUIRE(hm_1.n_active_hedgers() == 0);
|
||||
hm_1.total_fills(t_qty, t_price);
|
||||
REQUIRE(t_qty.value() == 2);
|
||||
REQUIRE(securities::test_price_equality(t_price.value(), 20.020, 0.005));
|
||||
// send 4 more q fills /////////
|
||||
////////////////////////////////
|
||||
for (size_t f = 4; f <= 10; f += 2)
|
||||
spreader_w.on_order_update(
|
||||
{qleg_data_4.order_key(),
|
||||
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(f),
|
||||
Price(20.045)});
|
||||
REQUIRE(hm_1.n_active_hedgers() == 4);
|
||||
REQUIRE(
|
||||
bookkeeping_data.get_leg_data(1)
|
||||
.hedger_manager()
|
||||
.n_active_hedgers() == 6);
|
||||
REQUIRE(
|
||||
bookkeeping_data.get_leg_data(2)
|
||||
.hedger_manager()
|
||||
.n_active_hedgers() == 6);
|
||||
REQUIRE(
|
||||
bookkeeping_data.get_leg_data(3)
|
||||
.hedger_manager()
|
||||
.n_active_hedgers() == 0);
|
||||
for (size_t i = 0; i < 4; i++) {
|
||||
auto &h = hm_1.test_only_get_hedger_at(i);
|
||||
REQUIRE(h.state() == HedgerState::WAITING_FOR_FIRST_ACK);
|
||||
REQUIRE(h.order_state().out_quantity().value() == 2);
|
||||
REQUIRE(securities::test_price_equality(
|
||||
h.order_state().out_price().value(), recomp ? 20.005 : 20.015,
|
||||
0.005));
|
||||
}
|
||||
// send order acks //////////
|
||||
/////////////////////////////
|
||||
for (size_t i = 0; i < 4; i++) {
|
||||
auto &h = hm_1.test_only_get_hedger_at(i);
|
||||
spreader_w.on_order_update(
|
||||
{h.order_state().order_key(),
|
||||
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
|
||||
Price(0)});
|
||||
REQUIRE(h.state() == HedgerState::WORKING);
|
||||
REQUIRE(h.order_state().out_quantity().value() == 2);
|
||||
REQUIRE(securities::test_price_equality(
|
||||
h.order_state().out_price().value(), recomp ? 20.005 : 20.015,
|
||||
0.005));
|
||||
}
|
||||
REQUIRE(hm_1.n_active_hedgers() == 4);
|
||||
// fills 1 lot on each order //
|
||||
///////////////////////////////
|
||||
for (size_t i = 0; i < 4; i++) {
|
||||
auto &h = hm_1.test_only_get_hedger_at(i);
|
||||
// previous hedger fills were 20.015, 20.025
|
||||
spreader_w.on_order_update(
|
||||
{h.order_state().order_key(),
|
||||
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(1),
|
||||
Price(20.035)});
|
||||
REQUIRE(h.state() == HedgerState::WORKING);
|
||||
REQUIRE(h.order_state().out_quantity().value() == 2);
|
||||
REQUIRE(securities::test_price_equality(
|
||||
h.order_state().out_price().value(), recomp ? 20.005 : 20.015,
|
||||
0.005));
|
||||
}
|
||||
REQUIRE(hm_1.n_active_hedgers() == 4);
|
||||
hm_1.total_fills(t_qty, t_price);
|
||||
REQUIRE(securities::test_price_equality(t_price.value(), 20.03, 0.005));
|
||||
REQUIRE(t_qty.value() == 6);
|
||||
|
||||
// fills additional 1 lot on each, ///////
|
||||
// which should complete the orders //////
|
||||
//////////////////////////////////////////
|
||||
for (size_t i = 0; i < 4; i++) {
|
||||
auto &h = hm_1.test_only_get_hedger_at(i);
|
||||
// previous hedger fills were 20.015, 20.025
|
||||
spreader_w.on_order_update(
|
||||
{h.order_state().order_key(),
|
||||
api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(2),
|
||||
Price(20.03)});
|
||||
REQUIRE(h.state() == HedgerState::START);
|
||||
REQUIRE(h.order_state().out_quantity().value() == 0);
|
||||
}
|
||||
REQUIRE(hm_1.n_active_hedgers() == 0);
|
||||
hm_1.total_fills(t_qty, t_price);
|
||||
REQUIRE(securities::test_price_equality(t_price.value(), 20.03, 0.005));
|
||||
REQUIRE(t_qty.value() == 10);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("simple book addition", "[spreader]") {
|
||||
SECTION("direct, book") {
|
||||
SecurityKey key(12345);
|
||||
@@ -5817,8 +6584,8 @@ TEST_CASE("net_change_transformation", "[spreader]") {
|
||||
b2_raw, bts::md::IntPrice_from_double<7>(settle2), tick2,
|
||||
spark::LegSpreaderParams::MERGED,
|
||||
bts::api::SyntheticContract::PRICECALC_NET_CHANGE, b2_ticks);
|
||||
// generate the leg properties accordingly (notice the tick size is 1
|
||||
// since the market is in ticks)
|
||||
// generate the leg properties accordingly (notice the tick size is
|
||||
// 1 since the market is in ticks)
|
||||
const LegPropertyData lp1 = create_leg_property_data(
|
||||
0, leg1_qty, leg1_pmult, api::Side::SIDE_BUY,
|
||||
1, 0, true),
|
||||
@@ -5892,17 +6659,20 @@ TEST_CASE("net_change_transformation", "[spreader]") {
|
||||
// Book look_ahead_book = bk;
|
||||
// // buy sweep
|
||||
// bool res = SpreaderUtils::compute_book_from_sweep(
|
||||
// bk, api::Side::SIDE_BUY, Price(80), Quantity(15), look_ahead_book);
|
||||
// bk, api::Side::SIDE_BUY, Price(80), Quantity(15),
|
||||
// look_ahead_book);
|
||||
// REQUIRE(res);
|
||||
// res = SpreaderUtils::compute_book_from_sweep(
|
||||
// bk, api::Side::SIDE_BUY, Price(80), Quantity(16), look_ahead_book);
|
||||
// bk, api::Side::SIDE_BUY, Price(80), Quantity(16),
|
||||
// look_ahead_book);
|
||||
// REQUIRE(!res);
|
||||
// res = SpreaderUtils::compute_book_from_sweep(
|
||||
// bk, api::Side::SIDE_BUY, Price(80.01), Quantity(16),
|
||||
// look_ahead_book);
|
||||
// REQUIRE(!res);
|
||||
// res = SpreaderUtils::compute_book_from_sweep(
|
||||
// bk, api::Side::SIDE_BUY, Price(80), Quantity(15), look_ahead_book);
|
||||
// bk, api::Side::SIDE_BUY, Price(80), Quantity(15),
|
||||
// look_ahead_book);
|
||||
// REQUIRE(res);
|
||||
// bts::securities::test_price_equality(
|
||||
// look_ahead_book.bid()[0].price(), 80);
|
||||
|
||||
Reference in new issue
Block a user