#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") { 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") { 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") { 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") { 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 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]") { // 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); // leg property data 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); QuoteParams qp_1, qp_2, qp_3; fill_quote_params(qp_1, lean_ratio_1); fill_quote_params(qp_2, lean_ratio_2); fill_quote_params(qp_3, lean_ratio_3); LegSpreaderParams lsp_1, lsp_2, lsp_3; fill_leg_spreader_params (lsp_1, price_mult_1, true, qp_1); fill_leg_spreader_params (lsp_2, price_mult_2, true, qp_2); fill_leg_spreader_params (lsp_3, price_mult_3, true, qp_3); LegPropertyData leg_prop_data_1 (0, leg_1, lsp_1, api::Side::SIDE_SELL); LegPropertyData leg_prop_data_2 (1, leg_2, lsp_2, api::Side::SIDE_BUY); LegPropertyData leg_prop_data_3 (2, leg_3, lsp_3, api::Side::SIDE_SELL); Book book1, book2, book3; // SpreaderManager std::vector legs; legs.push_back (leg_prop_data_1);legs.push_back (leg_prop_data_2);legs.push_back (leg_prop_data_3); std::vector books; books.push_back (book1);books.push_back (book2);books.push_back (book3); SpreaderManagerForTest spreader_manager (legs, books); // quoter SingleLegQuoter quoter_1 (spreader_manager, leg_prop_data_1, 3, spread_price , spread_quantity, bts::orderman::SpreaderOrderBase::ChildOrder()); SingleLegQuoter quoter_2 (spreader_manager, leg_prop_data_2, 3, spread_price , spread_quantity, bts::orderman::SpreaderOrderBase::ChildOrder()); SingleLegQuoter quoter_3 (spreader_manager, leg_prop_data_3, 3, spread_price , spread_quantity, bts::orderman::SpreaderOrderBase::ChildOrder()); // bookkeeping data std::vector leg_data_v; leg_data_v.push_back (SpreaderLegData (leg_prop_data_1, "er_1, order_key_1)); leg_data_v.push_back (SpreaderLegData (leg_prop_data_2, "er_2, order_key_2)); leg_data_v.push_back (SpreaderLegData (leg_prop_data_3, "er_3, order_key_3)); SpreaderBookkeepingData bookkeeping_data (leg_data_v, spread_price, spread_quantity); SECTION("verify security key access") { SpreaderLegData res_3 = bookkeeping_data.get_leg_data (SecurityKey (sec_key_3)); 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.get_leg_data (SecurityKey (sec_key_2)); 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.get_leg_data (SecurityKey (sec_key_1)); 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); } SECTION("verify index access") { SpreaderLegData res_3 = bookkeeping_data.get_leg_data (2); 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.get_leg_data (1); 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.get_leg_data (0); 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); } 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 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 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 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 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]") { Price spreader_price = Price (0.35); Quantity spreader_quantity (100); SpreaderManagerForTest sm = create_spreader_manager_2_legs (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); SingleLegQuoter quoter (sm, sm.get_leg_data (1), 2, spreader_price, spreader_quantity, bts::orderman::SpreaderOrderBase::ChildOrder()); SECTION("0. transition_to_start") { verify_complete_quoter_state (quoter, QuoterState::START, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (100), false); LOG(OrderMan, Diag, "quoter_START_state.transition_to_start"); } SECTION("1. init") { verify_complete_quoter_state (quoter, QuoterState::START, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (100), false); quoter.init (); 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, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (100), false); quoter.cancel_order(); verify_complete_quoter_state (quoter, QuoterState::END, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (100), false); LOG(OrderMan, Diag, "quoter_START_state.cancel_order"); } SECTION("5. terminate") { verify_complete_quoter_state (quoter, QuoterState::START, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (100), false); quoter.cancel_order(); verify_complete_quoter_state (quoter, QuoterState::END, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (100), false); LOG(OrderMan, Diag, "quoter_START_state.terminate"); } SECTION("7. update_other_leg_fills") { verify_complete_quoter_state (quoter, QuoterState::START, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (100), false); quoter.update_other_leg_fills (0, Quantity(50)); verify_complete_quoter_state (quoter, QuoterState::START, 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::START, 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_START_state.update_other_leg_fills"); } SECTION("8. update_order_price_quantity") { verify_complete_quoter_state (quoter, QuoterState::START, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (100), false); spreader_price = Price (0.5); spreader_quantity = Quantity (200); quoter.update_order_price_quantity (spreader_price, spreader_quantity); verify_complete_quoter_state (quoter, QuoterState::START, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (200), 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_START_state.update_order_price_quantity"); } } TEST_CASE ("quoter_WAITING_FOR_SIZE_state", "[spreader]") { Price spreader_price = Price (0.35); Quantity spreader_quantity (100); SpreaderManagerForTest sm = create_spreader_manager_2_legs (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); SingleLegQuoter quoter (sm, sm.get_leg_data (1), 2, spreader_price, spreader_quantity, bts::orderman::SpreaderOrderBase::ChildOrder()); quoter.init (); 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]") { Price spreader_price = Price (0.35); Quantity spreader_quantity (100); SpreaderManagerForTest sm = create_spreader_manager_2_legs (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); SingleLegQuoter quoter (sm, sm.get_leg_data (1), 2, spreader_price, spreader_quantity, bts::orderman::SpreaderOrderBase::ChildOrder()); quoter.init (); 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") { SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0)); u.update (api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (70), Price (2000), nullptr); 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") { SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0)); u.update (api::orderman::OrderStatus::OS_FILLED, Quantity (100), Price (2000), nullptr); 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]") { Price spreader_price = Price (0.35); Quantity spreader_quantity (100); SpreaderManagerForTest sm = create_spreader_manager_2_legs (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); SingleLegQuoter quoter (sm, sm.get_leg_data (1), 2, spreader_price, spreader_quantity, bts::orderman::SpreaderOrderBase::ChildOrder()); quoter.init (); 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") { SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0)); u.update (api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (70), Price (2000), nullptr); 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") { SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0)); u.update (api::orderman::OrderStatus::OS_FILLED, Quantity (100), Price (2000), nullptr); 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]") { Price spreader_price = Price (0.35); Quantity spreader_quantity (100); SpreaderManagerForTest sm = create_spreader_manager_2_legs (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); SingleLegQuoter quoter (sm, sm.get_leg_data (1), 2, spreader_price, spreader_quantity, bts::orderman::SpreaderOrderBase::ChildOrder()); quoter.init (); 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 (); SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0)); u.update (api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (0), Price (0), nullptr); 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::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (70), Price (2000), nullptr); 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::orderman::OrderStatus::OS_FILLED, Quantity (100), Price (2000), nullptr); 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]") { Price spreader_price = Price (0.35); Quantity spreader_quantity (100); SpreaderManagerForTest sm = create_spreader_manager_2_legs (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); SingleLegQuoter quoter (sm, sm.get_leg_data (1), 2, spreader_price, spreader_quantity, bts::orderman::SpreaderOrderBase::ChildOrder()); quoter.init (); 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 SpreaderOrderUpdateMessage u (OrderKey(0)); u.update (api::orderman::OrderStatus::OS_FILLED, Quantity (75), Price (2000), nullptr); 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); SpreaderOrderUpdateMessage u (OrderKey(0)); u.update (api::orderman::OrderStatus::OS_FILLED, Quantity (75), Price (2000), nullptr); 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]") { Price spreader_price = Price (0.5); Quantity spreader_quantity (100); SpreaderManagerForTest sm = create_spreader_manager_2_legs (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); SingleLegQuoter quoter (sm, sm.get_leg_data (1), 2, spreader_price, spreader_quantity, bts::orderman::SpreaderOrderBase::ChildOrder()); quoter.init (); 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); SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0)); u.update (api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); quoter.update_order_status (u); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.50), Quantity(40), Quantity (100), false); SECTION("2. reduced_size_update_order_status_non_terminal") { // partial fills u.update (api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (15), Price (2000), nullptr); quoter.update_order_status (u); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(15), Quantity(0), Price(2000.50), 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::orderman::OrderStatus::OS_FILLED, Quantity (40), Price (2000), nullptr); 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::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (20), Price (2000), nullptr); 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::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (10), Price (2000), nullptr); 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::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (10), Price (2000), nullptr); 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]") { Price spreader_price = Price (0.5); Quantity spreader_quantity (100); SpreaderManagerForTest sm = create_spreader_manager_2_legs (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); SingleLegQuoter quoter (sm, sm.get_leg_data (1), 2, spreader_price, spreader_quantity, bts::orderman::SpreaderOrderBase::ChildOrder()); quoter.init (); 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); SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0)); u.update (api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); quoter.update_order_status (u); verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.50), 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::orderman::OrderStatus::OS_FILLED, Quantity (40), Price (2000), nullptr); 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 SpreaderOrderUpdateMessage u2 (bts::orderman::OrderKey(0)); u2.update (api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); 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::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (5), Price (2000), nullptr); 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::orderman::OrderStatus::OS_FILLED, Quantity (45), Price (2000), nullptr); 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 SpreaderOrderUpdateMessage u3 (bts::orderman::OrderKey(0)); u3.update (api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); 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::orderman::OrderStatus::OS_FILLED, Quantity (15), Price (2000), nullptr); 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]") { Price hedger_price = Price (0.5); Quantity hedger_quantity (20); SpreaderManagerForTest sm = create_spreader_manager_2_legs (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); SingleFillHedger hedger (sm, sm.get_leg_data (1), bts::orderman::SpreaderOrderBase::ChildOrder(), hedger_price, hedger_quantity, api::Side::SIDE_SELL); 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::WAITING_FOR_FIRST_ACK, 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]") { Price hedger_price = Price (2000.0); Quantity hedger_quantity (20); SpreaderManagerForTest sm = create_spreader_manager_2_legs (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); SingleFillHedger hedger (sm, sm.get_leg_data (1), bts::orderman::SpreaderOrderBase::ChildOrder(), hedger_price, hedger_quantity, api::Side::SIDE_SELL); 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") { SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0)); u.update (api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (5), Price (2000), nullptr); 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") { SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0)); u.update (api::orderman::OrderStatus::OS_FILLED, Quantity (20), Price (2000), nullptr); 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]") { Price hedger_price = Price (2000.0); Quantity hedger_quantity (20); SpreaderManagerForTest sm = create_spreader_manager_2_legs (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); SingleFillHedger hedger (sm, sm.get_leg_data (1), bts::orderman::SpreaderOrderBase::ChildOrder(), hedger_price, hedger_quantity, api::Side::SIDE_SELL); 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") { SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0)); u.update (api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (5), Price (2000), nullptr); 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") { SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0)); u.update (api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr); 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]") { Price hedger_price = Price (2000.0); Quantity hedger_quantity (20); SpreaderManagerForTest sm = create_spreader_manager_2_legs (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); SingleFillHedger hedger (sm, sm.get_leg_data (1), bts::orderman::SpreaderOrderBase::ChildOrder(), hedger_price, hedger_quantity, api::Side::SIDE_SELL); 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); SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0)); u.update (api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); 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 SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0)); u.update (api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (5), Price (2000), nullptr); 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::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (10), Price (2000), nullptr); 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::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (15), Price (2000), nullptr); 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::orderman::OrderStatus::OS_CANCELED, Quantity (15), Price (2000), nullptr); 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]") { Price hedger_price = Price (2000.0); Quantity hedger_quantity (20); SpreaderManagerForTest sm = create_spreader_manager_2_legs (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); SingleFillHedger hedger (sm, sm.get_leg_data (1), bts::orderman::SpreaderOrderBase::ChildOrder(), hedger_price, hedger_quantity, api::Side::SIDE_SELL); hedger.init (); SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0)); u.update (api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); hedger.on_order_update (u); hedger.cancel_hedge (); u.update (api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr); 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::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr); 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]") { Price hedger_price = Price (2000.0); Quantity hedger_quantity (20); SpreaderManagerForTest sm = create_spreader_manager_2_legs (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); SingleFillHedger hedger (sm, sm.get_leg_data (1), bts::orderman::SpreaderOrderBase::ChildOrder(), hedger_price, hedger_quantity, api::Side::SIDE_SELL); hedger.init (); SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0)); u.update (api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); 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::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (7), Price (2000), nullptr); 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::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (15), Price (2000), nullptr); 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::orderman::OrderStatus::OS_FILLED, Quantity (20), Price (2000), nullptr); 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"); } } 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); SECTION("1. init") { verify_basic_spreader_state (spreader, SpreaderState::START, spreader_price, spreader_quantity); spreader.init (); verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_FIRST_CONNECT, spreader_price, spreader_quantity); LOG(OrderMan, Diag, "spreader_START.init"); } 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::START, Price (-0.05), Quantity (200)); LOG(OrderMan, Diag, "spreader_START.init"); } 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_START.on_cancel"); } SECTION("13. on_external_error") { std::string err_msg = "stop and celebrate"; spreader.on_external_error (err_msg); verify_basic_spreader_state (spreader, SpreaderState::END, spreader_price, spreader_quantity); 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); 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 spreaders should be in the end state LOG(OrderMan, Diag, "spreader_WORKING.on_disconnect"); } SECTION("4. on_update") { api::orderman::UpdateSpreaderOrder u; u.set_price(-0.05); u.set_quantity (200); spreader.on_update (u); verify_basic_spreader_state (spreader, SpreaderState::WORKING, Price (-0.05), Quantity (200)); // check spreader states LOG(OrderMan, Diag, "spreader_WORKING.on_update"); } SECTION("5. on_cancel") { api::orderman::CancelSpreaderOrder c; spreader.on_cancel(c); verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); // check spreader states LOG(OrderMan, Diag, "spreader_WORKING.on_cancel"); } SECTION("6. on_book") { SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data (); SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1); // send a book a on leg 1, this should make // leg 2 send out an order - verify that Book book_leg_1 = get_book (SecurityKey (leg_1.security().id()), 5, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10}, new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {10, 15, 25, 50, 10}, true); spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_1); validate_book (book_leg_1, leg_data_1.book()); verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_SIZE, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(0), Quantity(0), Quantity(100), false); verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false); // send a book on leg 2, this should make // leg 1 send out an order, so orders on // both legs should be out there now Book book_leg_2 = get_book (SecurityKey (leg_2.security().id()), 5, new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {20, 20, 20, 20, 20}, new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {10, 10, 10, 10, 10}, true); spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_2); validate_book (book_leg_2, leg_data_2.book()); verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false); verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false); bts_assert (leg_data_1.order_key().value() != leg_data_2.order_key().value()); spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false); verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false); spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false); verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false); // change the books and make sure the quoter // adjusts its order book_leg_1 = get_book (SecurityKey (leg_1.security().id()), 5, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10}, new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {10, 10, 10, 10, 10}, true); spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_1); validate_book (book_leg_1, leg_data_1.book()); verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false); verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2003), Quantity(50), Quantity(100), false); book_leg_2 = get_book (SecurityKey (leg_2.security().id()), 5, new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {1, 2, 10, 1, 1}, new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {10, 10, 10, 10, 10}, true); spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_2); validate_book (book_leg_2, leg_data_2.book()); verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(15), Quantity(100), false); verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2003), Quantity(50), Quantity(100), false); // remove the markets and the orders should be cancelled book_leg_1 = get_book (SecurityKey (leg_1.security().id()), 5, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {0, 0, 0, 0, 0}, new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {0, 0, 0, 0, 0}, true); book_leg_2 = get_book (SecurityKey (leg_2.security().id()), 5, new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {0, 0, 0, 0, 0}, new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {0, 0, 0, 0, 0}, true); spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_1); spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_2); verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(15), Quantity(100), false); verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2003), Quantity(50), Quantity(100), false); LOG(OrderMan, Diag, "spreader_WORKING.on_book"); } SECTION("7. on_time") { } SECTION("8. on_quoter_order_error") { // get orders in working state // and send an error set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10}, new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {10, 15, 25, 50, 10}, new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {20, 20, 20, 20, 20}, new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {10, 10, 10, 10, 10}); // verify working orders SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data (); SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1); verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false); verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false); // send an error now, both quoters should // go to cancel waiting std::string err_msg = "error"; spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), &err_msg); verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false); verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false); LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_error"); } SECTION("9. on_quoter_order_fill") { set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10}, new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {10, 15, 25, 50, 10}, new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {20, 20, 20, 20, 20}, new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {10, 10, 10, 10, 10}); // verify working orders SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data (); SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1); verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false); verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false); // now send a 20 lot fill in leg 1, // verify leg 1's order data // verify leg 2's order data // verify that there a hedging order is worked spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (20), Price (2000), nullptr); verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false); verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false); std::vector& hedgers_leg_2 = leg_data_2.get_hedgers(); bts_assert (hedgers_leg_2.size() == 1); SingleFillHedger& hedger = hedgers_leg_2[0].hedger(); verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20)); LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_error"); } SECTION("10. on_quoter_order_status_update") { // already done in 9 } SECTION("11. on_hedger_order_error") { //create the same scenario as 9, but send an error on the hedger order set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10}, new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {10, 15, 25, 50, 10}, new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {20, 20, 20, 20, 20}, new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {10, 10, 10, 10, 10}); // verify working orders SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data (); SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1); verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false); verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false); spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (20), Price (2000), nullptr); verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false); verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false); std::vector& hedgers_leg_2 = leg_data_2.get_hedgers(); bts_assert (hedgers_leg_2.size() == 1); SingleFillHedger& hedger = hedgers_leg_2[0].hedger(); verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20)); bts::orderman::OrderKey hedger_order_key = hedgers_leg_2[0].order_update_message().order_key; spreader.on_child_update (hedger_order_key, api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); verify_complete_hedger_state (hedger, HedgerState::WORKING, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20)); std::string err_msg = "error"; spreader.on_child_update (hedger_order_key, api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), &err_msg); verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false); verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false); verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_CANCEL_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20)); // verify that all quoter and hedgers should LOG(OrderMan, Diag, "spreader_WORKING.on_hedger_order_error"); } SECTION("12. on_hedger_order_update") { //create the same scenario as 9, but send an error on the hedger order set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10}, new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {10, 15, 25, 50, 10}, new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {20, 20, 20, 20, 20}, new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {10, 10, 10, 10, 10}); // verify working orders SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data (); SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1); verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false); verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false); spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (20), Price (2000), nullptr); verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false); verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false); std::vector& hedgers_leg_2 = leg_data_2.get_hedgers(); bts_assert (hedgers_leg_2.size() == 1); SingleFillHedger& hedger = hedgers_leg_2[0].hedger(); verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20)); // send fill on the hedger order bts::orderman::OrderKey hedger_order_key = hedgers_leg_2[0].order_update_message().order_key; spreader.on_child_update (hedger_order_key, api::orderman::OrderStatus::OS_NEW, Quantity (5), Price (2000), nullptr); verify_complete_hedger_state (hedger, HedgerState::WORKING, Price(1999), Quantity(20), Quantity(5), Price (1999), Quantity(20), Quantity (15)); // verify that all quoter and hedgers should LOG(OrderMan, Diag, "spreader_WORKING.on_hedger_order_update"); } SECTION("13. on_external_error") { SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data (); SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1); set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10}, new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {10, 15, 25, 50, 10}, new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {20, 20, 20, 20, 20}, new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {10, 10, 10, 10, 10}); spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (20), Price (2000), nullptr); SpreaderHedgerData& hedger_data = leg_data_2.get_hedgers()[0]; spreader.on_child_update (hedger_data.order_update_message().order_key, api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr); std::string err_msg = "external error"; spreader.on_external_error (err_msg); verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false); verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false); verify_complete_hedger_state (hedger_data.hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20)); LOG(OrderMan, Diag, "spreader_WORKING.on_external_error"); } SECTION("14. on_check_termination") { // get active orders working, send a terminal // status on each order and verify that the // spreader reached a terminal state SpreaderBookkeepingData& bookkeeping_data = spreader.test_only_func_spreader_full_data (); SpreaderLegData& leg_data_1 = bookkeeping_data.get_leg_data (0); SpreaderLegData& leg_data_2 = bookkeeping_data.get_leg_data (1); set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10}, new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {10, 15, 25, 50, 10}, new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {20, 20, 20, 20, 20}, new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {10, 10, 10, 10, 10}); verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity); // completely fill leg 1, this should cxl the leg 2 quoting order and send a hedge // fill the hedge completely // this should cause on_check_termination to return true spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_FILLED, Quantity (100), Price (1999), nullptr); // leg1's quoter should be in end state verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(0), Quantity(0), Quantity(0), true); // leg 2 should cancel its order now verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(100), Price(2002), Quantity(100), Quantity(0), true); spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr); verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(100), Price(0), Quantity(0), Quantity(0), true); bts_assert (leg_data_2.get_hedgers().size() == 1); SpreaderHedgerData leg_2_hedger_data = leg_data_2.get_hedgers()[0]; verify_complete_hedger_state (leg_2_hedger_data.hedger(), HedgerState::WAITING_FOR_FIRST_ACK, Price(1998), Quantity(100), Quantity(0), Price (1998), Quantity(100), Quantity (100)); verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity); // send a fill, this should make the spreader go to end spreader.on_child_update (leg_2_hedger_data.order_update_message().order_key, api::orderman::OrderStatus::OS_FILLED, Quantity (100), Price (1998), nullptr); verify_complete_hedger_state (leg_2_hedger_data.hedger(), HedgerState::END, Price(1998), Quantity(100), Quantity(100), Price (0), Quantity(0), Quantity (0)); verify_basic_spreader_state (spreader, SpreaderState::END, spreader_price, spreader_quantity); LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_error"); } } 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 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.count(); i++) { SpreaderLegData& leg_data = bookkeeping_data.get_leg_data (i); bts_assert (leg_data.quoter()->test_only_func_quoter_state() == QuoterState::END); // all hedgers should be in the end state for (size_t h = 0; h < leg_data.n_hedgers(); h++) bts_assert (leg_data.get_hedger (h).hedger().test_only_func_hedger_state() == HedgerState::END); } LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_disconnect"); } SECTION("4. on_update") { api::orderman::UpdateSpreaderOrder u; u.set_price(-0.05); u.set_quantity (200); spreader.on_update (u); 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") { } 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); } }}