#include "server/sparkd/orderman/tests/tests_common.h" namespace bts { namespace orderman { // QuoteLegPriceQuantityState is used by the quoter // to keep the state of the order state, ie // target price, qty // filled qty // reduced quantity due to other legs // output price, qty TEST_CASE ("quoter price quantity state", "[spreader]") { // construction QuoteLegPriceQuantityState s (Price (-1.0), Quantity (200)); bts_assert (s.target_spread_price() == Price (-1.0)); bts_assert (s.target_leg_quantity() == Quantity (200)); bts_assert (s.aggregated_filled_quantity() == Quantity (0)); bts_assert (s.aggregated_hedged_reduction() == Quantity (0)); bts_assert (s.remaining_to_fill() == Quantity (200)); bts_assert (s.out_price() == Price (0.0)); bts_assert (s.out_quantity() == Quantity (0)); // add fills s.add_filled_quantity (Quantity(10)); s.add_filled_quantity (Quantity(15)); bts_assert (s.target_spread_price() == Price (-1.0)); bts_assert (s.target_leg_quantity() == Quantity (200)); bts_assert (s.aggregated_filled_quantity() == Quantity (25)); bts_assert (s.aggregated_hedged_reduction() == Quantity (0)); bts_assert (s.remaining_to_fill() == Quantity (175)); bts_assert (s.out_price() == Price (0.0)); bts_assert (s.out_quantity() == Quantity (0)); // add hedged reduction s.add_hedged_reduction (Quantity(15)); s.add_hedged_reduction (Quantity(5)); s.add_hedged_reduction (Quantity(30)); bts_assert (s.target_spread_price() == Price (-1.0)); bts_assert (s.target_leg_quantity() == Quantity (200)); bts_assert (s.aggregated_filled_quantity() == Quantity (25)); bts_assert (s.aggregated_hedged_reduction() == Quantity (50)); bts_assert (s.remaining_to_fill() == Quantity (125)); bts_assert (s.out_price() == Price (0.0)); bts_assert (s.out_quantity() == Quantity (0)); // set out price and quantity s.update_out_price_quantity (Price (-0.35), Quantity (123)); bts_assert (s.target_spread_price() == Price (-1.0)); bts_assert (s.target_leg_quantity() == Quantity (200)); bts_assert (s.aggregated_filled_quantity() == Quantity (25)); bts_assert (s.aggregated_hedged_reduction() == Quantity (50)); bts_assert (s.remaining_to_fill() == Quantity (125)); bts_assert (s.out_price() == Price (-0.35)); bts_assert (s.out_quantity() == Quantity (123)); // change target price / quantity s.update_target_price_quantity (s.target_spread_price(), Quantity (105)); bts_assert (s.target_spread_price() == Price (-1.0)); bts_assert (s.target_leg_quantity() == Quantity (105)); bts_assert (s.aggregated_filled_quantity() == Quantity (25)); bts_assert (s.aggregated_hedged_reduction() == Quantity (50)); bts_assert (s.remaining_to_fill() == Quantity (30)); bts_assert (s.out_price() == Price (-0.35)); bts_assert (s.out_quantity() == Quantity (123)); // make the hedges go over s.add_hedged_reduction (Quantity(35)); bts_assert (s.target_spread_price() == Price (-1.0)); bts_assert (s.target_leg_quantity() == Quantity (105)); bts_assert (s.aggregated_filled_quantity() == Quantity (25)); bts_assert (s.aggregated_hedged_reduction() == Quantity (85)); bts_assert (s.remaining_to_fill() == Quantity (0)); bts_assert (s.out_price() == Price (-0.35)); bts_assert (s.out_quantity() == Quantity (123)); // make the fills go over s.add_filled_quantity (Quantity(15)); bts_assert (s.target_spread_price() == Price (-1.0)); bts_assert (s.target_leg_quantity() == Quantity (105)); bts_assert (s.aggregated_filled_quantity() == Quantity (40)); bts_assert (s.aggregated_hedged_reduction() == Quantity (85)); bts_assert (s.remaining_to_fill() == Quantity (0)); bts_assert (s.out_price() == Price (-0.35)); bts_assert (s.out_quantity() == Quantity (123)); SECTION("test cycle_back") { QuoteLegPriceQuantityState s (Price (-1.0), Quantity (200)); bts_assert (s.target_spread_price() == Price (-1.0)); bts_assert (s.target_leg_quantity() == Quantity (200)); bts_assert (s.aggregated_filled_quantity() == Quantity (0)); bts_assert (s.aggregated_hedged_reduction() == Quantity (0)); bts_assert (s.remaining_to_fill() == Quantity (200)); bts_assert (s.out_price() == Price (0.0)); bts_assert (s.out_quantity() == Quantity (0)); // add fills s.add_filled_quantity (Quantity(15)); s.add_filled_quantity (Quantity(25)); // add hedge reductions s.add_hedged_reduction (Quantity(5)); s.add_hedged_reduction (Quantity(15)); // set out values s.update_out_price_quantity (Price(1), Quantity (50)); bts_assert (s.target_spread_price() == Price (-1.0)); bts_assert (s.target_leg_quantity() == Quantity (200)); bts_assert (s.aggregated_filled_quantity() == Quantity (40)); bts_assert (s.aggregated_hedged_reduction() == Quantity (20)); bts_assert (s.remaining_to_fill() == Quantity (140)); bts_assert (s.out_price() == Price (1.0)); bts_assert (s.out_quantity() == Quantity (50)); // now cycle it back s.cycle_back (); bts_assert (s.target_spread_price() == Price (-1.0)); bts_assert (s.target_leg_quantity() == Quantity (200)); bts_assert (s.aggregated_filled_quantity() == Quantity (0)); bts_assert (s.aggregated_hedged_reduction() == Quantity (20)); bts_assert (s.remaining_to_fill() == Quantity (140)); bts_assert (s.out_price() == Price (0.0)); bts_assert (s.out_quantity() == Quantity (0)); // now make sure everything is good after the cycle_back s.add_filled_quantity (Quantity(8)); s.add_filled_quantity (Quantity(2)); s.add_hedged_reduction (Quantity(3)); s.add_hedged_reduction (Quantity(7)); s.update_out_price_quantity (Price(0.75), Quantity (50)); bts_assert (s.target_spread_price() == Price (-1.0)); bts_assert (s.target_leg_quantity() == Quantity (200)); bts_assert (s.aggregated_filled_quantity() == Quantity (10)); bts_assert (s.aggregated_hedged_reduction() == Quantity (30)); bts_assert (s.remaining_to_fill() == Quantity (120)); bts_assert (s.out_price() == Price (0.75)); bts_assert (s.out_quantity() == Quantity (50)); } } // tests spread_qty -> leg_qty and leg_2_qty -> leg_1_qty TEST_CASE ("test_leg_quantity_normalization", "[spreader]") { int n_runs = 20; for (int i = 0; i < n_runs; i++) { double leg_mult = gen_rand(-5.0, 2.0); uint32_t spr_qty = gen_rand(0, 100); std::string symbol = "ES"; ContractLeg leg; fill_future_contract_leg (leg, 0, symbol, bts::api::Venue::VENUE_GLBX, 2018, 12, 15, leg_mult, api::Side::SIDE_BUY, 1.0, 0.25); QuoteParams qp; fill_quote_params(qp, 1.0); LegSpreaderParams lsp; fill_leg_spreader_params (lsp, 1.0, true, qp); LegPropertyData leg_prop_data (0, leg, lsp, api::Side::SIDE_BUY); double calc_value = SpreaderUtils::get_leg_quantity_from_spreader_quantity (leg_prop_data, Quantity (spr_qty)), expected_value = std::round(std::abs(leg_mult * spr_qty)); bts_assert (calc_value == expected_value); } for (int i = 0; i < n_runs; i++) { double leg_mult_1 = gen_rand(-5.0, 2.0), leg_mult_2 = gen_rand(-5.0, 2.0); uint32_t leg_qty = gen_rand(0, 100); std::string symbol = "ES"; ContractLeg leg_1, leg_2; fill_future_contract_leg (leg_1, 0, symbol, bts::api::Venue::VENUE_GLBX, 2017, 12, 15, leg_mult_1, api::Side::SIDE_BUY, 1.0, 0.25); fill_future_contract_leg (leg_2, 1, symbol, bts::api::Venue::VENUE_GLBX, 2018, 3, 15, leg_mult_2, api::Side::SIDE_SELL, 1.0, 0.25); QuoteParams qp_1, qp_2; fill_quote_params(qp_1, 1.0); fill_quote_params(qp_2, 1.0); LegSpreaderParams lsp_1, lsp_2; fill_leg_spreader_params (lsp_1, 1.0, true, qp_1); fill_leg_spreader_params (lsp_2, 1.0, true, qp_2); LegPropertyData leg_prop_data_1 (0, leg_1, lsp_1, api::Side::SIDE_BUY); LegPropertyData leg_prop_data_2 (1, leg_2, lsp_2, api::Side::SIDE_BUY); double calc_value = SpreaderUtils::get_equivelant_size (leg_prop_data_1, Quantity(leg_qty), leg_prop_data_2), expected_value = std::round(std::abs(leg_qty * leg_mult_2 / leg_mult_1)); bts_assert (calc_value == expected_value); } } // given a qty, traverses the book to find the level // where the accumulated qty >= given qty TEST_CASE ("book traversal", "[spreader]") { Price calc_price; Quantity calc_quantity; SECTION("test level 1 sell") { bts::orderman2::Book book; uint16_t sizes[] = { 11, 13, 17, 19, 23 }; double prices[] = { 2500.25, 2500.50, 2501, 2502, 2503 }; fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL); SpreaderUtils::traverse_depth_for_quantity (book, bts::api::Side::SIDE_SELL, Quantity (7), calc_price, calc_quantity); bts_assert (calc_price == Price (2500.25)); bts_assert (calc_quantity == Quantity (7)); SpreaderUtils::traverse_depth_for_quantity (book, bts::api::Side::SIDE_BUY, Quantity (7), calc_price, calc_quantity); bts_assert (calc_quantity == Quantity (0)); } SECTION("test level 2 sell") { bts::orderman2::Book book; uint16_t sizes[] = { 23, 1, 17, 19, 23 }; double prices[] = { 2500.25, 2500.75, 2501, 2502, 2503 }; fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL); SpreaderUtils::traverse_depth_for_quantity (book, bts::api::Side::SIDE_SELL, Quantity (24), calc_price, calc_quantity); bts_assert (calc_price == Price (2500.75)); bts_assert (calc_quantity == Quantity (24)); SpreaderUtils::traverse_depth_for_quantity (book, bts::api::Side::SIDE_BUY, Quantity (7), calc_price, calc_quantity); bts_assert (calc_quantity == Quantity (0)); } SECTION("test req_qty == book sell") { bts::orderman2::Book book; uint16_t sizes[] = { 23, 1, 16, 33, 27 }; double prices[] = { 2500.25, 2500.75, 2501, 2502, 2503 }; fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL); SpreaderUtils::traverse_depth_for_quantity (book, bts::api::Side::SIDE_SELL, Quantity (100), calc_price, calc_quantity); bts_assert (calc_price == Price (2503)); bts_assert (calc_quantity == Quantity (100)); SpreaderUtils::traverse_depth_for_quantity (book, bts::api::Side::SIDE_BUY, Quantity (7), calc_price, calc_quantity); bts_assert (calc_quantity == Quantity (0)); } SECTION("test req_qty > book buy") { bts::orderman2::Book book; uint16_t sizes[] = { 13, 11, 16, 33, 27 }; double prices[] = { 2500.25, 2500, 2499, 2498, 2497}; fill_book (book, prices, sizes, bts::api::Side::SIDE_BUY); SpreaderUtils::traverse_depth_for_quantity (book, bts::api::Side::SIDE_BUY, Quantity (200), calc_price, calc_quantity); bts_assert (calc_price == Price (2497)); bts_assert (calc_quantity == Quantity (100)); SpreaderUtils::traverse_depth_for_quantity (book, bts::api::Side::SIDE_SELL, Quantity (7), calc_price, calc_quantity); bts_assert (calc_quantity == Quantity (0)); } SECTION("test_5 buy") { // empty book bts::orderman2::Book book; uint16_t sizes[] = { 0, 0, 0, 0, 0 }; double prices[] = { 2500.00, 2500.25, 2500.50, 2500.75, 2501 }; fill_book (book, prices, sizes, bts::api::Side::SIDE_BUY); SpreaderUtils::traverse_depth_for_quantity (book, bts::api::Side::SIDE_BUY, Quantity (1), calc_price, calc_quantity); bts_assert (calc_quantity == Quantity (0)); SpreaderUtils::traverse_depth_for_quantity (book, bts::api::Side::SIDE_SELL, Quantity (7), calc_price, calc_quantity); bts_assert (calc_quantity == Quantity (0)); } } //this is how the spreader organizes the data TEST_CASE ("spreader bookkeeping data", "[spreader]") { bts::orderman2::OrderKey order_key(0); // constants double leg_mult_1 = -1.25, leg_mult_2 = 3.33, leg_mult_3 = -1.75; std::string symbol_1 = "ES", symbol_2 = "ZN", symbol_3 = "GC"; uint32_t sec_key_1 = 1111, sec_key_2 = 2222, sec_key_3 = 3333; double lean_ratio_1 = 1.33, lean_ratio_2 = 5.0, lean_ratio_3 = 2.75; double price_mult_1 = -2.5, price_mult_2 = 5.0, price_mult_3 = -3.33; Price spread_price (-0.35); Quantity spread_quantity (125); OrderKey order_key_1 (4), order_key_2 (22), order_key_3 (2007); // security ContractLeg leg_1, leg_2, leg_3; fill_future_contract_leg (leg_1, sec_key_1, symbol_1, bts::api::Venue::VENUE_GLBX, 2017, 12, 15, leg_mult_1, api::Side::SIDE_SELL, 1.0, 0.25); fill_future_contract_leg (leg_2, sec_key_2, symbol_2, bts::api::Venue::VENUE_GLBX, 2018, 3, 15, leg_mult_2, api::Side::SIDE_BUY, 1.0, 0.03125); fill_future_contract_leg (leg_3, sec_key_3, symbol_3, bts::api::Venue::VENUE_GLBX, 2018, 6, 15, leg_mult_3, api::Side::SIDE_SELL, 1.0, 0.05); std::vector contract_legs; contract_legs.push_back(leg_1);contract_legs.push_back(leg_2);contract_legs.push_back(leg_3); 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, price_mult_1, true, lean_ratio_1);fill_leg_spreader_params(lsp_2, price_mult_2, true, lean_ratio_2);fill_leg_spreader_params(lsp_3, price_mult_3, true, lean_ratio_3); std::vector spreader_params; spreader_params.push_back(lsp_1);spreader_params.push_back(lsp_2);spreader_params.push_back(lsp_3); bts::api::orderman2::OrderDefinition order_def; fill_spreader_order_definition(order_def, Side::SIDE_BUY, synthetic_security, spreader_params); // putting it together in SpreaderBookkeepingData TestOnlySpreaderPreActivationOrderServices testonly_spreader_pao_services = _create_spreader_pao_services(synthetic_security); SpreaderPreActivationOrderServices pao_services (&testonly_spreader_pao_services); std::vector leg_props; SpreaderUtils::resolve_synthetic_spread(pao_services, order_def, leg_props); SpreaderManagerForTest spreader_manager (order_key, pao_services, leg_props); SpreaderBookkeepingData& bookkeeping_data = spreader_manager.bookkeeping_data(); SECTION("verify security key access") { SpreaderLegData& res_3 = bookkeeping_data.get_leg_data (SecurityKey (sec_key_3)); verify_leg_data (res_3, order_key, 2, sec_key_3, 2018, 6, 15, symbol_3, leg_mult_3, price_mult_3, api::Side::SIDE_SELL); SpreaderLegData& res_2 = bookkeeping_data.get_leg_data (SecurityKey (sec_key_2)); verify_leg_data (res_2, order_key, 1, sec_key_2, 2018, 3, 15, symbol_2, leg_mult_2, price_mult_2, api::Side::SIDE_BUY); SpreaderLegData& res_1 = bookkeeping_data.get_leg_data (SecurityKey (sec_key_1)); verify_leg_data (res_1, order_key, 0, sec_key_1, 2017, 12, 15, symbol_1, leg_mult_1, price_mult_1, api::Side::SIDE_SELL); } SECTION("verify index access") { SpreaderLegData& res_3 = bookkeeping_data.get_leg_data (2); verify_leg_data (res_3, bts::orderman2::OrderKey(0), 2, sec_key_3, 2018, 6, 15, symbol_3, leg_mult_3, price_mult_3, api::Side::SIDE_SELL); SpreaderLegData& res_2 = bookkeeping_data.get_leg_data (1); verify_leg_data (res_2, bts::orderman2::OrderKey(0), 1, sec_key_2, 2018, 3, 15, symbol_2, leg_mult_2, price_mult_2, api::Side::SIDE_BUY); SpreaderLegData& res_1 = bookkeeping_data.get_leg_data (0); verify_leg_data (res_1, bts::orderman2::OrderKey(0), 0, sec_key_1, 2017, 12, 15, symbol_1, leg_mult_1, price_mult_1, api::Side::SIDE_SELL); } // // SECTION("verify order key access") // // { // // SpreaderLegData* res_3 = bookkeeping_data.find_leg_from_quoter_orderkey (order_key_3); // // bts_assert (res_3 != nullptr); // // verify_leg_data (*res_3, order_key_3, 2, sec_key_3, 2018, 6, 15, symbol_3, leg_mult_3, price_mult_3, api::Side::SIDE_SELL); // // SpreaderLegData* res_2 = bookkeeping_data.find_leg_from_quoter_orderkey (order_key_2); // // bts_assert (res_2 != nullptr); // // verify_leg_data (*res_2, order_key_2, 1, sec_key_2, 2018, 3, 15, symbol_2, leg_mult_2, price_mult_2, api::Side::SIDE_BUY); // // SpreaderLegData* res_1 = bookkeeping_data.find_leg_from_quoter_orderkey (order_key_1); // // bts_assert (res_1 != nullptr); // // verify_leg_data (*res_1, order_key_1, 0, sec_key_1, 2017, 12, 15, symbol_1, leg_mult_1, price_mult_1, api::Side::SIDE_SELL); // // } } // // quote price and quantity for a 2 legged spread TEST_CASE ("compute quoting price quantity 2 legs", "[spreader]") { Price spreader_price (1.0); Quantity spreader_quantity (10); Price out_price; Quantity out_quantity; // simple buy 1 sell 1 spreader (same ratio) ContractLeg leg_1, leg_2; SECTION("basic ") { fill_future_contract_leg (leg_1, 0, "ES", bts::api::Venue::VENUE_GLBX, 2017, 12, 15, 1, api::Side::SIDE_BUY, 1.0, 0.25); fill_future_contract_leg (leg_2, 0, "ES", bts::api::Venue::VENUE_GLBX, 2017, 3, 15, -1, api::Side::SIDE_SELL, 1.0, 0.25); LegPropertyData leg_prop_data_1 = create_leg_property_data (leg_1, 0, 1.0, true, 2.0); LegPropertyData leg_prop_data_2 = create_leg_property_data (leg_2, 1, -1.0, true, 2.0); // md bts::orderman2::Book book_1, book_2; double bid_prices_1[] = {2500.0, 2499.75, 2499.5, 2499, 2498}; uint16_t bid_sizes_1[] = {11, 25, 45, 6, 99}; double ask_prices_1[] = {2500.25, 2500.50, 2500.75, 2501, 2502}; uint16_t ask_sizes_1[] = {13, 12, 45, 5, 15}; double bid_prices_2[] = {2505.0, 2504.75, 2504, 2503.00, 2502.75}; uint16_t bid_sizes_2[] = {1, 4, 5, 20, 20}; double ask_prices_2[] = {2505.25, 2506.50, 2507, 2507.5, 2508}; uint16_t ask_sizes_2[] = {10, 4, 6, 20, 15}; fill_book (book_1, bid_prices_1, bid_sizes_1, ask_prices_1, ask_sizes_1); fill_book (book_2, bid_prices_2, bid_sizes_2, ask_prices_2, ask_sizes_2); SpreaderUtils::compute_price_quantity_2_legs (spreader_price, spreader_quantity, leg_prop_data_1, leg_prop_data_2, book_2, out_price, out_quantity); bts_assert (out_price.value() == 2504.00); bts_assert (out_quantity.value() == 10); } SECTION("lean mult") { spreader_quantity = Quantity(5); spreader_price = Price (-0.5); double lean_mult = 1.0; fill_future_contract_leg (leg_1, 0, "ES", bts::api::Venue::VENUE_GLBX, 2017, 12, 15, 1, api::Side::SIDE_BUY, 1.0, 0.25); fill_future_contract_leg (leg_2, 0, "ES", bts::api::Venue::VENUE_GLBX, 2017, 3, 15, -1, api::Side::SIDE_SELL, 1.0, 0.25); LegPropertyData leg_prop_data_1 = create_leg_property_data (leg_1, 0, 1.0, true, 1.0); LegPropertyData leg_prop_data_2 = create_leg_property_data (leg_2, 1, -1.0, true, lean_mult); // md bts::orderman2::Book book_2; double bid_prices_2[] = {2505.0, 2504.75, 2504, 2503.00, 2502.75}; uint16_t bid_sizes_2[] = {5, 10, 5, 10, 20}; double ask_prices_2[] = {2505.25, 2506.50, 2507, 2507.5, 2508}; uint16_t ask_sizes_2[] = {0, 0, 0, 0, 0}; fill_book (book_2, bid_prices_2, bid_sizes_2, ask_prices_2, ask_sizes_2); SpreaderUtils::compute_price_quantity_2_legs (spreader_price, spreader_quantity, leg_prop_data_1, leg_prop_data_2, book_2, out_price, out_quantity); bts_assert (out_price.value() == 2504.5); bts_assert (out_quantity.value() == 5); // changing lean mult lean_mult = 2.0; LegPropertyData leg_prop_data_2_lm_2 = create_leg_property_data (leg_2, 1, -1.0, true, lean_mult); SpreaderUtils::compute_price_quantity_2_legs (spreader_price, spreader_quantity, leg_prop_data_1, leg_prop_data_2_lm_2, book_2, out_price, out_quantity); bts_assert (out_price.value() == 2504.25); bts_assert (out_quantity.value() == 5); lean_mult = 5.0; LegPropertyData leg_prop_data_2_lm_5 = create_leg_property_data (leg_2, 1, -1.0, true, lean_mult); SpreaderUtils::compute_price_quantity_2_legs (spreader_price, spreader_quantity, leg_prop_data_1, leg_prop_data_2_lm_5, book_2, out_price, out_quantity); bts_assert (out_price.value() == 2502.5); bts_assert (out_quantity.value() == 5); lean_mult = 9.0; LegPropertyData leg_prop_data_2_lm_9 = create_leg_property_data (leg_2, 1, -1.0, true, lean_mult); SpreaderUtils::compute_price_quantity_2_legs (spreader_price, spreader_quantity, leg_prop_data_1, leg_prop_data_2_lm_9, book_2, out_price, out_quantity); bts_assert (out_price.value() == 2502.25); bts_assert (out_quantity.value() == 5); lean_mult = 10.0; LegPropertyData leg_prop_data_2_lm_10 = create_leg_property_data (leg_2, 1, -1.0, true, lean_mult); SpreaderUtils::compute_price_quantity_2_legs (spreader_price, spreader_quantity, leg_prop_data_1, leg_prop_data_2_lm_10, book_2, out_price, out_quantity); bts_assert (out_price.value() == 2502.25); bts_assert (out_quantity.value() == 5); // with a large lean mult, make the leg 2 qty req exhaust the book lean_mult = 20.0; LegPropertyData leg_prop_data_2_lm_20 = create_leg_property_data (leg_2, 1, -1.0, true, lean_mult); SpreaderUtils::compute_price_quantity_2_legs (spreader_price, spreader_quantity, leg_prop_data_1, leg_prop_data_2_lm_20, book_2, out_price, out_quantity); bts_assert (out_price.value() == 2502.25); bts_assert (out_quantity.value() == 3); // TODO:check // fractional leg mults lean_mult = 1.5; LegPropertyData leg_prop_data_2_lm_1_5 = create_leg_property_data (leg_2, 1, -1.0, true, lean_mult); SpreaderUtils::compute_price_quantity_2_legs (spreader_price, spreader_quantity, leg_prop_data_1, leg_prop_data_2_lm_1_5, book_2, out_price, out_quantity); bts_assert (out_price.value() == 2504.25); bts_assert (out_quantity.value() == 5); lean_mult = 4.3333; LegPropertyData leg_prop_data_2_lm_3_33 = create_leg_property_data (leg_2, 1, -1.0, true, lean_mult); SpreaderUtils::compute_price_quantity_2_legs (spreader_price, spreader_quantity, leg_prop_data_1, leg_prop_data_2_lm_3_33, book_2, out_price, out_quantity); bts_assert (out_price.value() == 2502.5); bts_assert (out_quantity.value() == 5); } SECTION("fractional leg mult ") { spreader_quantity = Quantity(10); spreader_price = Price (0.5); double mult_1 = 0.25, mult_2 = -1.1; // same used for price and qty double lean_mult = 1.0; fill_future_contract_leg (leg_1, 0, "ES", bts::api::Venue::VENUE_GLBX, 2017, 12, 15, mult_1, api::Side::SIDE_BUY, 1.0, 0.25); fill_future_contract_leg (leg_2, 0, "ES", bts::api::Venue::VENUE_GLBX, 2017, 3, 15, mult_2, api::Side::SIDE_SELL, 1.0, 0.25); LegPropertyData leg_prop_data_1 = create_leg_property_data (leg_1, 0, mult_1, true, lean_mult); LegPropertyData leg_prop_data_2 = create_leg_property_data (leg_2, 1, mult_2, true, lean_mult); // md bts::orderman2::Book book_1, book_2; double bid_prices_2[] = {2500.0, 2499.75, 2499.5, 2499, 2498};uint16_t bid_sizes_2[] = {5, 4, 1, 6, 99}; double ask_prices_2[] = {2500.25, 2500.50, 2500.75, 2501, 2502};uint16_t ask_sizes_2[] = {13, 12, 45, 5, 15}; fill_book (book_2, bid_prices_2, bid_sizes_2, ask_prices_2, ask_sizes_2); SpreaderUtils::compute_price_quantity_2_legs (spreader_price, Quantity(3), leg_prop_data_1, leg_prop_data_2, book_2, out_price, out_quantity); bts_assert (out_price.value() == 10997.5); bts_assert (out_quantity.value() == 3); } SECTION("price mult") { spreader_quantity = Quantity(10); spreader_price = Price (0.5); double size_mult_1 = 0.25, size_mult_2 = -1.1, // same used for price and qty price_mult_1 = 0.35, price_mult_2 = -1.5; double lean_mult = 1.0; fill_future_contract_leg (leg_1, 0, "ES", bts::api::Venue::VENUE_GLBX, 2017, 12, 15, size_mult_1, api::Side::SIDE_BUY, 1.0, 0.25); fill_future_contract_leg (leg_2, 0, "ES", bts::api::Venue::VENUE_GLBX, 2017, 3, 15, size_mult_2, api::Side::SIDE_SELL, 1.0, 0.25); LegPropertyData leg_prop_data_1 = create_leg_property_data (leg_1, 0, price_mult_1, true, lean_mult); LegPropertyData leg_prop_data_2 = create_leg_property_data (leg_2, 1, price_mult_2, true, lean_mult); // md bts::orderman2::Book book_1, book_2; double bid_prices_2[] = {2500.0, 2499.75, 2499.5, 2499, 2498};uint16_t bid_sizes_2[] = {5, 4, 1, 6, 99}; double ask_prices_2[] = {2500.25, 2500.50, 2500.75, 2501, 2502};uint16_t ask_sizes_2[] = {13, 12, 45, 5, 15}; fill_book (book_2, bid_prices_2, bid_sizes_2, ask_prices_2, ask_sizes_2); SpreaderUtils::compute_price_quantity_2_legs (spreader_price, Quantity(3), leg_prop_data_1, leg_prop_data_2, book_2, out_price, out_quantity); bts_assert (out_price.value() == 10711.25); bts_assert (out_quantity.value() == 3); } } TEST_CASE ("compute hedge price quantity 2 legs", "[spreader]") { ContractLeg leg_1, leg_2; Price out_hedge_price; Quantity out_hedge_quantity; Price spreader_price = Price (0.35); double size_mult_1 = 0.25, size_mult_2 = -1.1, // same used for price and qty price_mult_1 = 0.35, price_mult_2 = -1.5; double lean_mult = 1.0; fill_future_contract_leg (leg_1, 0, "ES", bts::api::Venue::VENUE_GLBX, 2017, 12, 15, size_mult_1, api::Side::SIDE_BUY, 1.0, 0.25); fill_future_contract_leg (leg_2, 0, "ES", bts::api::Venue::VENUE_GLBX, 2017, 3, 15, size_mult_2, api::Side::SIDE_SELL, 1.0, 0.25); LegPropertyData leg_prop_data_1 = create_leg_property_data (leg_1, 0, price_mult_1, true, lean_mult); LegPropertyData leg_prop_data_2 = create_leg_property_data (leg_2, 1, price_mult_2, true, lean_mult); // md SpreaderUtils::compute_hedge_price_size_2_legs (spreader_price, leg_prop_data_2, Price (2500.5), Quantity (3), leg_prop_data_1, out_hedge_price, out_hedge_quantity); bts_assert (out_hedge_quantity.value() == 1); bts_assert (out_hedge_price.value() == 10717.25); SpreaderUtils::compute_hedge_price_size_2_legs (spreader_price, leg_prop_data_2, Price (2500.5), Quantity (2), leg_prop_data_1, out_hedge_price, out_hedge_quantity); bts_assert (out_hedge_quantity.value() == 0); bts_assert (out_hedge_price.value() == 10717.25); // reversing the side of the quote fill SpreaderUtils::compute_hedge_price_size_2_legs (spreader_price, leg_prop_data_1, Price (10000.5), Quantity (2), leg_prop_data_2, out_hedge_price, out_hedge_quantity); bts_assert (out_hedge_quantity.value() == 9); bts_assert (out_hedge_price.value() == 2333.25); SpreaderUtils::compute_hedge_price_size_2_legs (spreader_price, leg_prop_data_1, Price (9997), Quantity (6), leg_prop_data_2, out_hedge_price, out_hedge_quantity); bts_assert (out_hedge_quantity.value() == 26); bts_assert (out_hedge_price.value() == 2332.5); } /************************************************************************************************************/ /*********************************************Quoter State Tests*********************************************/ /************************************************************************************************************/ TEST_CASE ("quoter_START_state", "[spreader]") { bts::orderman2::OrderKey spreader_order_key(0); Price spreader_price = Price (0.35); Quantity spreader_quantity (100); SpreaderManagerForTest* sm = create_spreader_manager_2_legs (spreader_order_key, bts::api::Venue::VENUE_GLBX, "ES", 2017, 12, 15, 1.0, 1.0, 1.0, api::Side::SIDE_BUY, 1.0, 0.25, bts::api::Venue::VENUE_GLBX, "ES", 2017, 3, 15, 1.0, -1.0, 1.0, api::Side::SIDE_SELL, 1.0, 0.25); SpreaderBookkeepingData& bookeeping_data = sm->bookkeeping_data(); SingleLegQuoter& quoter = bookeeping_data.get_leg_data(1).quoter(); SECTION("0. transition_to_start") { verify_complete_quoter_state (quoter, QuoterState::START, false, Price(0), Quantity(0), Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (0), true); LOG(OrderMan, Diag, "quoter_START_state.transition_to_start"); } SECTION("1. one_time_activate") { verify_complete_quoter_state (quoter, QuoterState::START, false, Price(0), Quantity(0), Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (0), true); quoter.one_time_activate (spreader_price, spreader_quantity); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_SIZE, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (100), false); LOG(OrderMan, Diag, "quoter_START_state.init"); } SECTION("4. cancel_order") { verify_complete_quoter_state (quoter, QuoterState::START, false, Price(0), Quantity(0), Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (0), true); quoter.cancel_order(); verify_complete_quoter_state (quoter, QuoterState::END, true, Price(0), Quantity(0), Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (0), true); LOG(OrderMan, Diag, "quoter_START_state.cancel_order"); } SECTION("5. terminate") { verify_complete_quoter_state (quoter, QuoterState::START, false, Price(0), Quantity(0), Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (0), true); quoter.terminate(); verify_complete_quoter_state (quoter, QuoterState::END, true, Price(0), Quantity(0), Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (0), true); LOG(OrderMan, Diag, "quoter_START_state.terminate"); } SECTION("7. update_other_leg_fills") { verify_complete_quoter_state (quoter, QuoterState::START, false, Price(0), Quantity(0), Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (0), true); quoter.update_other_leg_fills (0, Quantity(50)); verify_complete_quoter_state (quoter, QuoterState::START, false, Price(0), Quantity(0), Quantity(0), Quantity(50), Price(0), Quantity(0), Quantity (0), true); // another fill quoter.update_other_leg_fills (0, Quantity(25)); verify_complete_quoter_state (quoter, QuoterState::START, false, Price(0), Quantity(0), Quantity(0), Quantity(75), Price(0), Quantity(0), Quantity (0), true); } SECTION("8. update_order_price_quantity") { verify_complete_quoter_state (quoter, QuoterState::START, false, Price(0), Quantity(0), Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (0), true); spreader_price = Price (0.5); spreader_quantity = Quantity (200); quoter.update_order_price_quantity (spreader_price, spreader_quantity); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_SIZE, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (200), false); LOG(OrderMan, Diag, "quoter_START_state.update_order_price_quantity"); } } TEST_CASE ("quoter_WAITING_FOR_SIZE_state", "[spreader]") { bts::orderman2::OrderKey spreader_order_key(0); Price spreader_price = Price (0.35); Quantity spreader_quantity (100); SpreaderManagerForTest* sm_ptr = create_spreader_manager_2_legs (spreader_order_key, bts::api::Venue::VENUE_GLBX, "ES", 2017, 12, 15, 1.0, 1.0, 1.0, api::Side::SIDE_BUY, 1.0, 0.25, bts::api::Venue::VENUE_GLBX, "ES", 2017, 3, 15, 1.0, -1.0, 1.0, api::Side::SIDE_SELL, 1.0, 0.25); SpreaderBookkeepingData& bookeeping_data = sm_ptr->bookkeeping_data(); SpreaderManagerForTest& sm = *sm_ptr; SingleLegQuoter& quoter = bookeeping_data.get_leg_data(1).quoter(); quoter.one_time_activate (spreader_price, spreader_quantity); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_SIZE, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (100), false); SECTION("3. on_book_zero") { // 0 size md update, it should keep waiting // buying the spread => sell leg 2 => buy leg 1 => leg 1's sell market double prices[] = {0, 0, 0, 0, 0}; uint16_t sizes[] = {0, 0, 0, 0, 0}; fire_book_update (prices, sizes, api::Side::SIDE_SELL, 0, sm, quoter); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_SIZE, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (100), false); LOG(OrderMan, Diag, "quoter_WAITING_FOR_SIZE_state.on_book_zero success"); } SECTION("3. on_book_less_size_than_total") { double prices[] = {2000, 2000.25, 2000.5, 2000.75, 2002}; uint16_t sizes[] = {10, 5, 15, 5, 25}; //60 fire_book_update (prices, sizes, api::Side::SIDE_SELL, 0, sm, quoter); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2001.75), Quantity(60), Quantity (100), false); LOG(OrderMan, Diag, "quoter_WAITING_FOR_SIZE_state.on_book_less_size_than_total"); } SECTION("3. on_book_more_size_than_total") { double prices[] = {2000, 2001, 0, 0, 0}; uint16_t sizes[] = {60, 55, 0, 0, 0}; fire_book_update (prices, sizes, api::Side::SIDE_SELL, 0, sm, quoter); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.75), Quantity(100), Quantity (100), false); LOG(OrderMan, Diag, "quoter_WAITING_FOR_SIZE_state.on_book_more_size_than_total"); } SECTION("4. cancel_order") { quoter.cancel_order(); verify_complete_quoter_state (quoter, QuoterState::END, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), spreader_quantity, false); LOG(OrderMan, Diag, "quoter_WAITING_FOR_SIZE_state.cancel_order"); } SECTION("5. terminate") { quoter.terminate(); verify_complete_quoter_state (quoter, QuoterState::END, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), spreader_quantity, false); LOG(OrderMan, Diag, "quoter_WAITING_FOR_SIZE_state.cancel_order"); } SECTION("7. update_other_leg_fills") { quoter.update_other_leg_fills (0, Quantity(50)); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_SIZE, false, spreader_price, spreader_quantity, Quantity(0), Quantity(50), Price(0), Quantity(0), Quantity(50), false); // another fill quoter.update_other_leg_fills (0, Quantity(25)); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_SIZE, false, spreader_price, spreader_quantity, Quantity(0), Quantity(75), Price(0), Quantity(0), Quantity(25), false); // completely fill the other side quoter.update_other_leg_fills (0, Quantity(25)); verify_complete_quoter_state (quoter, QuoterState::END, false, spreader_price, spreader_quantity, Quantity(0), Quantity(100), Price(0), Quantity(0), Quantity(0), true); LOG(OrderMan, Diag, "quoter_WAITING_FOR_SIZE_state.update_other_leg_fills"); } SECTION("8. update_order_price_quantity") { spreader_price = Price (0.5); spreader_quantity = Quantity (200); quoter.update_order_price_quantity (spreader_price, spreader_quantity); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_SIZE, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), spreader_quantity, false); // on zero size, it should go to end state spreader_price = Price (0.5); spreader_quantity = Quantity (0); quoter.update_order_price_quantity (spreader_price, spreader_quantity); verify_complete_quoter_state (quoter, QuoterState::END, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity(0), true); LOG(OrderMan, Diag, "quoter_WAITING_FOR_SIZE_state.update_order_price_quantity"); } } TEST_CASE ("quoter_WAITING_FOR_FIRT_ACK", "[spreader]") { bts::orderman2::OrderKey spreader_order_key(0); Price spreader_price = Price (0.35); Quantity spreader_quantity (100); SpreaderManagerForTest* sm_ptr = create_spreader_manager_2_legs (spreader_order_key, bts::api::Venue::VENUE_GLBX, "ES", 2017, 12, 15, 1.0, 1.0, 1.0, api::Side::SIDE_BUY, 1.0, 0.25, bts::api::Venue::VENUE_GLBX, "ES", 2017, 3, 15, 1.0, -1.0, 1.0, api::Side::SIDE_SELL, 1.0, 0.25); SpreaderBookkeepingData& bookeeping_data = sm_ptr->bookkeeping_data(); SpreaderManagerForTest& sm = *sm_ptr; SingleLegQuoter& quoter = bookeeping_data.get_leg_data(1).quoter(); quoter.one_time_activate(spreader_price, spreader_quantity); double prices[] = {2000, 2001, 0, 0, 0}; uint16_t sizes[] = {60, 55, 0, 0, 0}; fire_book_update (prices, sizes, api::Side::SIDE_SELL, 0, sm, quoter); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.75), Quantity(100), Quantity (100), false); SECTION("2. update_order_status_non_terminal") { SpreaderChildOrderState u = create_order_update (); u.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (70), Price (2000)); quoter.update_order_status(u); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(70), Quantity(0), Price(2000.75), Quantity(100), Quantity (30), false); LOG(OrderMan, Diag, "quoter_WAITING_FOR_FIRT_ACK.update_order_status_non_terminal"); } SECTION("3. update_order_status_terminal") { SpreaderChildOrderState u = create_order_update (); u.update (api::orderman2::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (100), Price (2000)); quoter.update_order_status(u); verify_complete_quoter_state (quoter, QuoterState::END, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (0), true); LOG(OrderMan, Diag, "quoter_WAITING_FOR_FIRT_ACK.update_order_status_terminal"); } SECTION("3. on_book") { // orders are not updated in this state double prices[] = {0, 0, 0, 0, 0}; uint16_t sizes[] = {0, 0, 0, 0, 0}; fire_book_update (prices, sizes, api::Side::SIDE_SELL, 0, sm, quoter); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.75), Quantity(100), Quantity (100), false); LOG(OrderMan, Diag, "quoter_WAITING_FOR_FIRT_ACK.on_book"); } SECTION("4. cancel_order") { quoter.cancel_order(); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK_CANCELLED, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.75), Quantity(100), Quantity (100), false); LOG(OrderMan, Diag, "quoter_WAITING_FOR_FIRT_ACK.cancel_order"); } SECTION("5. terminate") { quoter.terminate (); verify_complete_quoter_state (quoter, QuoterState::END, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.75), Quantity(100), Quantity (100), false); LOG(OrderMan, Diag, "quoter_WAITING_FOR_FIRT_ACK.terminate"); } SECTION("7. update_other_leg_fills") { quoter.update_other_leg_fills (0, Quantity(50)); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, spreader_quantity, Quantity(0), Quantity(50), Price(2000.75), Quantity(100), Quantity (50), false); // another fill quoter.update_other_leg_fills (0, Quantity(25)); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, spreader_quantity, Quantity(0), Quantity(75), Price(2000.75), Quantity(100), Quantity (25), false); // completely fill the other side quoter.update_other_leg_fills (0, Quantity(25)); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK_CANCELLED, false, spreader_price, spreader_quantity, Quantity(0), Quantity(100), Price(2000.75), Quantity(100), Quantity (0), true); LOG(OrderMan, Diag, "quoter_WAITING_FOR_FIRT_ACK.update_other_leg_fills"); } SECTION("8. update_order_price_quantity") { spreader_price = Price(0.5); spreader_quantity = Quantity (125); quoter.update_order_price_quantity (spreader_price, spreader_quantity); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.75), Quantity(100), spreader_quantity, false); // other leg fill quoter.update_other_leg_fills (0, Quantity(50)); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, spreader_quantity, Quantity(0), Quantity(50), Price(2000.75), Quantity(100), Quantity (75), false); // on zero size, it should go to end state spreader_price = Price (0.5); spreader_quantity = Quantity (50); quoter.update_order_price_quantity (spreader_price, spreader_quantity); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK_CANCELLED, false, spreader_price, spreader_quantity, Quantity(0), Quantity(50), Price(2000.75), Quantity(100), Quantity (0), true); LOG(OrderMan, Diag, "quoter_WAITING_FOR_FIRT_ACK.update_order_price_quantity"); } } TEST_CASE ("quoter_WAITING_FOR_FIRT_ACK_CANCELLED", "[spreader]") { bts::orderman2::OrderKey spreader_order_key(0); Price spreader_price = Price (0.35); Quantity spreader_quantity (100); SpreaderManagerForTest* sm_ptr = create_spreader_manager_2_legs (spreader_order_key, bts::api::Venue::VENUE_GLBX, "ES", 2017, 12, 15, 1.0, 1.0, 1.0, api::Side::SIDE_BUY, 1.0, 0.25, bts::api::Venue::VENUE_GLBX, "ES", 2017, 3, 15, 1.0, -1.0, 1.0, api::Side::SIDE_SELL, 1.0, 0.25); SpreaderBookkeepingData& bookeeping_data = sm_ptr->bookkeeping_data(); SpreaderManagerForTest& sm = *sm_ptr; SingleLegQuoter& quoter = bookeeping_data.get_leg_data(1).quoter(); quoter.one_time_activate(spreader_price, spreader_quantity); double prices[] = {2000, 2001, 0, 0, 0}; uint16_t sizes[] = {60, 55, 0, 0, 0}; fire_book_update (prices, sizes, api::Side::SIDE_SELL, 0, sm, quoter); quoter.cancel_order (); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK_CANCELLED, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.75), Quantity(100), Quantity (100), false); SECTION("2. update_order_status_non_terminal") { SpreaderChildOrderState u = create_order_update (); u.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (70), Price (2000)); quoter.update_order_status(u); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, spreader_quantity, Quantity(70), Quantity(0), Price(2000.75), Quantity(100), Quantity(30), false); LOG(OrderMan, Diag, "quoter_WAITING_FOR_FIRT_ACK_CANCELLED.update_order_status_non_terminal"); } SECTION("2. update_order_status_terminal") { SpreaderChildOrderState u = create_order_update (); u.update (api::orderman2::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (100), Price (2000)); quoter.update_order_status(u); verify_complete_quoter_state (quoter, QuoterState::END, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity(0), true); LOG(OrderMan, Diag, "quoter_WAITING_FOR_FIRT_ACK_CANCELLED.update_order_status_terminal"); } SECTION("3. on_book") { double prices[] = {0, 0, 0, 0, 0}; uint16_t sizes[] = {0, 0, 0, 0, 0}; fire_book_update (prices, sizes, api::Side::SIDE_SELL, 0, sm, quoter); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK_CANCELLED, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.75), Quantity(100), Quantity (100), false); LOG(OrderMan, Diag, "quoter_WAITING_FOR_FIRT_ACK_CANCELLED.on_book"); } SECTION("4. cancel_order") { quoter.cancel_order(); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK_CANCELLED, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.75), Quantity(100), Quantity (100), false); LOG(OrderMan, Diag, "quoter_WAITING_FOR_FIRT_ACK_CANCELLED.cancel_order"); } SECTION("5. terminate") { quoter.terminate (); verify_complete_quoter_state (quoter, QuoterState::END, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.75), Quantity(100), Quantity (100), false); LOG(OrderMan, Diag, "quoter_WAITING_FOR_FIRT_ACK_CANCELLED.terminate"); } SECTION("7. update_other_leg_fills") { quoter.update_other_leg_fills (0, Quantity(50)); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK_CANCELLED, true, spreader_price, spreader_quantity, Quantity(0), Quantity(50), Price(2000.75), Quantity(100), Quantity (50), false); // another fill quoter.update_other_leg_fills (0, Quantity(25)); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK_CANCELLED, true, spreader_price, spreader_quantity, Quantity(0), Quantity(75), Price(2000.75), Quantity(100), Quantity (25), false); // completely fill the other side quoter.update_other_leg_fills (0, Quantity(25)); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK_CANCELLED, true, spreader_price, spreader_quantity, Quantity(0), Quantity(100), Price(2000.75), Quantity(100), Quantity (0), true); LOG(OrderMan, Diag, "quoter_WAITING_FOR_FIRT_ACK_CANCELLED.update_other_leg_fills"); } SECTION("8. update_order_price_quantity") { spreader_price = Price (0.5); spreader_quantity = Quantity (200); quoter.update_order_price_quantity (spreader_price, spreader_quantity); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK_CANCELLED, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.75), Quantity(100), Quantity (200), false); spreader_price = Price (0.5); spreader_quantity = Quantity (0); quoter.update_order_price_quantity (spreader_price, spreader_quantity); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK_CANCELLED, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.75), Quantity(100), Quantity (0), true); LOG(OrderMan, Diag, "quoter_WAITING_FOR_FIRT_ACK_CANCELLED.update_order_price_quantity"); } } TEST_CASE ("quoter_WAITING_FOR_CANCEL_ACK", "[spreader]") { bts::orderman2::OrderKey spreader_order_key(0); Price spreader_price = Price (0.35); Quantity spreader_quantity (100); SpreaderManagerForTest* sm_ptr = create_spreader_manager_2_legs (spreader_order_key, bts::api::Venue::VENUE_GLBX, "ES", 2017, 12, 15, 1.0, 1.0, 1.0, api::Side::SIDE_BUY, 1.0, 0.25, bts::api::Venue::VENUE_GLBX, "ES", 2017, 3, 15, 1.0, -1.0, 1.0, api::Side::SIDE_SELL, 1.0, 0.25); SpreaderBookkeepingData& bookeeping_data = sm_ptr->bookkeeping_data(); SpreaderManagerForTest& sm = *sm_ptr; SingleLegQuoter& quoter = bookeeping_data.get_leg_data(1).quoter(); quoter.one_time_activate(spreader_price, spreader_quantity); double prices[] = {2000, 2001, 0, 0, 0}; uint16_t sizes[] = {60, 55, 0, 0, 0}; fire_book_update (prices, sizes, api::Side::SIDE_SELL, 0, sm, quoter); quoter.cancel_order (); SpreaderChildOrderState u = create_order_update (); u.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0)); quoter.update_order_status(u); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.75), Quantity(100), Quantity(100), false); SECTION("2. update_order_status_non_terminal") { u.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (70), Price (2000)); quoter.update_order_status(u); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, spreader_quantity, Quantity(70), Quantity(0), Price(2000.75), Quantity(100), Quantity(30), false); LOG(OrderMan, Diag, "quoter_WAITING_FOR_CANCEL_ACK.update_order_status_non_terminal"); } SECTION("2. update_order_status_terminal") { u.update (api::orderman2::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (100), Price (2000)); quoter.update_order_status(u); verify_complete_quoter_state (quoter, QuoterState::END, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity(0), true); LOG(OrderMan, Diag, "quoter_WAITING_FOR_CANCEL_ACK.update_order_status_terminal"); } SECTION("3. on_book") { double zero_prices[] = {0, 0, 0, 0, 0}; uint16_t zero_sizes[] = {0, 0, 0, 0, 0}; fire_book_update (prices, sizes, api::Side::SIDE_SELL, 1, sm, quoter); // any bts_assert (quoter.test_only_func_quoter_state () == QuoterState::WAITING_FOR_CANCEL_ACK); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.75), Quantity(100), Quantity(100), false); LOG(OrderMan, Diag, "quoter_WAITING_FOR_CANCEL_ACK.on_book"); } SECTION("4. cancel_order") { quoter.cancel_order(); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.75), Quantity(100), Quantity(100), false); LOG(OrderMan, Diag, "quoter_WAITING_FOR_CANCEL_ACK.cancel_order"); } SECTION("5. terminate") { quoter.terminate (); verify_complete_quoter_state (quoter, QuoterState::END, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.75), Quantity(100), Quantity(100), false); LOG(OrderMan, Diag, "quoter_WAITING_FOR_CANCEL_ACK.terminate"); } SECTION("7. update_other_leg_fills") { quoter.update_other_leg_fills (0, Quantity(10)); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, spreader_quantity, Quantity(0), Quantity(10), Price(2000.75), Quantity(100), Quantity(90), false); // another fill quoter.update_other_leg_fills (0, Quantity(50)); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, spreader_quantity, Quantity(0), Quantity(60), Price(2000.75), Quantity(100), Quantity(40), false); // completely fill quoter.update_other_leg_fills (0, Quantity(40)); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, spreader_quantity, Quantity(0), Quantity(100), Price(2000.75), Quantity(100), Quantity(0), true); LOG(OrderMan, Diag, "quoter_WAITING_FOR_CANCEL_ACK.update_other_leg_fills"); } SECTION("8. update_order_price_quantity") { spreader_price = Price (0.5); spreader_quantity = Quantity (200); quoter.update_order_price_quantity (spreader_price, spreader_quantity); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.75), Quantity(100), spreader_quantity, false); // on zero size, it should go to end state spreader_price = Price (0.5); spreader_quantity = Quantity (0); quoter.update_order_price_quantity (spreader_price, spreader_quantity); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.75), Quantity(100), spreader_quantity, true); LOG(OrderMan, Diag, "quoter_WAITING_FOR_CANCEL_ACK.update_order_price_quantity"); } } TEST_CASE ("quoter_END", "[spreader]") { bts::orderman2::OrderKey spreader_order_key(0); Price spreader_price = Price (0.35); Quantity spreader_quantity (100); SpreaderManagerForTest* sm_ptr = create_spreader_manager_2_legs (spreader_order_key, bts::api::Venue::VENUE_GLBX, "ES", 2017, 12, 15, 1.0, 1.0, 1.0, api::Side::SIDE_BUY, 1.0, 0.25, bts::api::Venue::VENUE_GLBX, "ES", 2017, 3, 15, 1.0, -1.0, 1.0, api::Side::SIDE_SELL, 1.0, 0.25); SpreaderBookkeepingData& bookeeping_data = sm_ptr->bookkeeping_data(); SpreaderManagerForTest& sm = *sm_ptr; SingleLegQuoter& quoter = bookeeping_data.get_leg_data(1).quoter(); quoter.one_time_activate(spreader_price, spreader_quantity); double prices[] = {2000, 2001, 0, 0, 0}; uint16_t sizes[] = {50, 25, 0, 0, 0}; fire_book_update (prices, sizes, api::Side::SIDE_SELL, 0, sm, quoter); // the end state is different than the others. it takes action // on entry, and either goes back to WAITING_FOR_SIZE or stays // in END permenantly SECTION("partially_filled_terminal_state") { // this should go back to waiting for size // since the 75 lot of filled but the // target is 100 verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, spreader_quantity, Quantity(0), Quantity (0), Price (2000.75), Quantity (75), spreader_quantity, false); // setting md to 0, so it doesnt submit an order immediatly double zero_prices[] = {2000, 2001, 0, 0, 0}; uint16_t zero_sizes[] = {0, 0, 0, 0, 0}; fire_book_update (zero_prices, zero_sizes, api::Side::SIDE_SELL, 0, sm, quoter); // fill the working lot SpreaderChildOrderState u = create_order_update (); u.update (api::orderman2::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (75), Price (2000)); quoter.update_order_status(u); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_SIZE, false, spreader_price, spreader_quantity, Quantity(0), Quantity (0), Price (0), Quantity (0), Quantity(25), false); LOG(OrderMan, Diag, "quoter_END.partially_filled_terminal_state"); } SECTION("completely_filled_terminal_state") { // this should back to waiting for size // since the 75 lot of filled but the // target is 100 verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, spreader_quantity, Quantity(0), Quantity (0), Price (2000.75), Quantity (75), spreader_quantity, false); // changing size to 75, so that a fill on the order can completely fill it // setting md to 0, so it doesnt submit an order immediatly spreader_quantity = Quantity (75); quoter.update_order_price_quantity (spreader_price, spreader_quantity); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, spreader_quantity, Quantity(0), Quantity (0), Price (2000.75), Quantity (75), spreader_quantity, false); SpreaderChildOrderState u = create_order_update (); u.update (api::orderman2::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (75), Price (2000)); quoter.update_order_status(u); verify_complete_quoter_state (quoter, QuoterState::END, false, spreader_price, spreader_quantity, Quantity(0), Quantity (0), Price (0), Quantity (0), Quantity(0), true); LOG(OrderMan, Diag, "quoter_END.completely_filled_terminal_state"); } SECTION("terminate_terminal_state") { // this should back to waiting for size // since the 75 lot of filled but the // target is 100 verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, spreader_quantity, Quantity(0), Quantity (0), Price (2000.75), Quantity (75), spreader_quantity, false); quoter.terminate (); verify_complete_quoter_state (quoter, QuoterState::END, true, spreader_price, spreader_quantity, Quantity(0), Quantity (0), Price (2000.75), Quantity (75), spreader_quantity, false); LOG(OrderMan, Diag, "quoter_END.terminate_terminal_state"); } } TEST_CASE ("quoter_WORKING", "[spreader]") { bts::orderman2::OrderKey spreader_order_key(0); Price spreader_price = Price (0.5); Quantity spreader_quantity (100); SpreaderManagerForTest* sm_ptr = create_spreader_manager_2_legs (spreader_order_key, bts::api::Venue::VENUE_GLBX, "ES", 2017, 12, 15, 1.0, 1.0, 1.0, api::Side::SIDE_BUY, 1.0, 0.25, bts::api::Venue::VENUE_GLBX, "ES", 2017, 3, 15, 1.0, -1.0, 1.0, api::Side::SIDE_SELL, 1.0, 0.25); SpreaderBookkeepingData& bookeeping_data = sm_ptr->bookkeeping_data(); SpreaderManagerForTest& sm = *sm_ptr; SingleLegQuoter& quoter = bookeeping_data.get_leg_data(1).quoter(); quoter.one_time_activate(spreader_price, spreader_quantity); double prices[] = {2000.0, 2000.25, 2000.5, 2000.75, 2001.0}; uint16_t sizes[] = {5, 10, 4, 6, 15}; fire_book_update (prices, sizes, api::Side::SIDE_SELL, 0, sm, quoter); SpreaderChildOrderState u = create_order_update (); u.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0)); quoter.update_order_status (u); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.5), Quantity(40), Quantity (100), false); SECTION("2. reduced_size_update_order_status_non_terminal") { // partial fills u.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (15), Price (2000)); quoter.update_order_status (u); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(15), Quantity(0), Price(2000.5), Quantity(55), Quantity (85), false); LOG(OrderMan, Diag, "quoter_WORKING.reduced_size_update_order_status_non_terminal"); } SECTION("2. reduced_size_update_order_status_terminal") { // complete fill, should go to end, and then to waiting_for_size. // a tick here would make it send an order u.update (api::orderman2::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (40), Price (2000)); quoter.update_order_status (u); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_SIZE, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (60), false); LOG(OrderMan, Diag, "quoter_WORKING.reduced_size_update_order_status_terminal"); } SECTION("2. full_size_update_order_status_non_terminal") { // change book to accomodate full size double prices_full[] = {2000.0, 2000.25, 2000.5, 2000.75, 2001.0}; uint16_t sizes_full[] = {10, 30, 25, 15, 20}; fire_book_update (prices_full, sizes_full, api::Side::SIDE_SELL, 0, sm, quoter); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.50), Quantity(100), Quantity (100), false); // send out a fill u.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (20), Price (2000)); quoter.update_order_status (u); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(20), Quantity(0), Price(2000.25), Quantity(100), Quantity (80), false); LOG(OrderMan, Diag, "quoter_WORKING.full_size_update_order_status_non_terminal"); } SECTION("3. on_book") { // to piggy back on the book test, the base // is set as a partial fill of 10, and a hedge // reduction of 15 u.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (10), Price (2000)); quoter.update_order_status (u); quoter.update_other_leg_fills (0, Quantity (15)); double prices_full_0[] = {2000.0, 2000.25, 2000.5, 2000.75, 2001.0}; uint16_t sizes_full_0[] = {10, 30, 25, 15, 20}; fire_book_update (prices_full_0, sizes_full_0, api::Side::SIDE_SELL, 0, sm, quoter); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(10), Quantity(15), Price(2000.25), Quantity(85), Quantity (75), false); // change the book and validate the price (full qty) double prices_full_1[] = {2000.0, 2000.25, 2000.5, 2000.75, 2001.0}; uint16_t sizes_full_1[] = {75, 0, 0, 0, 0}; fire_book_update (prices_full_1, sizes_full_1, api::Side::SIDE_SELL, 0, sm, quoter); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(10), Quantity(15), Price(1999.5), Quantity(85), Quantity (75), false); // change the book and validate the price again (full qty) double prices_full_2[] = {2005.0, 2006, 2007, 2008, 2009}; uint16_t sizes_full_2[] = {1, 1, 1, 1, 71}; fire_book_update (prices_full_2, sizes_full_2, api::Side::SIDE_SELL, 0, sm, quoter); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(10), Quantity(15), Price(2008.5), Quantity(85), Quantity (75), false); LOG(OrderMan, Diag, "quoter_WORKING.on_book"); // and again double prices_full_3[] = {2000.0, 2001, 2002, 2003, 2004}; uint16_t sizes_full_3[] = {1, 1, 70, 2, 1}; fire_book_update (prices_full_3, sizes_full_3, api::Side::SIDE_SELL, 0, sm, quoter); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(10), Quantity(15), Price(2003.5), Quantity(85), Quantity (75), false); LOG(OrderMan, Diag, "quoter_WORKING.on_book"); // now decrease the size in book so the full // target remaining (75) is not there, this should // result in a reduced order double prices_full_4[] = {2000.0, 2001, 2002, 2003, 2004}; uint16_t sizes_full_4[] = {1, 1, 1, 1, 26}; fire_book_update (prices_full_4, sizes_full_4, api::Side::SIDE_SELL, 0, sm, quoter); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(10), Quantity(15), Price(2003.5), Quantity(40), Quantity (75), false); LOG(OrderMan, Diag, "quoter_WORKING.on_book"); // another reduced size double prices_full_5[] = {2000.0, 2001, 2002, 2003, 2004}; uint16_t sizes_full_5[] = {1, 0, 0, 0, 0}; fire_book_update (prices_full_5, sizes_full_5, api::Side::SIDE_SELL, 0, sm, quoter); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(10), Quantity(15), Price(1999.5), Quantity(11), Quantity (75), false); LOG(OrderMan, Diag, "quoter_WORKING.on_book"); // and another ... double prices_full_6[] = {2000.0, 2001, 2002, 2003, 2004}; uint16_t sizes_full_6[] = {1, 1, 1, 1, 1}; fire_book_update (prices_full_6, sizes_full_6, api::Side::SIDE_SELL, 0, sm, quoter); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(10), Quantity(15), Price(2003.5), Quantity(15), Quantity (75), false); LOG(OrderMan, Diag, "quoter_WORKING.on_book"); // blank out the book, this should result in cxl'ing the order double prices_full_7[] = {2000.0, 2001, 2002, 2003, 2004}; uint16_t sizes_full_7[] = {0, 0, 0, 0, 0}; fire_book_update (prices_full_7, sizes_full_7, api::Side::SIDE_SELL, 0, sm, quoter); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, spreader_quantity, Quantity(10), Quantity(15), Price(2003.5), Quantity(15), Quantity (75), false); LOG(OrderMan, Diag, "quoter_WORKING.on_book"); } SECTION("4. cancel_order") { quoter.cancel_order(); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.50), Quantity(40), Quantity (100), false); LOG(OrderMan, Diag, "quoter_WORKING.cancel_order"); } SECTION("5. terminate") { quoter.terminate (); verify_complete_quoter_state (quoter, QuoterState::END, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.50), Quantity(40), Quantity (100), false); LOG(OrderMan, Diag, "quoter_WORKING.terminate"); } SECTION("7. update_other_leg_fills") { // base set with full market and a partial fill of 10 double prices_full_0[] = {2000.0, 2000.25, 2000.5, 2000.75, 2001.0}; uint16_t sizes_full_0[] = {10, 30, 25, 15, 20}; fire_book_update (prices_full_0, sizes_full_0, api::Side::SIDE_SELL, 0, sm, quoter); u.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (10), Price (2000)); quoter.update_order_status (u); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(10), Quantity(0), Price(2000.5), Quantity(100), Quantity (90), false); // hedge reduction by 10 quoter.update_other_leg_fills (0, Quantity (10)); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(10), Quantity(10), Price(2000.25), Quantity(90), Quantity (80), false); LOG(OrderMan, Diag, "quoter_WORKING.update_other_leg_fills"); // hedge reduction by another 15 quoter.update_other_leg_fills (0, Quantity (15)); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(10), Quantity(25), Price(2000.00), Quantity(75), Quantity (65), false); LOG(OrderMan, Diag, "quoter_WORKING.update_other_leg_fills"); // hedge reduction by another 55 quoter.update_other_leg_fills (0, Quantity (55)); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(10), Quantity(80), Price(1999.5), Quantity(20), Quantity (10), false); LOG(OrderMan, Diag, "quoter_WORKING.update_other_leg_fills"); // this hedge reduction should completely cancel the quoting side quoter.update_other_leg_fills (0, Quantity (10)); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, spreader_quantity, Quantity(10), Quantity(90), Price(1999.5), Quantity(20), Quantity (0), true); LOG(OrderMan, Diag, "quoter_WORKING.update_other_leg_fills"); } SECTION("8. update_order_price_quantity") { // change price, qty spreader_price = Price (0.0); spreader_quantity = Quantity(200); quoter.update_order_price_quantity (spreader_price, spreader_quantity); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2001.0), Quantity(40), Quantity (200), false); // decrease the qty spreader_price = Price (0.0); spreader_quantity = Quantity(40); quoter.update_order_price_quantity (spreader_price, spreader_quantity); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2001.0), Quantity(40), Quantity (40), false); // other leg fill and then decrease the size quoter.update_other_leg_fills (0, Quantity (25)); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(0), Quantity(25), Price(2000.25), Quantity(15), Quantity (15), false); // change the quantity to beyond what was filled in the other leg spreader_price = Price (0.0); spreader_quantity = Quantity(25); quoter.update_order_price_quantity (spreader_price, spreader_quantity); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, spreader_quantity, Quantity(0), Quantity(25), Price(2000.25), Quantity(15), Quantity (0), true); LOG(OrderMan, Diag, "quoter_WORKING.update_order_price_quantity"); } } TEST_CASE ("cycle", "[spreader]") { bts::orderman2::OrderKey spreader_order_key(0); Price spreader_price = Price (0.5); Quantity spreader_quantity (100); SpreaderManagerForTest* sm_ptr = create_spreader_manager_2_legs (spreader_order_key, bts::api::Venue::VENUE_GLBX, "ES", 2017, 12, 15, 1.0, 1.0, 1.0, api::Side::SIDE_BUY, 1.0, 0.25, bts::api::Venue::VENUE_GLBX, "ES", 2017, 3, 15, 1.0, -1.0, 1.0, api::Side::SIDE_SELL, 1.0, 0.25); SpreaderBookkeepingData& bookeeping_data = sm_ptr->bookkeeping_data(); SpreaderManagerForTest& sm = *sm_ptr; SingleLegQuoter& quoter = bookeeping_data.get_leg_data(1).quoter(); quoter.one_time_activate(spreader_price, spreader_quantity); double prices[] = {2000.0, 2000.25, 2000.5, 2000.75, 2001.0}; uint16_t sizes[] = {5, 10, 4, 6, 15}; fire_book_update (prices, sizes, api::Side::SIDE_SELL, 0, sm, quoter); SpreaderChildOrderState u = create_order_update (); u.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0)); quoter.update_order_status (u); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.5), Quantity(40), Quantity (100), false); // so we have a working order of 40 // fill of 40 -> another order of 40 // fill of 10 -> order size should go up to 50 (since the book can satisfy 40 lots) // fill of 10 -> order size should go up to 60 (...) // fill the remainder -> end // fill the working 40 u.update (api::orderman2::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (40), Price (2000)); quoter.update_order_status (u); // cycles back, to waiting for size verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_SIZE, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (60), false); // fire the book, this will fire the order fire_book_update (prices, sizes, api::Side::SIDE_SELL, 0, sm, quoter); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.50), Quantity(40), Quantity (60), false); // send ack to make it go to working SpreaderChildOrderState u2 = create_order_update (); u2.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0)); quoter.update_order_status (u2); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.50), Quantity(40), Quantity (60), false); // fill 5, this should increase the order size to 45 u2.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (5), Price (2000)); quoter.update_order_status (u2); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(5), Quantity(0), Price(2000.50), Quantity(45), Quantity (55), false); // fill it all u2.update (api::orderman2::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (45), Price (2000)); quoter.update_order_status (u2); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_SIZE, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (15), false); // fire the book, this will fire the order fire_book_update (prices, sizes, api::Side::SIDE_SELL, 0, sm, quoter); verify_complete_quoter_state (quoter, QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(1999.75), Quantity(15), Quantity (15), false); // send an ack SpreaderChildOrderState u3 = create_order_update (); u3.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0)); quoter.update_order_status (u3); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(1999.75), Quantity(15), Quantity (15), false); // fill it all, should go to end u3.update (api::orderman2::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (15), Price (2000)); quoter.update_order_status (u3); verify_complete_quoter_state (quoter, QuoterState::END, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (0), true); LOG(OrderMan, Diag, "cycle"); } /************************************************************************************************************/ /*********************************************Hedger State Tests*********************************************/ /************************************************************************************************************/ TEST_CASE ("hedger_START_state", "[spreader]") { bts::orderman2::OrderKey spreader_order_key(0); Price hedger_price = Price (0.5); Quantity hedger_quantity (20); SpreaderManagerForTest* sm_ptr = create_spreader_manager_2_legs (spreader_order_key, bts::api::Venue::VENUE_GLBX, "ES", 2017, 12, 15, 1.0, 1.0, 1.0, api::Side::SIDE_BUY, 1.0, 0.25, bts::api::Venue::VENUE_GLBX, "ES", 2017, 3, 15, 1.0, -1.0, 1.0, api::Side::SIDE_SELL, 1.0, 0.25); SpreaderBookkeepingData& bookeeping_data = sm_ptr->bookkeeping_data(); SpreaderManagerForTest& sm = *sm_ptr; SpreaderChildOrderState u; SingleFillHedger hedger (sm, sm.get_leg_data (1), u, hedger_price, hedger_quantity); verify_complete_hedger_state (hedger, HedgerState::START, hedger_price, hedger_quantity, Quantity (0), Price (0), Quantity (0), hedger_quantity); SECTION("0. transition_to_start") { verify_complete_hedger_state (hedger, HedgerState::START, hedger_price, hedger_quantity, Quantity (0), Price (0), Quantity (0), hedger_quantity); LOG(OrderMan, Diag, "hedger_START_state.transition_to_start"); } SECTION("1. init") { hedger.init (); verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, hedger_quantity); LOG(OrderMan, Diag, "hedger_START_state.init"); } // SECTION("3. on_book") // { // double prices[] = {2000, 2000.25, 2000.5, 2000.75, 2002}; uint16_t sizes[] = {10, 5, 15, 5, 25}; // fire_book_update_hedger (prices, sizes, api::Side::SIDE_SELL, hedger); // verify_complete_hedger_state (hedger, HedgerState::START, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, hedger_quantity); // LOG(OrderMan, Diag, "hedger_START_state.on_book"); // } SECTION("4. cancel_hedge") { hedger.cancel_hedge(); verify_complete_hedger_state (hedger, HedgerState::END, hedger_price, hedger_quantity, Quantity (0), Price (0), Quantity (0), hedger_quantity); LOG(OrderMan, Diag, "hedger_START_state.cancel_hedge"); } SECTION("5. terminate") { hedger.terminate (); verify_complete_hedger_state (hedger, HedgerState::END, hedger_price, hedger_quantity, Quantity (0), Price (0), Quantity (0), hedger_quantity); LOG(OrderMan, Diag, "hedger_START_state.terminate"); } } TEST_CASE ("hedger_WAITING_FOR_FIRST_ACK_state", "[spreader]") { bts::orderman2::OrderKey spreader_order_key(0); Price hedger_price = Price (0.5); Quantity hedger_quantity (20); SpreaderManagerForTest* sm_ptr = create_spreader_manager_2_legs (spreader_order_key, bts::api::Venue::VENUE_GLBX, "ES", 2017, 12, 15, 1.0, 1.0, 1.0, api::Side::SIDE_BUY, 1.0, 0.25, bts::api::Venue::VENUE_GLBX, "ES", 2017, 3, 15, 1.0, -1.0, 1.0, api::Side::SIDE_SELL, 1.0, 0.25); SpreaderBookkeepingData& bookeeping_data = sm_ptr->bookkeeping_data(); SpreaderManagerForTest& sm = *sm_ptr; SpreaderChildOrderState u; SingleFillHedger hedger (sm, sm.get_leg_data (1), u, hedger_price, hedger_quantity); verify_complete_hedger_state (hedger, HedgerState::START, hedger_price, hedger_quantity, Quantity (0), Price (0), Quantity (0), hedger_quantity); hedger.init (); verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, hedger_quantity); SECTION("1. init") { } SECTION ("2. on_order_update_non_terminal") { SpreaderChildOrderState u = create_order_update (); u.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (5), Price (2000)); hedger.on_order_update(u); verify_complete_hedger_state (hedger, HedgerState::WORKING, hedger_price, hedger_quantity, Quantity (5), hedger_price, hedger_quantity, Quantity(15)); LOG(OrderMan, Diag, "hedger_WAITING_FOR_FIRST_ACK_state.on_order_update_non_terminal"); } SECTION ("2. on_order_update_terminal") { SpreaderChildOrderState u = create_order_update (); u.update (api::orderman2::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (20), Price (2000)); hedger.on_order_update (u); verify_complete_hedger_state (hedger, HedgerState::END, hedger_price, hedger_quantity, Quantity (20), Price(0), Quantity(0), Quantity(0)); LOG(OrderMan, Diag, "hedger_WAITING_FOR_FIRST_ACK_state.on_order_update_terminal"); } SECTION("3. on_book") { double prices[] = {2000, 2000.25, 2000.5, 2000.75, 2002}; uint16_t sizes[] = {10, 5, 15, 5, 25}; fire_book_update_hedger (prices, sizes, api::Side::SIDE_SELL, hedger); verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, hedger_quantity); LOG(OrderMan, Diag, "hedger_WAITING_FOR_FIRST_ACK_state.on_book"); } SECTION("4. cancel_hedge") { hedger.cancel_hedge(); verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK_CANCELLED, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, hedger_quantity); LOG(OrderMan, Diag, "hedger_START_state.cancel_hedge"); } SECTION("5. terminate") { hedger.terminate(); verify_complete_hedger_state (hedger, HedgerState::END, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, hedger_quantity); LOG(OrderMan, Diag, "hedger_START_state.terminate"); } } TEST_CASE ("hedger_WAITING_FOR_FIRST_ACK_CANCELLED_state", "[spreader]") { bts::orderman2::OrderKey spreader_order_key(0); Price hedger_price = Price (0.5); Quantity hedger_quantity (20); SpreaderManagerForTest* sm_ptr = create_spreader_manager_2_legs (spreader_order_key, bts::api::Venue::VENUE_GLBX, "ES", 2017, 12, 15, 1.0, 1.0, 1.0, api::Side::SIDE_BUY, 1.0, 0.25, bts::api::Venue::VENUE_GLBX, "ES", 2017, 3, 15, 1.0, -1.0, 1.0, api::Side::SIDE_SELL, 1.0, 0.25); SpreaderBookkeepingData& bookeeping_data = sm_ptr->bookkeeping_data(); SpreaderManagerForTest& sm = *sm_ptr; SpreaderChildOrderState u; SingleFillHedger hedger (sm, sm.get_leg_data (1), u, hedger_price, hedger_quantity); verify_complete_hedger_state (hedger, HedgerState::START, hedger_price, hedger_quantity, Quantity (0), Price (0), Quantity (0), hedger_quantity); hedger.init (); hedger.cancel_hedge(); verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK_CANCELLED, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, hedger_quantity); SECTION("1. init") { } SECTION ("2. on_order_update_non_terminal") { SpreaderChildOrderState u = create_order_update (); u.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (5), Price (2000)); hedger.on_order_update(u); verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_CANCEL_ACK, hedger_price, hedger_quantity, Quantity (5), hedger_price, hedger_quantity, Quantity(15)); LOG(OrderMan, Diag, "hedger_WAITING_FOR_FIRST_ACK_CANCELLED_state.on_order_update_non_terminal"); } SECTION ("2. on_order_update.terminal") { SpreaderChildOrderState u = create_order_update (); u.update (api::orderman2::OrderStatus::ORDER_STATUS_CANCELED, Quantity (0), Price (0)); hedger.on_order_update (u); verify_complete_hedger_state (hedger, HedgerState::END, hedger_price, hedger_quantity, Quantity (0), Price(0), Quantity(0), Quantity(20)); LOG(OrderMan, Diag, "hedger_WAITING_FOR_FIRST_ACK_state.on_order_update"); } SECTION("3. on_book") { double prices[] = {2000, 2000.25, 2000.5, 2000.75, 2002}; uint16_t sizes[] = {10, 5, 15, 5, 25}; fire_book_update_hedger (prices, sizes, api::Side::SIDE_SELL, hedger); verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK_CANCELLED, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, hedger_quantity); LOG(OrderMan, Diag, "hedger_WAITING_FOR_FIRST_ACK_CANCELLED_state.on_book"); } SECTION("4. cancel_hedge") { hedger.cancel_hedge(); verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK_CANCELLED, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, hedger_quantity); LOG(OrderMan, Diag, "hedger_WAITING_FOR_FIRST_ACK_CANCELLED_state.cancel_hedge"); } SECTION("5. terminate") { hedger.terminate(); verify_complete_hedger_state (hedger, HedgerState::END, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, hedger_quantity); LOG(OrderMan, Diag, "hedger_WAITING_FOR_FIRST_ACK_CANCELLED_state.terminate"); } } TEST_CASE ("hedger_WAITING_FOR_CANCEL_ACK_state", "[spreader]") { bts::orderman2::OrderKey spreader_order_key(0); Price hedger_price = Price (0.5); Quantity hedger_quantity (20); SpreaderManagerForTest* sm_ptr = create_spreader_manager_2_legs (spreader_order_key, bts::api::Venue::VENUE_GLBX, "ES", 2017, 12, 15, 1.0, 1.0, 1.0, api::Side::SIDE_BUY, 1.0, 0.25, bts::api::Venue::VENUE_GLBX, "ES", 2017, 3, 15, 1.0, -1.0, 1.0, api::Side::SIDE_SELL, 1.0, 0.25); SpreaderBookkeepingData& bookeeping_data = sm_ptr->bookkeeping_data(); SpreaderManagerForTest& sm = *sm_ptr; SpreaderChildOrderState u; SingleFillHedger hedger (sm, sm.get_leg_data (1), u, hedger_price, hedger_quantity); verify_complete_hedger_state (hedger, HedgerState::START, hedger_price, hedger_quantity, Quantity (0), Price (0), Quantity (0), hedger_quantity); hedger.init (); hedger.cancel_hedge(); verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK_CANCELLED, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, hedger_quantity); u = create_order_update (); u.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0)); hedger.on_order_update (u); verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_CANCEL_ACK, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, Quantity(20)); SECTION("1. init") { } SECTION ("2. on_order_update") { // eventhough the order was cancelled, non terminal updates // can keep coming in SpreaderChildOrderState u = create_order_update (); u.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (5), Price (2000)); hedger.on_order_update(u); verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_CANCEL_ACK, hedger_price, hedger_quantity, Quantity (5), hedger_price, hedger_quantity, Quantity(15)); u.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (10), Price (2000)); hedger.on_order_update(u); verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_CANCEL_ACK, hedger_price, hedger_quantity, Quantity (10), hedger_price, hedger_quantity, Quantity(10)); u.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (15), Price (2000)); hedger.on_order_update(u); verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_CANCEL_ACK, hedger_price, hedger_quantity, Quantity (15), hedger_price, hedger_quantity, Quantity(5)); // cancel the order now u.update (api::orderman2::OrderStatus::ORDER_STATUS_CANCELED, Quantity (15), Price (2000)); hedger.on_order_update(u); verify_complete_hedger_state (hedger, HedgerState::END, hedger_price, hedger_quantity, Quantity (15), Price(0), Quantity(0), Quantity(5)); LOG(OrderMan, Diag, "hedger_WAITING_FOR_CANCEL_ACK_state.on_order_update"); } SECTION("3. on_book") { // no change double prices[] = {2000, 2000.25, 2000.5, 2000.75, 2002}; uint16_t sizes[] = {10, 5, 15, 5, 25}; fire_book_update_hedger (prices, sizes, api::Side::SIDE_SELL, hedger); verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_CANCEL_ACK, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, Quantity(20)); LOG(OrderMan, Diag, "hedger_WAITING_FOR_CANCEL_ACK_state.on_book"); } SECTION("4. cancel_hedge") { // no change hedger.cancel_hedge(); verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_CANCEL_ACK, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, Quantity(20)); LOG(OrderMan, Diag, "hedger_WAITING_FOR_CANCEL_ACK_state.cancel_hedge"); } SECTION("5. terminate") { hedger.terminate(); verify_complete_hedger_state (hedger, HedgerState::END, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, hedger_quantity); LOG(OrderMan, Diag, "hedger_WAITING_FOR_CANCEL_ACK_state.terminate"); } } TEST_CASE ("hedger_END_state", "[spreader]") { bts::orderman2::OrderKey spreader_order_key(0); Price hedger_price = Price (0.5); Quantity hedger_quantity (20); SpreaderManagerForTest* sm_ptr = create_spreader_manager_2_legs (spreader_order_key, bts::api::Venue::VENUE_GLBX, "ES", 2017, 12, 15, 1.0, 1.0, 1.0, api::Side::SIDE_BUY, 1.0, 0.25, bts::api::Venue::VENUE_GLBX, "ES", 2017, 3, 15, 1.0, -1.0, 1.0, api::Side::SIDE_SELL, 1.0, 0.25); SpreaderBookkeepingData& bookeeping_data = sm_ptr->bookkeeping_data(); SpreaderManagerForTest& sm = *sm_ptr; SpreaderChildOrderState u; SingleFillHedger hedger (sm, sm.get_leg_data (1), u, hedger_price, hedger_quantity); verify_complete_hedger_state (hedger, HedgerState::START, hedger_price, hedger_quantity, Quantity (0), Price (0), Quantity (0), hedger_quantity); hedger.init (); u = create_order_update (); u.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0)); hedger.on_order_update (u); hedger.cancel_hedge (); u.update (api::orderman2::OrderStatus::ORDER_STATUS_CANCELED, Quantity (0), Price (0)); hedger.on_order_update (u); verify_complete_hedger_state (hedger, HedgerState::END, hedger_price, hedger_quantity, Quantity (0), Price(0), Quantity (0), Quantity(20)); SECTION("1. init") { } SECTION ("2. on_order_update") { u.update (api::orderman2::OrderStatus::ORDER_STATUS_CANCELED, Quantity (0), Price (0)); hedger.on_order_update (u); verify_complete_hedger_state (hedger, HedgerState::END, hedger_price, hedger_quantity, Quantity (0), Price(0), Quantity (0), Quantity(20)); LOG(OrderMan, Diag, "hedger_END_state.on_order_update"); } SECTION("3. on_book") { double prices[] = {2000, 2000.25, 2000.5, 2000.75, 2002}; uint16_t sizes[] = {10, 5, 15, 5, 25}; fire_book_update_hedger (prices, sizes, api::Side::SIDE_SELL, hedger); verify_complete_hedger_state (hedger, HedgerState::END, hedger_price, hedger_quantity, Quantity (0), Price(0), Quantity (0), Quantity(20)); LOG(OrderMan, Diag, "hedger_END_state.on_book"); } SECTION("4. cancel_hedge") { hedger.cancel_hedge (); verify_complete_hedger_state (hedger, HedgerState::END, hedger_price, hedger_quantity, Quantity (0), Price(0), Quantity (0), Quantity(20)); LOG(OrderMan, Diag, "hedger_END_state.cancel_hedge"); } SECTION("5. terminate") { hedger.terminate(); verify_complete_hedger_state (hedger, HedgerState::END, hedger_price, hedger_quantity, Quantity (0), Price(0), Quantity (0), Quantity(20)); LOG(OrderMan, Diag, "hedger_END_state.terminate"); } } TEST_CASE ("hedger_WORKING", "[spreader]") { bts::orderman2::OrderKey spreader_order_key(0); Price hedger_price = Price (0.5); Quantity hedger_quantity (20); SpreaderManagerForTest* sm_ptr = create_spreader_manager_2_legs (spreader_order_key, bts::api::Venue::VENUE_GLBX, "ES", 2017, 12, 15, 1.0, 1.0, 1.0, api::Side::SIDE_BUY, 1.0, 0.25, bts::api::Venue::VENUE_GLBX, "ES", 2017, 3, 15, 1.0, -1.0, 1.0, api::Side::SIDE_SELL, 1.0, 0.25); SpreaderBookkeepingData& bookeeping_data = sm_ptr->bookkeeping_data(); SpreaderManagerForTest& sm = *sm_ptr; SpreaderChildOrderState u; SingleFillHedger hedger (sm, sm.get_leg_data (1), u, hedger_price, hedger_quantity); verify_complete_hedger_state (hedger, HedgerState::START, hedger_price, hedger_quantity, Quantity (0), Price (0), Quantity (0), hedger_quantity); hedger.init (); u.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0)); hedger.on_order_update (u); verify_complete_hedger_state (hedger, HedgerState::WORKING, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, Quantity(20)); SECTION("1. init") { } SECTION ("2. on_order_update") { // partial fill 1 u.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (7), Price (2000)); hedger.on_order_update (u); verify_complete_hedger_state (hedger, HedgerState::WORKING, hedger_price, hedger_quantity, Quantity (7), hedger_price, hedger_quantity, Quantity(13)); // partial fill 2 u.update (api::orderman2::OrderStatus::ORDER_STATUS_WORKING, Quantity (15), Price (2000)); hedger.on_order_update (u); verify_complete_hedger_state (hedger, HedgerState::WORKING, hedger_price, hedger_quantity, Quantity (15), hedger_price, hedger_quantity, Quantity(5)); // complete fill u.update (api::orderman2::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (20), Price (2000)); hedger.on_order_update (u); verify_complete_hedger_state (hedger, HedgerState::END, hedger_price, hedger_quantity, Quantity (20), Price(0), Quantity(0), Quantity(0)); LOG(OrderMan, Diag, "hedger_WORKING.on_order_update"); } SECTION("3. on_book_no_post_hedge") { double prices[] = {2000, 2000.25, 2000.5, 2000.75, 2002}; uint16_t sizes[] = {10, 5, 15, 5, 25}; fire_book_update_hedger (prices, sizes, api::Side::SIDE_SELL, hedger); verify_complete_hedger_state (hedger, HedgerState::WORKING, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, Quantity(20)); LOG(OrderMan, Diag, "hedger_WORKING.on_book_no_post_hedge"); } SECTION("4. cancel_hedge") { hedger.cancel_hedge (); verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_CANCEL_ACK, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, Quantity(20)); LOG(OrderMan, Diag, "hedger_WORKING.cancel_hedge"); } SECTION("5. terminate") { hedger.terminate(); verify_complete_hedger_state (hedger, HedgerState::END, hedger_price, hedger_quantity, Quantity (0), hedger_price, hedger_quantity, Quantity(20)); LOG(OrderMan, Diag, "hedger_WORKING.terminate"); } } /************************************************************************************************************/ /*********************************************Spreader State Tests*********************************************/ /************************************************************************************************************/ TEST_CASE ("spreader_START", "[spreader]") { // ContractLeg leg_1, leg_2; // fill_future_contract_leg (leg_1, 2468, "ES", bts::api::Venue::VENUE_GLBX, 2017, 12, 15, 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, api::Side::SIDE_SELL, 1.0, 0.25); // std::vector legs; // legs.push_back (leg_1); // legs.push_back (leg_2); // QuoteParams qp_1, qp_2; // fill_quote_params (qp_1, 1.0); // fill_quote_params (qp_2, 1.0); // LegSpreaderParams leg_spreader_params_1, leg_spreader_params_2; // fill_leg_spreader_params (leg_spreader_params_1, 1.0, true, qp_1); // fill_leg_spreader_params (leg_spreader_params_2, -1.0, true, qp_2); // std::vector leg_spreader_params; // leg_spreader_params.push_back (leg_spreader_params_1); // leg_spreader_params.push_back (leg_spreader_params_2); // Price spreader_price = Price (0); // Quantity spreader_quantity = Quantity (100); // api::orderman::CreateOrderRequest cor; // fill_create_orderorder (cor, 422, spreader_price, spreader_quantity, api::Side::SIDE_BUY, legs, leg_spreader_params); // MySecDB db (legs); // NativeOrderFactory factory; // /*****************Creating the order********************/ // SpreaderOrder spreader (db,factory,OrderKey(1),cor); // // auto do_nothing = [] (auto const&) {}; // // spreader.init_signals(do_nothing, // // do_nothing, // // do_nothing, // // do_nothing, // // do_nothing); bts::orderman2::OrderKey order_key(0); //Price spreader_price = Price (0); 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, 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, api::Side::SIDE_SELL, 1.0, 0.25); std::vector 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 spreader_params; spreader_params.push_back(lsp_1);spreader_params.push_back(lsp_2); bts::api::orderman2::OrderDefinition order_def; fill_spreader_order_definition(order_def, Side::SIDE_BUY, synthetic_security, spreader_params); // putting it together in SpreaderBookkeepingData TestOnlySpreaderPreActivationOrderServices testonly_spreader_pao_services = _create_spreader_pao_services(synthetic_security); SpreaderPreActivationOrderServices pao_services (&testonly_spreader_pao_services); std::vector leg_props; SpreaderUtils::resolve_synthetic_spread(pao_services, order_def, leg_props); SpreaderManagerForTest spreader_manager (order_key, pao_services, leg_props); SpreaderBookkeepingData& bookkeeping_data = spreader_manager.bookkeeping_data(); SpreaderOrder spreader; bts_assert(spreader.test_only_func_spreader_state() == SpreaderState::START); SECTION("1. on_init_new.resolved") { spreader.test_only_on_init_new (order_def, pao_services); bts_assert(spreader.test_only_func_spreader_state() == SpreaderState::START); SpreaderBookkeepingData& bookeeping_data = spreader.test_only_func_spreader_full_data(); bts_assert(bookkeeping_data.get_leg_data(0).leg_property_data().security_key() == 2468); bts_assert(bookkeeping_data.get_leg_data(1).leg_property_data().security_key() == 13579); } SECTION("1. on_init_new.not_resolved") { testonly_spreader_pao_services.set_resolve_flag(false); spreader.test_only_on_init_new (order_def, pao_services); bts_assert(spreader.test_only_func_spreader_state() == SpreaderState::END); } SECTION("5. on_cancel") { spreader.on_cancel(); bts_assert(spreader.test_only_func_spreader_state() == SpreaderState::END); LOG(OrderMan, Diag, "spreader_START.on_cancel"); } } // TEST_CASE ("spreader_WAITING_FOR_FIRST_CONNECT", "[spreader]") // { // ContractLeg leg_1, leg_2; // fill_future_contract_leg (leg_1, 2468, "ES", bts::api::Venue::VENUE_GLBX, 2017, 12, 15, 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, api::Side::SIDE_SELL, 1.0, 0.25); // std::vector legs; // legs.push_back (leg_1); // legs.push_back (leg_2); // QuoteParams qp_1, qp_2; // fill_quote_params (qp_1, 1.0); // fill_quote_params (qp_2, 1.0); // LegSpreaderParams leg_spreader_params_1, leg_spreader_params_2; // fill_leg_spreader_params (leg_spreader_params_1, 1.0, true, qp_1); // fill_leg_spreader_params (leg_spreader_params_2, -1.0, true, qp_2); // std::vector leg_spreader_params; // leg_spreader_params.push_back (leg_spreader_params_1); // leg_spreader_params.push_back (leg_spreader_params_2); // Price spreader_price = Price (0); // Quantity spreader_quantity = Quantity (100); // api::orderman::CreateOrderRequest cor; // fill_create_orderorder (cor, 422, spreader_price, spreader_quantity, api::Side::SIDE_BUY, legs, leg_spreader_params); // MySecDB db (legs); // NativeOrderFactory factory; // /*****************Creating the order********************/ // SpreaderOrder spreader (db,factory,OrderKey(1),cor); // // auto do_nothing = [] (auto const&) {}; // // spreader.init_signals(do_nothing, // // do_nothing, // // do_nothing, // // do_nothing, // // do_nothing); // spreader.init (); // verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_FIRST_CONNECT, spreader_price, spreader_quantity); // SECTION("1. init") // { // } // SECTION("2. on_connect_securities_not_resolved") // { // db.secs.clear (); // // since it wont be able to resolve securities, it will directly // // go to end forever // spreader.on_connect (); // verify_basic_spreader_state (spreader, SpreaderState::END, spreader_price, spreader_quantity); // LOG(OrderMan, Diag, "spreader_WAITING_FOR_FIRST_CONNECT.on_connect_securities_not_resolved"); // } // SECTION("2. on_connect_securities_resolved") // { // // this is where everything will be set up // spreader.on_connect (); // verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity); // LOG(OrderMan, Diag, "spreader_WAITING_FOR_FIRST_CONNECT.on_connect_securities_resolved"); // // validate data // // leg 1 // SpreaderBookkeepingData& spreader_bookkeeping_data = spreader.test_only_func_spreader_full_data (); // SpreaderLegData& spreader_leg_1 = spreader_bookkeeping_data.get_leg_data (0); // const LegPropertyData& spreader_leg_1_data = spreader_leg_1.leg_property_data (); // validate_leg_property_data (spreader_leg_1_data, 0, leg_1, leg_spreader_params_1, api::Side::SIDE_BUY); // // leg 2 // SpreaderLegData& spreader_leg_2 = spreader_bookkeeping_data.get_leg_data (1); // const LegPropertyData& spreader_leg_2_data = spreader_leg_2.leg_property_data (); // validate_leg_property_data (spreader_leg_2_data, 1, leg_2, leg_spreader_params_2, api::Side::SIDE_SELL); // } // SECTION("4. on_update") // { // api::orderman::UpdateSpreaderOrder u; u.set_price(-0.05); u.set_quantity (200); // spreader.on_update (u); // verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_FIRST_CONNECT, Price (-0.05), Quantity (200)); // LOG(OrderMan, Diag, "spreader_WAITING_FOR_FIRST_CONNECT.on_update"); // } // SECTION("5. on_cancel") // { // api::orderman::CancelSpreaderOrder c; // spreader.on_cancel(c); // verify_basic_spreader_state (spreader, SpreaderState::END, spreader_price, spreader_quantity); // LOG(OrderMan, Diag, "spreader_WAITING_FOR_FIRST_CONNECT.on_cancel"); // } // SECTION("6. on_book") // { // } // SECTION("7. on_time") // { // } // SECTION("8. on_quoter_order_error") // { // } // SECTION("9. on_quoter_order_fill") // { // } // SECTION("10. on_quoter_order_status_update") // { // } // SECTION("11. on_hedger_order_error") // { // } // SECTION("12. on_hedger_order_update") // { // } // SECTION("13. on_external_error") // { // std::string err_msg = "external error"; // spreader.on_external_error (err_msg); // verify_basic_spreader_state (spreader, SpreaderState::END, spreader_price, spreader_quantity); // LOG(OrderMan, Diag, "spreader_WAITING_FOR_FIRST_CONNECT.on_external_error"); // } // SECTION("14. on_check_termination") // { // } // } // TEST_CASE ("spreader_WORKING", "[spreader]") // { // ContractLeg leg_1, leg_2; // fill_future_contract_leg (leg_1, 2468, "ES", bts::api::Venue::VENUE_GLBX, 2017, 12, 15, 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, api::Side::SIDE_SELL, 1.0, 0.25); // std::vector legs; // legs.push_back (leg_1); // legs.push_back (leg_2); // QuoteParams qp_1, qp_2; // fill_quote_params (qp_1, 1.0); // fill_quote_params (qp_2, 1.0); // LegSpreaderParams leg_spreader_params_1, leg_spreader_params_2; // fill_leg_spreader_params (leg_spreader_params_1, 1.0, true, qp_1); // fill_leg_spreader_params (leg_spreader_params_2, -1.0, true, qp_2); // std::vector leg_spreader_params; // leg_spreader_params.push_back (leg_spreader_params_1); // leg_spreader_params.push_back (leg_spreader_params_2); // Price spreader_price = Price (1); // Quantity spreader_quantity = Quantity (100); // api::orderman::CreateOrderRequest cor; // fill_create_orderorder (cor, 422, spreader_price, spreader_quantity, api::Side::SIDE_BUY, legs, leg_spreader_params); // MySecDB db (legs); // NativeOrderFactory factory; // /*****************Creating the order********************/ // SpreaderOrder spreader (db,factory,OrderKey(1),cor); // // auto do_nothing = [] (auto const&) {}; // // spreader.init_signals(do_nothing, // // do_nothing, // // do_nothing, // // do_nothing, // // do_nothing); // spreader.init (); // spreader.on_connect (); // verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity); // 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}); // // verify working orders // SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data (); // SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1); // verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false); // verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false); // // send fill on leg 1 (20) // spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (20), Price (2000), nullptr); // verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false); // verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false); // // send another fill on leg 1 (10) // spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (30), Price (2000), nullptr); // 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.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (15), Price (2001), nullptr); // 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.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (45), Price (2001), nullptr); // verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(45), Price(2002), Quantity(55), Quantity(25), false); // verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (45), Quantity(30), Price(2000), Quantity(70), Quantity(25), false); // // send another fill on leg 2 (10) // spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (55), Price (2001), nullptr); // verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false); // verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); // // verify the hedgers // // leg 1 should have 3 hedgers, for each of the 3 fills // for (size_t i = 0; i < leg_data_1.n_hedgers(); i++) // spreader.on_child_update (leg_data_1.get_hedger(i).order_update_message().order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); // for (size_t i = 0; i < leg_data_2.n_hedgers(); i++) // spreader.on_child_update (leg_data_2.get_hedger(i).order_update_message().order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); // bts_assert (leg_data_1.n_hedgers () == 3); // bts_assert (leg_data_2.n_hedgers () == 2); // verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::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).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); // verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); // verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); // verify_complete_hedger_state (leg_data_2.get_hedger (0).hedger(), HedgerState::WORKING, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20)); // verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), HedgerState::WORKING, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10)); // 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 // { // bts_assert (leg_data_1.n_hedgers () == 3); // bts_assert (leg_data_2.n_hedgers () == 2); // verify_complete_hedger_state (leg_data_1.get_hedger(0).hedger(), 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(), 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(), 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(), 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(), hedger_state, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10)); // }; // SECTION("1. init") // { // } // SECTION("2. on_connect") // { // } // SECTION("3. on_disconnect") // { // // terminates all quoters and hedgers and goes to the // // end state // spreader.on_disconnect (); // verify_basic_spreader_state (spreader, SpreaderState::END, spreader_price, spreader_quantity); // generic_validate_quoters (QuoterState::END, true); // generic_validate_hedgers (HedgerState::END); // LOG(OrderMan, Diag, "spreader_WORKING.on_disconnect"); // } // 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); // api::orderman::UpdateSpreaderOrder u; u.set_price(spreader_price.value()); u.set_quantity (spreader_quantity.value()); // spreader.on_update (u); // 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") // { // api::orderman::CancelSpreaderOrder c; // spreader.on_cancel(c); // 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(); // 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.on_book (bts::orderman::NullTickToTradeCorID, modified_book); // 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::NullTickToTradeCorID, modified_book); // 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::NullTickToTradeCorID, modified_book); // 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::NullTickToTradeCorID, modified_book); // 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::NullTickToTradeCorID, modified_book); // 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") // { // // similiar to a cancel // std::string err_msg = "error"; // spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (30), Price (2000), &err_msg); // 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_quoter_order_error"); // } // SECTION("9. on_quoter_order_fill") // { // // add one more hedge // spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (65), Price (2001), nullptr); // for (size_t i = 0; i < leg_data_1.n_hedgers(); i++) // spreader.on_child_update (leg_data_1.get_hedger(i).order_update_message().order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); // for (size_t i = 0; i < leg_data_2.n_hedgers(); i++) // spreader.on_child_update (leg_data_2.get_hedger(i).order_update_message().order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); // bts_assert (leg_data_1.n_hedgers () == 4); // bts_assert (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).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); // verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); // verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); // verify_complete_hedger_state (leg_data_1.get_hedger (3).hedger(), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); // verify_complete_hedger_state (leg_data_2.get_hedger (0).hedger(), HedgerState::WORKING, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20)); // verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), HedgerState::WORKING, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10)); // LOG(OrderMan, Diag, "spreader_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.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_FILLED, Quantity (70), Price (2001), nullptr); // for (size_t i = 0; i < leg_data_1.n_hedgers(); i++) // spreader.on_child_update (leg_data_1.get_hedger(i).order_update_message().order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); // for (size_t i = 0; i < leg_data_2.n_hedgers(); i++) // spreader.on_child_update (leg_data_2.get_hedger(i).order_update_message().order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); // bts_assert (leg_data_1.n_hedgers () == 4); // bts_assert (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).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); // verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); // verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); // verify_complete_hedger_state (leg_data_1.get_hedger (3).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); // verify_complete_hedger_state (leg_data_2.get_hedger (0).hedger(), HedgerState::WORKING, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20)); // verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), HedgerState::WORKING, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10)); // LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_fill"); // } // SECTION("11. on_hedger_order_error") // { // // similiar to a cancel // std::string err_msg = "error"; // spreader.on_child_update (leg_data_1.get_hedger(0).order_update_message().order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), &err_msg); // 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_hedger_order_error"); // } // SECTION("12. on_hedger_order_update") // { // // send as fill for the hedger // spreader.on_child_update (leg_data_1.get_hedger(0).order_update_message().order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (10), Price (2002), nullptr); // verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity); // generic_validate_quoters (QuoterState::WORKING, false); // bts_assert (leg_data_1.n_hedgers () == 3); // bts_assert (leg_data_2.n_hedgers () == 2); // verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (10), Price(2002), Quantity (15), Quantity (5)); // verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); // verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); // verify_complete_hedger_state (leg_data_2.get_hedger (0).hedger(), HedgerState::WORKING, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20)); // verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), HedgerState::WORKING, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10)); // LOG(OrderMan, Diag, "spreader_WORKING.on_hedger_order_update"); // } // SECTION("13. on_external_error") // { // std::string err_msg = "error"; // spreader.on_external_error (err_msg); // verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); // generic_validate_quoters (QuoterState::WAITING_FOR_CANCEL_ACK, true); // generic_validate_hedgers (HedgerState::WAITING_FOR_CANCEL_ACK); // LOG(OrderMan, Diag, "spreader_WORKING.on_external_error"); // } // 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.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_FILLED, Quantity (70), Price (2001), nullptr); // bts_assert (leg_data_1.n_hedgers () == 4); // bts_assert (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).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); // verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); // verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); // verify_complete_hedger_state (leg_data_1.get_hedger (3).hedger(), 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).hedger(), HedgerState::WORKING, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20)); // verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), HedgerState::WORKING, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10)); // // 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.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (30), Price (2001), nullptr); // 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.on_child_update (leg_data_1.get_hedger (0).order_update_message().order_key(), api::orderman::OrderStatus::OS_FILLED, Quantity (15), Price (2002), nullptr); // verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity); // spreader.on_child_update (leg_data_1.get_hedger (1).order_update_message().order_key(), api::orderman::OrderStatus::OS_FILLED, Quantity (30), Price (2002), nullptr); // verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity); // spreader.on_child_update (leg_data_1.get_hedger (2).order_update_message().order_key(), api::orderman::OrderStatus::OS_FILLED, Quantity (10), Price (2002), nullptr); // verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity); // spreader.on_child_update (leg_data_1.get_hedger (3).order_update_message().order_key(), api::orderman::OrderStatus::OS_FILLED, Quantity (15), Price (2002), nullptr); // verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity); // spreader.on_child_update (leg_data_2.get_hedger (0).order_update_message().order_key(), api::orderman::OrderStatus::OS_FILLED, Quantity (20), Price (1999), nullptr); // verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity); // spreader.on_child_update (leg_data_2.get_hedger (1).order_update_message().order_key(), api::orderman::OrderStatus::OS_FILLED, Quantity (10), Price (1999), nullptr); // 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]") // { // ContractLeg leg_1, leg_2; // fill_future_contract_leg (leg_1, 2468, "ES", bts::api::Venue::VENUE_GLBX, 2017, 12, 15, 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, api::Side::SIDE_SELL, 1.0, 0.25); // std::vector legs; // legs.push_back (leg_1); // legs.push_back (leg_2); // QuoteParams qp_1, qp_2; // fill_quote_params (qp_1, 1.0); // fill_quote_params (qp_2, 1.0); // LegSpreaderParams leg_spreader_params_1, leg_spreader_params_2; // fill_leg_spreader_params (leg_spreader_params_1, 1.0, true, qp_1); // fill_leg_spreader_params (leg_spreader_params_2, -1.0, true, qp_2); // std::vector leg_spreader_params; // leg_spreader_params.push_back (leg_spreader_params_1); // leg_spreader_params.push_back (leg_spreader_params_2); // Price spreader_price = Price (1); // Quantity spreader_quantity = Quantity (100); // api::orderman::CreateOrderRequest cor; // fill_create_orderorder (cor, 422, spreader_price, spreader_quantity, api::Side::SIDE_BUY, legs, leg_spreader_params); // MySecDB db (legs); // NativeOrderFactory factory; // /*****************Creating the order********************/ // SpreaderOrder spreader (db,factory,OrderKey(1),cor); // // auto do_nothing = [] (auto const&) {}; // // spreader.init_signals(do_nothing, // // do_nothing, // // do_nothing, // // do_nothing, // // do_nothing); // spreader.init (); // spreader.on_connect (); // verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity); // 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}); // // verify working orders // SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data (); // SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1); // verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false); // verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false); // // send fill on leg 1 (20) // spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (20), Price (2000), nullptr); // verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false); // verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false); // // send another fill on leg 1 (10) // spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (30), Price (2000), nullptr); // 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.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (15), Price (2001), nullptr); // 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.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (45), Price (2001), nullptr); // verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(45), Price(2002), Quantity(55), Quantity(25), false); // verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (45), Quantity(30), Price(2000), Quantity(70), Quantity(25), false); // // send another fill on leg 2 (10) // spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (55), Price (2001), nullptr); // verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false); // verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); // // verify the hedgers // // leg 1 should have 3 hedgers, for each of the 3 fills // bts_assert (leg_data_1.n_hedgers() == 3); // for (size_t i = 0; i < leg_data_1.n_hedgers(); i++) // spreader.on_child_update (leg_data_1.get_hedger(i).order_update_message().order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); // for (size_t i = 0; i < leg_data_2.n_hedgers(); i++) // spreader.on_child_update (leg_data_2.get_hedger(i).order_update_message().order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); // verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); // verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); // verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); // bts_assert (leg_data_2.n_hedgers () == 2); // verify_complete_hedger_state (leg_data_2.get_hedger (0).hedger(), HedgerState::WORKING, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20)); // verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), HedgerState::WORKING, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10)); // LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.initializing"); // // now cancel the spreader // bts::TimeStamp cancel_timestamp = std::chrono::system_clock::now(); // spreader.on_time (cancel_timestamp); // spreader.on_cancel (bts::api::orderman::CancelSpreaderOrder()); // auto validate_state = [&]() -> void // { // verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); // bts_assert (leg_data_1.n_hedgers () == 3); // bts_assert (leg_data_2.n_hedgers () == 2); // verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false); // verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); // verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); // verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); // verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); // verify_complete_hedger_state (leg_data_2.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20)); // verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10)); // }; // validate_state (); // SECTION("1. init") // { // } // SECTION("2. on_connect") // { // } // SECTION("3. on_disconnect") // { // spreader.on_disconnect (); // verify_basic_spreader_state (spreader, SpreaderState::END, spreader_price, spreader_quantity); // // all quoters should go to end state // for (size_t i = 0; i < bookkeeping_data.n_legs(); i++) // { // SpreaderLegData& leg_data = bookkeeping_data.get_leg_data (i); // bts_assert (leg_data.quoter().test_only_func_quoter_state() == QuoterState::END); // // all hedgers should be in the end state // for (size_t h = 0; h < leg_data.n_hedgers(); h++) // bts_assert (leg_data.get_hedger (h).hedger().test_only_func_hedger_state() == HedgerState::END); // } // LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_disconnect"); // } // SECTION("4. on_update") // { // api::orderman::UpdateSpreaderOrder u; u.set_price(-0.05); u.set_quantity (200); // spreader.on_update (u); // validate_state(); // // order changes dont go through // validate_state(); // LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_update"); // } // SECTION("5. on_cancel") // { // api::orderman::CancelSpreaderOrder c; // spreader.on_cancel(c); // // 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, new double[5] {1999, 1998, 1997, 1996, 1995}, new uint16_t[5] {1, 0, 0, 0, 0}, // new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {1, 1, 2, 0, 0}, // new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {1, 0, 0, 0, 0}, // new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {1, 0, 0, 0, 0}); // validate_state (); // LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_book"); // } // SECTION("7. on_time") // { // while (spreader.test_only_func_spreader_state () != SpreaderState::END) // { // spreader.on_time (std::chrono::system_clock::now()); // std::this_thread::sleep_for(std::chrono::milliseconds(1)); // } // int64_t time_since_cxl = ms_diff (std::chrono::system_clock::now(), cancel_timestamp); // bts_assert (time_since_cxl >= spreader.test_cancel_timeout()); // verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::END, 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::END, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); // verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::END, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); // verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::END, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); // verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::END, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); // verify_complete_hedger_state (leg_data_2.get_hedger (0).hedger(), HedgerState::END, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20)); // verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), HedgerState::END, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10)); // LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_time"); // } // SECTION("8. on_quoter_order_error") // { // std::string err_msg = "error"; // spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (30), Price (2000), &err_msg); // validate_state(); // LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_quoter_order_error"); // } // SECTION("9. on_quoter_order_fill") // { // // send another fill on leg 1, this will update the filled // // state of leg 1, but no other action will take place // spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (40), Price (2000.5), nullptr); // verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); // bts_assert (leg_data_1.n_hedgers () == 3); // bts_assert (leg_data_2.n_hedgers () == 2); // verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (40), Quantity(55), Price(2003), Quantity(45), Quantity(5), false); // verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); // verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); // verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); // verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); // verify_complete_hedger_state (leg_data_2.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20)); // verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10)); // LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_quoter_order_fill"); // } // SECTION("10. on_quoter_order_status_update") // { // // cancelled update // spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (30), Price (2000), nullptr); // verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); // bts_assert (leg_data_1.n_hedgers () == 3); // bts_assert (leg_data_2.n_hedgers () == 2); // verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (0), Quantity(55), Price(0), Quantity(0), Quantity(15), false); // verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); // verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); // verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); // verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); // verify_complete_hedger_state (leg_data_2.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20)); // verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10)); // LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_quoter_order_status_update"); // } // SECTION("11. on_hedger_order_error") // { // std::string err_msg = "error"; // spreader.on_child_update (leg_data_1.get_hedger (0).order_update_message().order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), &err_msg); // validate_state (); // LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_hedger_order_error"); // } // SECTION("12. on_hedger_order_update") // { // // send a fill // spreader.on_child_update (leg_data_1.get_hedger (0).order_update_message().order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (10), Price (2000), nullptr); // verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false); // verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); // verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(15), Quantity (10), Price(2002), Quantity (15), Quantity (5)); // verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); // verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); // verify_complete_hedger_state (leg_data_2.get_hedger (0).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (1999), Quantity(20), Quantity (0), Price(1999), Quantity (20), Quantity (20)); // verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price (1999), Quantity(10), Quantity (0), Price(1999), Quantity (10), Quantity (10)); // LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_hedger_order_update"); // } // SECTION("13. on_external_error") // { // std::string err_msg = "error"; // spreader.on_external_error (err_msg); // validate_state (); // LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_external_error"); // } // SECTION("14. on_check_termination") // { // // send cancel for orders, once all quoters and hedgers // // are cancelled, spreader should come to end // spreader.on_child_update (leg_data_1.order_update_message().order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (30), Price (2000), nullptr); // verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (0), Quantity(55), Price(0), Quantity(0), Quantity(15), false); // spreader.on_child_update (leg_data_2.order_update_message().order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (55), Price (2000), nullptr); // verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(0), Quantity(0), Quantity(15), false); // verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); // spreader.on_child_update (leg_data_1.get_hedger (0).order_update_message().order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr); // verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::END, Price (2002), Quantity(15), Quantity (0), Price(0), Quantity (0), Quantity (15)); // spreader.on_child_update (leg_data_1.get_hedger (1).order_update_message().order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr); // verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::END, Price (2002), Quantity(30), Quantity (0), Price(0), Quantity (0), Quantity (30)); // spreader.on_child_update (leg_data_1.get_hedger (2).order_update_message().order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr); // verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::END, Price (2002), Quantity(10), Quantity (0), Price(0), Quantity (0), Quantity (10)); // spreader.on_child_update (leg_data_2.get_hedger (0).order_update_message().order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr); // verify_complete_hedger_state (leg_data_2.get_hedger (0).hedger(), HedgerState::END, Price (1999), Quantity(20), Quantity (0), Price(0), Quantity (0), Quantity (20)); // verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); // spreader.on_child_update (leg_data_2.get_hedger (1).order_update_message().order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr); // verify_complete_hedger_state (leg_data_2.get_hedger (1).hedger(), HedgerState::END, Price (1999), Quantity(10), Quantity (0), Price(0), Quantity (0), Quantity (10)); // verify_basic_spreader_state (spreader, SpreaderState::END, spreader_price, spreader_quantity); // LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_check_termination"); // } // } // class Temp // { // public: // int i; // Temp (int arg_i) : i (arg_i){} // }; // TEST_CASE ("ref test", "[spreader]") // { // Temp* t_ptr = new Temp (100); // Temp t_val = *t_ptr; // t_val.i = 200; // bts_assert (t_ptr->i == 100); // bts_assert (t_val.i == 200); // Temp& t_ref = *t_ptr; // t_ref.i = 200; // bts_assert (t_ptr->i == 200); // bts_assert (t_ref.i == 200); // t_ptr->i = 300; // bts_assert (t_ptr->i == 300); // bts_assert (t_ref.i == 300); // } // TEST_CASE ("vector ref test", "[spreader]") // { // Temp t_val (0); // std::vector t_vect; // t_vect.push_back (t_val); // t_vect.push_back (t_val); // t_vect.push_back (t_val); // Temp& t_ref = t_vect[1]; // t_ref.i = 100; // bts_assert (t_vect[1].i == 100); // for (auto it = t_vect.begin(); it != t_vect.end(); it++) // { // Temp& t_it_ref = *it; // t_it_ref.i = 115; // } // bts_assert (t_vect[1].i == 115); // } // class D{ // public: // double d; // D (const D&) = delete; // // D (D&& o) // // { // // d = o.d; // // } // // D& operator=(D&& o) // // { // // d = o.d; // // return *this; // // } // }; // class C{ // public: // std::vector d; // C () // { // //d.reserve (10); // } // }; }}