From bc4643fbf3ca34fac620274dd63e473138c9ebb4 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Fri, 25 May 2018 17:33:23 -0400 Subject: [PATCH] spreader tests --- src/lib/sparkproto/SparkProtos.proto | 3 +- .../spreader_orders/spreader/SpreaderUtils.h | 255 +++++----- .../spreader_orders/tests/spreader_tests.cpp | 454 ++++++++++-------- .../spreader_orders/tests/tests_common.h | 6 +- 4 files changed, 393 insertions(+), 325 deletions(-) diff --git a/src/lib/sparkproto/SparkProtos.proto b/src/lib/sparkproto/SparkProtos.proto index b20408805..64ec4b535 100644 --- a/src/lib/sparkproto/SparkProtos.proto +++ b/src/lib/sparkproto/SparkProtos.proto @@ -304,7 +304,8 @@ message PreHedgeQuantityBasedPayupTicks /*******************************PreHedge QuantityBasedPayLessTicks************************************* [Pre-Hedge] -If the quantity at the calculated hedge price is greater than the 'Threshold' +If the cumulative quantity at the calculated hedge price (in the target side of the +hedge order ie sell side for buy hedges and vice verca) is greater than the 'Threshold' then pay less by payup_ticks ticks BTS def: diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.h b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.h index 504b10a3f..9c94f5112 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.h @@ -27,9 +27,9 @@ namespace orderman { class SpreaderUtils { public: - /**********************************************************************/ - /**************************General Spreader****************************/ - /**********************************************************************/ + //////////////////////////////////////////// + // misc //////////////////////////////////// + //////////////////////////////////////////// // based on the side of the spreader order, // returns the side of the leg api::Side static get_leg_side(api::Side spreader_order_side, @@ -38,6 +38,24 @@ public: api::Side static invert_side(api::Side side){ return side == api::SIDE_BUY ? api::SIDE_SELL : api::SIDE_BUY; } + // returns the effective threshold quantity, based + // on the absolute or ratio setting in + // QuantityMeasure (the second arg is used in the + // case of ratio) + static Quantity _quantity_threshold (const bts::spark::QuantityMeasure& quantity_measure, + Quantity current_quantity){ + switch(quantity_measure.quantity_case()){ + case bts::spark::QuantityMeasure::QuantityCase::kAbsolute: + return Quantity(quantity_measure.absolute()); + case bts::spark::QuantityMeasure::QuantityCase::kRatio: + return Quantity(static_cast(quantity_measure.ratio() * current_quantity.value())); + case bts::spark::QuantityMeasure::QuantityCase::QUANTITY_NOT_SET: + bts_assert (false); + return Quantity (0); + } + bts_assert (false); + return Quantity(0); + } // Resolves the securities and returns LegPropertyData for eacg // Returns false if // i. can not resolve the spreader security @@ -48,55 +66,45 @@ public: const api::orderman::OrderDefinition& order_def, std::vector& out_resolved, bool resolve_synthetic = true); - // not in the critical path - // builds the order builders for the quoting orders - static void build_order_builders (bts::orderman::OrderKey spreader_order_key, - const SpreaderPreActivationOrderServices& spreader_pao_services, - const std::vector& spreader_legs, - size_t reserve_sz, - bool is_quoter, - std::vector& out_vals) - { - out_vals.reserve(spreader_legs.size()); - for (auto l_it = spreader_legs.begin(); l_it != spreader_legs.end(); l_it++) - out_vals.emplace_back(spreader_order_key, is_quoter ? l_it->quoter_order_definition() : l_it->hedger_order_definition(), spreader_pao_services, reserve_sz); - } - /**********************************************************************/ - /*******************************Orders*********************************/ - /**********************************************************************/ - static bool order_in_error_state(const bts::orderman::OrderStateUpdateEvent& ord_ev) - { - bts::api::orderman::OrderStatus order_status = ord_ev.state.status(); - return order_in_error_state(order_status) || - (!order_in_terminal_state (order_status) && ord_ev.state.last_msg().length() > 0); - } - static bool order_in_error_state(bts::api::orderman::OrderStatus order_status) - { + //////////////////////////////////////////// + // orders ////////////////////////////////// + //////////////////////////////////////////// + // checks for the 3 states that are designated error states + static bool order_in_error_state(bts::api::orderman::OrderStatus order_status){ return order_status == api::orderman::OrderStatus::ORDER_STATUS_ERROR || order_status == api::orderman::OrderStatus::ORDER_STATUS_DISCONNECTED || order_status == api::orderman::OrderStatus::ORDER_STATUS_REJECTED_BY_SPARK; } - static bool order_in_terminal_state(bts::api::orderman::OrderStatus order_status) - { + // this function checks for the order status (above) or + // for the message size (todo:this is a temporary fix) + static bool order_in_error_state(const bts::orderman::OrderStateUpdateEvent& ord_ev){ + bts::api::orderman::OrderStatus order_status = ord_ev.state.status(); + return order_in_error_state(order_status) || + (!order_in_terminal_state (order_status) && ord_ev.state.last_msg().length() > 0); + } + // checks for the 4 states that are designated error states + static bool order_in_terminal_state(bts::api::orderman::OrderStatus order_status){ return order_status == api::orderman::OrderStatus::ORDER_STATUS_COMPLETED || order_status == api::orderman::OrderStatus::ORDER_STATUS_CANCELED || order_status == api::orderman::OrderStatus::ORDER_STATUS_ERROR || order_status == api::orderman::OrderStatus::ORDER_STATUS_REJECTED_BY_SPARK; } - static bool order_acknowledged (bts::api::orderman::OrderStatus order_status) - { + static bool order_acknowledged (bts::api::orderman::OrderStatus order_status){ bool un_acked = order_status == api::orderman::OrderStatus::ORDER_STATUS_INACTIVE || order_status == api::orderman::OrderStatus::ORDER_STATUS_PENDING_WORKING; return !un_acked; } - static bool order_in_cancelled_state (bts::api::orderman::OrderStatus order_status) {return order_status == api::orderman::OrderStatus::ORDER_STATUS_CANCELED;} - /**********************************************************************/ - /****************************Market Data*******************************/ - /**********************************************************************/ + static bool order_in_cancelled_state (bts::api::orderman::OrderStatus order_status){ + return order_status == api::orderman::OrderStatus::ORDER_STATUS_CANCELED; + } + //////////////////////////////////////////// + // market data ///////////////////////////// + //////////////////////////////////////////// // CRITICAL PATH (quoting) // this traverses the depth of the book, accumulating the quantity, - // till the target quantity is reached. if the target quantity is not - // reached the out_quantity < target_quantity + // till the target quantity is reached. + // this function is run for each quoting leg everytime the hedging + // leg changes void static traverse_depth_for_quantity(const orderman::Book& leg_book, const api::Side book_side, Quantity target_quantity, @@ -118,7 +126,7 @@ public: last_nonzero_level = level; cum_quantity_u += level_qty; if (cum_quantity_u >= target_quantity.value()){ - // early break, we have already accumulted the target + // early break, we have already accumulated the target cum_quantity_u = target_quantity.value(); break; } @@ -135,18 +143,20 @@ public: bts_assert(out_quantity.value() <= target_quantity.value()); } // CRITICAL PATH (for hedging) - // travserses the book to locate the target_price, and find the qty at the - // target price and the cum qty upto that price. - // return false if the target_price is not found. + // travserses the book to locate the target_price, + // and finds the qty at the target price and the + // cum qty upto that price. + // returns false if the target_price is not found. // this is used to find the qty and cumm_qty - static bool find_qty_at_price_level (const Book& book, api::Side book_side, Price target_price, double tick_size, - Quantity& price_qty, Quantity& cumm_qty) - { + static bool find_qty_at_price_level (const Book& book, + api::Side book_side, + Price target_price, + double tick_size, + Quantity& price_qty, Quantity& cumm_qty){ price_qty = Quantity(0); cumm_qty = Quantity(0); const size_t n_levels = book.n_levels(); const bts::orderman::BookSide& book_depth = book.side(book_side); - for (size_t level = 0; level < n_levels; level++) - { + for (size_t level = 0; level < n_levels; level++){ const md::PriceSize& level_price_qty = book_depth[level]; double level_price = level_price_qty.price(); price_qty = Quantity(level_price_qty.size()); @@ -156,32 +166,30 @@ public: } price_qty = Quantity(0); cumm_qty = Quantity(0); return false; - } - - /**********************************************************************/ - /****************************Quoting Params****************************/ - /**********************************************************************/ + } + //////////////////////////////////////////// + // quoting params ////////////////////////// + //////////////////////////////////////////// // given the new price, applies the quoting parameters (mute etc) // to see if quote needs to be repriced - static bool reprice_quote_mute_zone(double current_price, double new_price, api::Side quote_side, double tick_size, - const bts::spark::QuoteMuteZone& quote_mute_zone) - { + static bool reprice_quote_mute_zone(double current_price, + double new_price, + api::Side quote_side, + double tick_size, + const bts::spark::QuoteMuteZone& quote_mute_zone){ int price_change_ticks = bts::securities::price_diff_to_ticks (current_price, new_price, tick_size); - if (price_change_ticks != 0) - { + if (price_change_ticks != 0){ bool price_increasing = price_change_ticks > 0; uint32_t abs_price_change_ticks = static_cast(std::abs(price_change_ticks)); LOG(OrderMan, Info, "SpreaderUtils::reprice_quote_mute_zone current_price: {} new_price: {} price_change_ticks: {} abs_price_change_ticks: {} inside_limit_ticks: {} outside_limit_ticks: {}", current_price, new_price, price_change_ticks, abs_price_change_ticks, quote_mute_zone.inside_ticks(), quote_mute_zone.outside_ticks()); - if (quote_side == api::SIDE_BUY) - { + if (quote_side == api::SIDE_BUY){ if (price_increasing) // moving toward inside market return abs_price_change_ticks > quote_mute_zone.inside_ticks(); else return abs_price_change_ticks > quote_mute_zone.outside_ticks(); } - else - { + else{ if (!price_increasing) // moving toward inside market return abs_price_change_ticks > quote_mute_zone.inside_ticks(); else @@ -191,87 +199,52 @@ public: else return false; } - /**********************************************************************/ - /****************************Pre Hedge Params**************************/ - /**********************************************************************/ - - static double prehedge_max_price_from_inside_market (double hedge_price, api::Side hedge_side, const bts::orderman::Book& book, double tick_size, - const bts::spark::PreHedgeMaxPriceFromInsideMarket& max_price_from_inside_market) - { + //////////////////////////////////////////// + // pre-hedge params //////////////////////// + //////////////////////////////////////////// + // (unused and untested) this function caps the hedge price + // to only be a user defined interval away from the opposite + // inside market + static double prehedge_max_price_from_inside_market (double hedge_price, + api::Side hedge_side, + const bts::orderman::Book& book, + double tick_size, + const bts::spark::PreHedgeMaxPriceFromInsideMarket& max_price_from_inside_market){ double max_dist_from_inside_market = max_price_from_inside_market.hedge_tick_limit() * tick_size; - if (hedge_side == api::SIDE_BUY) - { + if (hedge_side == api::SIDE_BUY){ const md::PriceSize& inside_price_size = book.side(api::Side::SIDE_SELL)[0]; - if (inside_price_size.size() > 0) - { + if (inside_price_size.size() > 0){ double inside_price = inside_price_size.price(); if (hedge_price > inside_price + max_dist_from_inside_market) hedge_price = inside_price + max_dist_from_inside_market; } } - else - { + else{ const md::PriceSize& inside_price_size = book.side(api::Side::SIDE_SELL)[0]; - if (inside_price_size.size() > 0) - { + if (inside_price_size.size() > 0){ double inside_price = inside_price_size.price(); if (hedge_price < inside_price + max_dist_from_inside_market) hedge_price = inside_price + max_dist_from_inside_market; } } return hedge_price; - } - - static Quantity _quantity_threshold (const bts::spark::QuantityMeasure& quantity_measure, Quantity current_quantity) - { - switch(quantity_measure.quantity_case()) - { - case bts::spark::QuantityMeasure::QuantityCase::kAbsolute: - return Quantity(quantity_measure.absolute()); - case bts::spark::QuantityMeasure::QuantityCase::kRatio: - return Quantity(static_cast(quantity_measure.ratio() * current_quantity.value())); - case bts::spark::QuantityMeasure::QuantityCase::QUANTITY_NOT_SET: - bts_assert (false); - return Quantity (0); - } - bts_assert (false); - return Quantity(0); } - - static bool prehedge_quantity_base_payup_ticks_reprice (const spark::PreHedgeQuantityBasedPayupTicks& params, const Book& book, api::Side hedge_side, double tick_size, - Price current_price, Quantity current_qty, Price& out_price) - { - out_price = current_price; - api::Side book_side = invert_side(hedge_side); - Quantity price_level_qty, cumm_qty; - bool find_qty_at_price = find_qty_at_price_level (book, book_side, current_price, tick_size, price_level_qty, cumm_qty); - if (find_qty_at_price) - { - Quantity qty_threshold = _quantity_threshold(params.quantity_threshold(), current_qty); - if (price_level_qty.value() < qty_threshold.value()) - { - if (hedge_side == api::Side::SIDE_BUY) - out_price = Price(current_price.value() + tick_size * params.payup_ticks()); - else - out_price = Price(current_price.value() - tick_size * params.payup_ticks()); - return true; - } - } - return false; - } - - static bool prehedge_quantity_base_payless_ticks_reprice (const spark::PreHedgeQuantityBasedPayLessTicks& params, const Book& book, api::Side hedge_side, double tick_size, - Price current_price, Quantity current_qty, Price& out_price) - { + // this function finds the cum qty at hedge price (on the target side of + // the hedge), and pays less if the cum_qty is > threshold + static bool prehedge_quantity_base_payless_ticks_reprice (const spark::PreHedgeQuantityBasedPayLessTicks& params, + const Book& book, + api::Side hedge_side, + double tick_size, + Price current_price, + Quantity current_qty, + Price& out_price){ out_price = current_price; api::Side book_side = invert_side(hedge_side); Quantity price_level_qty, cumm_qty; bool find_qty_at_price = find_qty_at_price_level (book, book_side, current_price, tick_size, price_level_qty, cumm_qty); - if (find_qty_at_price) - { + if (find_qty_at_price){ Quantity qty_threshold = _quantity_threshold(params.quantity_threshold(), current_qty); - if (price_level_qty.value() > qty_threshold.value()) - { + if (cumm_qty.value() > qty_threshold.value()){ if (hedge_side == api::Side::SIDE_BUY) out_price = Price(current_price.value() - tick_size * params.payless_ticks()); else @@ -281,18 +254,44 @@ public: } return false; } - - static Price apply_pre_hedge_parameters (const spark::PreHedgeParams& prehedge_params, const Book& book, api::Side hedge_side, double tick_size, - Price current_price, Quantity current_qty) - { - Price out_price = current_price; + // this function finds the cum qty at hedge price (on the target side of + // the hedge), and pays up if the cum_qty is < threshold + static bool prehedge_quantity_base_payup_ticks_reprice (const spark::PreHedgeQuantityBasedPayupTicks& params, + const Book& book, + api::Side hedge_side, + double tick_size, + Price current_price, + Quantity current_qty, + Price& out_price){ + out_price = current_price; + api::Side book_side = invert_side(hedge_side); + Quantity price_level_qty, cumm_qty; + bool find_qty_at_price = find_qty_at_price_level (book, book_side, current_price, tick_size, price_level_qty, cumm_qty); + if (find_qty_at_price){ + Quantity qty_threshold = _quantity_threshold(params.quantity_threshold(), current_qty); + if (cumm_qty.value() < qty_threshold.value()){ + if (hedge_side == api::Side::SIDE_BUY) + out_price = Price(current_price.value() + tick_size * params.payup_ticks()); + else + out_price = Price(current_price.value() - tick_size * params.payup_ticks()); + return true; + } + } + return false; + } + static Price apply_pre_hedge_parameters (const spark::PreHedgeParams& prehedge_params, + const Book& book, + api::Side hedge_side, + double tick_size, + Price current_price, + Quantity current_qty){ + Price out_price = current_price; if (prehedge_params.has_quantity_based_payless_ticks() && prehedge_quantity_base_payless_ticks_reprice (prehedge_params.quantity_based_payless_ticks(), book, hedge_side, tick_size, current_price, current_qty, out_price)) return out_price; else if (prehedge_params.has_quantity_based_payup_ticks() && prehedge_quantity_base_payup_ticks_reprice (prehedge_params.quantity_based_payup_ticks(), book, hedge_side, tick_size, current_price, current_qty, out_price)) return out_price; return out_price; } - /**********************************************************************/ /****************************Post Hedge Params*************************/ /**********************************************************************/ @@ -604,7 +603,7 @@ public: /**************************debugging helpers***************************/ /**********************************************************************/ static std::string book_to_str(const bts::orderman::Book& book, - api::Side side); + api::Side side); static std::string book_ev_to_str(const bts::orderman::BookUpdateEvent& book_event); }; }} diff --git a/src/server/sparkd/orderman/orders/spreader_orders/tests/spreader_tests.cpp b/src/server/sparkd/orderman/orders/spreader_orders/tests/spreader_tests.cpp index 19dc4c81d..6837223bd 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/tests/spreader_tests.cpp +++ b/src/server/sparkd/orderman/orders/spreader_orders/tests/spreader_tests.cpp @@ -13,80 +13,80 @@ 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)); + REQUIRE (s.target_spread_price() == Price (-1.0)); + REQUIRE (s.target_leg_quantity() == Quantity (200)); + REQUIRE (s.aggregated_filled_quantity() == Quantity (0)); + REQUIRE (s.aggregated_hedged_reduction() == Quantity (0)); + REQUIRE (s.remaining_to_fill() == Quantity (200)); + REQUIRE (s.out_price() == Price (0.0)); + REQUIRE (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)); + REQUIRE (s.target_spread_price() == Price (-1.0)); + REQUIRE (s.target_leg_quantity() == Quantity (200)); + REQUIRE (s.aggregated_filled_quantity() == Quantity (25)); + REQUIRE (s.aggregated_hedged_reduction() == Quantity (0)); + REQUIRE (s.remaining_to_fill() == Quantity (175)); + REQUIRE (s.out_price() == Price (0.0)); + REQUIRE (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)); + REQUIRE (s.target_spread_price() == Price (-1.0)); + REQUIRE (s.target_leg_quantity() == Quantity (200)); + REQUIRE (s.aggregated_filled_quantity() == Quantity (25)); + REQUIRE (s.aggregated_hedged_reduction() == Quantity (50)); + REQUIRE (s.remaining_to_fill() == Quantity (125)); + REQUIRE (s.out_price() == Price (0.0)); + REQUIRE (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)); + REQUIRE (s.target_spread_price() == Price (-1.0)); + REQUIRE (s.target_leg_quantity() == Quantity (200)); + REQUIRE (s.aggregated_filled_quantity() == Quantity (25)); + REQUIRE (s.aggregated_hedged_reduction() == Quantity (50)); + REQUIRE (s.remaining_to_fill() == Quantity (125)); + REQUIRE (s.out_price() == Price (-0.35)); + REQUIRE (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)); + REQUIRE (s.target_spread_price() == Price (-1.0)); + REQUIRE (s.target_leg_quantity() == Quantity (105)); + REQUIRE (s.aggregated_filled_quantity() == Quantity (25)); + REQUIRE (s.aggregated_hedged_reduction() == Quantity (50)); + REQUIRE (s.remaining_to_fill() == Quantity (30)); + REQUIRE (s.out_price() == Price (-0.35)); + REQUIRE (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)); + REQUIRE (s.target_spread_price() == Price (-1.0)); + REQUIRE (s.target_leg_quantity() == Quantity (105)); + REQUIRE (s.aggregated_filled_quantity() == Quantity (25)); + REQUIRE (s.aggregated_hedged_reduction() == Quantity (85)); + REQUIRE (s.remaining_to_fill() == Quantity (0)); + REQUIRE (s.out_price() == Price (-0.35)); + REQUIRE (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)); + REQUIRE (s.target_spread_price() == Price (-1.0)); + REQUIRE (s.target_leg_quantity() == Quantity (105)); + REQUIRE (s.aggregated_filled_quantity() == Quantity (40)); + REQUIRE (s.aggregated_hedged_reduction() == Quantity (85)); + REQUIRE (s.remaining_to_fill() == Quantity (0)); + REQUIRE (s.out_price() == Price (-0.35)); + REQUIRE (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)); + REQUIRE (s.target_spread_price() == Price (-1.0)); + REQUIRE (s.target_leg_quantity() == Quantity (200)); + REQUIRE (s.aggregated_filled_quantity() == Quantity (0)); + REQUIRE (s.aggregated_hedged_reduction() == Quantity (0)); + REQUIRE (s.remaining_to_fill() == Quantity (200)); + REQUIRE (s.out_price() == Price (0.0)); + REQUIRE (s.out_quantity() == Quantity (0)); // add fills s.add_filled_quantity (Quantity(15)); s.add_filled_quantity (Quantity(25)); @@ -95,35 +95,35 @@ TEST_CASE ("quoter price quantity state", "[spreader]") 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)); + REQUIRE (s.target_spread_price() == Price (-1.0)); + REQUIRE (s.target_leg_quantity() == Quantity (200)); + REQUIRE (s.aggregated_filled_quantity() == Quantity (40)); + REQUIRE (s.aggregated_hedged_reduction() == Quantity (20)); + REQUIRE (s.remaining_to_fill() == Quantity (140)); + REQUIRE (s.out_price() == Price (1.0)); + REQUIRE (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)); + REQUIRE (s.target_spread_price() == Price (-1.0)); + REQUIRE (s.target_leg_quantity() == Quantity (200)); + REQUIRE (s.aggregated_filled_quantity() == Quantity (0)); + REQUIRE (s.aggregated_hedged_reduction() == Quantity (20)); + REQUIRE (s.remaining_to_fill() == Quantity (140)); + REQUIRE (s.out_price() == Price (0.0)); + REQUIRE (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)); + REQUIRE (s.target_spread_price() == Price (-1.0)); + REQUIRE (s.target_leg_quantity() == Quantity (200)); + REQUIRE (s.aggregated_filled_quantity() == Quantity (10)); + REQUIRE (s.aggregated_hedged_reduction() == Quantity (30)); + REQUIRE (s.remaining_to_fill() == Quantity (120)); + REQUIRE (s.out_price() == Price (0.75)); + REQUIRE (s.out_quantity() == Quantity (50)); } } // tests spread_qty -> leg_qty and leg_2_qty -> leg_1_qty @@ -144,7 +144,7 @@ TEST_CASE ("test_leg_quantity_normalization", "[spreader]") LegPropertyData leg_prop_data (0, leg, lsp, api::Side::SIDE_BUY); Quantity calc_value = SpreaderUtils::get_leg_quantity_from_spreader_quantity (leg_prop_data, Quantity (spr_qty)), expected_value = Quantity(static_cast (std::round(std::abs(leg_mult * spr_qty)))); - bts_assert (calc_value == expected_value); + REQUIRE (calc_value == expected_value); } for (int i = 0; i < n_runs; i++) { @@ -165,7 +165,7 @@ TEST_CASE ("test_leg_quantity_normalization", "[spreader]") LegPropertyData leg_prop_data_2 (1, leg_2, lsp_2, api::Side::SIDE_BUY); Quantity calc_value = SpreaderUtils::get_leg_quantity_from_another_leg_quantity (leg_prop_data_1, Quantity(leg_qty), leg_prop_data_2), expected_value = Quantity(static_cast (std::round(std::abs(leg_qty * leg_mult_2 / leg_mult_1)))); - bts_assert (calc_value == expected_value); + REQUIRE (calc_value == expected_value); } } // given a qty, traverses the book to find the level @@ -181,10 +181,10 @@ TEST_CASE ("book traversal", "[spreader]") 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)); + REQUIRE (calc_price == Price (2500.25)); + REQUIRE (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)); + REQUIRE (calc_quantity == Quantity (0)); } SECTION("test level 2 sell") { @@ -193,10 +193,10 @@ TEST_CASE ("book traversal", "[spreader]") 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)); + REQUIRE (calc_price == Price (2500.75)); + REQUIRE (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)); + REQUIRE (calc_quantity == Quantity (0)); } SECTION("test req_qty == book sell") { @@ -205,10 +205,10 @@ TEST_CASE ("book traversal", "[spreader]") 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)); + REQUIRE (calc_price == Price (2503)); + REQUIRE (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)); + REQUIRE (calc_quantity == Quantity (0)); } SECTION("test req_qty > book buy") { @@ -217,10 +217,10 @@ TEST_CASE ("book traversal", "[spreader]") 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)); + REQUIRE (calc_price == Price (2497)); + REQUIRE (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)); + REQUIRE (calc_quantity == Quantity (0)); } SECTION("test_5 buy") { @@ -230,9 +230,9 @@ TEST_CASE ("book traversal", "[spreader]") 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)); + REQUIRE (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)); + REQUIRE (calc_quantity == Quantity (0)); } } //this is how the spreader organizes the data @@ -292,13 +292,13 @@ TEST_CASE ("spreader bookkeeping data", "[spreader]") // // SECTION("verify order key access") // // { // // SpreaderLegData* res_3 = bookkeeping_data.find_leg_from_quoter_orderkey (order_key_3); - // // bts_assert (res_3 != nullptr); + // // REQUIRE (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); + // // REQUIRE (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); + // // REQUIRE (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); // // } } @@ -330,8 +330,8 @@ TEST_CASE ("compute quoting price quantity 2 legs", "[spreader]") 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); + REQUIRE (out_price.value() == 2504.00); + REQUIRE (out_quantity.value() == 10); } SECTION("lean mult") { @@ -349,50 +349,50 @@ TEST_CASE ("compute quoting price quantity 2 legs", "[spreader]") 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); + REQUIRE (out_price.value() == 2504.5); + REQUIRE (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); + REQUIRE (out_price.value() == 2504.25); + REQUIRE (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); + REQUIRE (out_price.value() == 2502.5); + REQUIRE (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); + REQUIRE (out_price.value() == 2502.25); + REQUIRE (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); + REQUIRE (out_price.value() == 2502.25); + REQUIRE (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() == 2); // TODO:check + REQUIRE (out_price.value() == 2502.25); + REQUIRE (out_quantity.value() == 2); // 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); + REQUIRE (out_price.value() == 2504.25); + REQUIRE (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); + REQUIRE (out_price.value() == 2502.5); + REQUIRE (out_quantity.value() == 5); } SECTION("fractional leg mult ") { @@ -411,8 +411,8 @@ TEST_CASE ("compute quoting price quantity 2 legs", "[spreader]") 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); + REQUIRE (out_price.value() == 10997.5); + REQUIRE (out_quantity.value() == 3); } SECTION("fractional leg mult 2") { @@ -430,12 +430,12 @@ TEST_CASE ("compute quoting price quantity 2 legs", "[spreader]") double ask_prices_1[] = {18.525}; uint16_t ask_sizes_1[] = {100}; fill_book (book_1, bid_prices_1, bid_sizes_1, ask_prices_1, ask_sizes_1); SpreaderUtils::compute_price_quantity_2_legs (spreader_price, Quantity(23), leg_prop_data_2, leg_prop_data_1, book_1, out_price, out_quantity); - bts_assert (out_price.value() == 18.45); - bts_assert (out_quantity.value() == 23); + REQUIRE (out_price.value() == 18.45); + REQUIRE (out_quantity.value() == 23); //lower qty SpreaderUtils::compute_price_quantity_2_legs (spreader_price, Quantity(12), leg_prop_data_2, leg_prop_data_1, book_1, out_price, out_quantity); - bts_assert (out_price.value() == 18.45); - bts_assert (out_quantity.value() == 12); + REQUIRE (out_price.value() == 18.45); + REQUIRE (out_quantity.value() == 12); } SECTION("price mult") { @@ -455,8 +455,8 @@ TEST_CASE ("compute quoting price quantity 2 legs", "[spreader]") 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); + REQUIRE (out_price.value() == 10711.25); + REQUIRE (out_quantity.value() == 3); } } TEST_CASE ("compute quoting price quantity 3 legs", "[spreader]") @@ -489,16 +489,16 @@ TEST_CASE ("compute quoting price quantity 3 legs", "[spreader]") sm->set_book(book_1, 0);sm->set_book(book_2, 1);sm->set_book(book_3, 2); // leg 1 quoting price SpreaderUtils::compute_quoting_price_size_n_legs(spreader_price, spreader_quantity, 0, *sm, driver_vector, out_price, out_quantity); - bts_assert (out_price.value() == 18.175); - bts_assert (out_quantity.value() == 2); + REQUIRE (out_price.value() == 18.175); + REQUIRE (out_quantity.value() == 2); // leg 2 quoting price SpreaderUtils::compute_quoting_price_size_n_legs(spreader_price, Quantity(2 * spreader_quantity.value()), 1, *sm, driver_vector, out_price, out_quantity); - bts_assert (out_price.value() == 18.425); - bts_assert (out_quantity.value() == 4); + REQUIRE (out_price.value() == 18.425); + REQUIRE (out_quantity.value() == 4); // leg 3 quoting SpreaderUtils::compute_quoting_price_size_n_legs(spreader_price, spreader_quantity, 2, *sm, driver_vector, out_price, out_quantity); - bts_assert (out_price.value() == 18.425); - bts_assert (out_quantity.value() == 2); + REQUIRE (out_price.value() == 18.425); + REQUIRE (out_quantity.value() == 2); } SECTION("basic crossing") { @@ -510,16 +510,16 @@ TEST_CASE ("compute quoting price quantity 3 legs", "[spreader]") sm->set_book(book_1, 0);sm->set_book(book_2, 1);sm->set_book(book_3, 2); // leg 1 quoting price SpreaderUtils::compute_quoting_price_size_n_legs(spreader_price, spreader_quantity, 0, *sm, driver_vector, out_price, out_quantity); - bts_assert (out_price.value() == 18.275); - bts_assert (out_quantity.value() == 2); + REQUIRE (out_price.value() == 18.275); + REQUIRE (out_quantity.value() == 2); // leg 2 quoting price SpreaderUtils::compute_quoting_price_size_n_legs(spreader_price, Quantity(2 * spreader_quantity.value()), 1, *sm, driver_vector, out_price, out_quantity); - bts_assert (out_price.value() == 18.375); - bts_assert (out_quantity.value() == 4); + REQUIRE (out_price.value() == 18.375); + REQUIRE (out_quantity.value() == 4); // leg 3 quoting SpreaderUtils::compute_quoting_price_size_n_legs(spreader_price, spreader_quantity, 2, *sm, driver_vector, out_price, out_quantity); - bts_assert (out_price.value() == 18.525); - bts_assert (out_quantity.value() == 2); + REQUIRE (out_price.value() == 18.525); + REQUIRE (out_quantity.value() == 2); } SECTION("reduced to minimum leg") { @@ -531,8 +531,8 @@ TEST_CASE ("compute quoting price quantity 3 legs", "[spreader]") sm->set_book(book_1, 0);sm->set_book(book_2, 1);sm->set_book(book_3, 2); // leg 2 quoting price SpreaderUtils::compute_quoting_price_size_n_legs(spreader_price, Quantity(2 * spreader_quantity.value()), 1, *sm, driver_vector, out_price, out_quantity); - bts_assert (out_price.value() == 18.425); - bts_assert (out_quantity.value() == 4); + REQUIRE (out_price.value() == 18.425); + REQUIRE (out_quantity.value() == 4); } SECTION("reduced to minimum leg stagger") { @@ -544,8 +544,8 @@ TEST_CASE ("compute quoting price quantity 3 legs", "[spreader]") sm->set_book(book_1, 0);sm->set_book(book_2, 1);sm->set_book(book_3, 2); // leg 2 quoting price SpreaderUtils::compute_quoting_price_size_n_legs(spreader_price, Quantity(2 * spreader_quantity.value()), 1, *sm, driver_vector, out_price, out_quantity); - bts_assert (out_price.value() == 18.42); - bts_assert (out_quantity.value() == 4); + REQUIRE (out_price.value() == 18.42); + REQUIRE (out_quantity.value() == 4); } SECTION("reduced to minimum leg stagger multiple levels") { @@ -557,8 +557,8 @@ TEST_CASE ("compute quoting price quantity 3 legs", "[spreader]") sm->set_book(book_1, 0);sm->set_book(book_2, 1);sm->set_book(book_3, 2); // leg 2 quoting price SpreaderUtils::compute_quoting_price_size_n_legs(spreader_price, Quantity(2 * spreader_quantity.value()), 1, *sm, driver_vector, out_price, out_quantity); - bts_assert (out_price.value() == 18.42); - bts_assert (out_quantity.value() == 4); + REQUIRE (out_price.value() == 18.42); + REQUIRE (out_quantity.value() == 4); } } TEST_CASE ("compute hedge price quantity 2 legs", "[spreader]") @@ -576,22 +576,22 @@ TEST_CASE ("compute hedge price quantity 2 legs", "[spreader]") // 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); + REQUIRE (out_hedge_quantity.value() == 1); + REQUIRE (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); + REQUIRE (out_hedge_quantity.value() == 0); + REQUIRE (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); + REQUIRE (out_hedge_quantity.value() == 9); + REQUIRE (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); + REQUIRE (out_hedge_quantity.value() == 26); + REQUIRE (out_hedge_price.value() == 2332.5); } /************************************************************************************************************/ /*********************************************Quoter State Tests*********************************************/ @@ -909,7 +909,7 @@ TEST_CASE ("quoter_WAITING_FOR_CANCEL_ACK", "[spreader]") 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); + REQUIRE (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"); } @@ -1585,21 +1585,21 @@ TEST_CASE ("spreader_START", "[spreader]") SpreaderManagerForTest spreader_manager (order_key, order_def, pao_services, leg_props); SpreaderBookkeepingData& bookkeeping_data = spreader_manager.bookkeeping_data(); SpreaderOrder spreader; - bts_assert(spreader.test_only_func_spreader_state() == SpreaderState::START); + REQUIRE(spreader.test_only_func_spreader_state() == SpreaderState::START); SECTION("1. on_init_new.resolved") { spreader.test_only_on_init_new (order_def, pao_services); - bts_assert(spreader.test_only_func_spreader_state() == SpreaderState::START); + REQUIRE(spreader.test_only_func_spreader_state() == SpreaderState::START); SpreaderBookkeepingData& bookeeping_data = spreader.test_only_func_spreader_full_data(); - bts_assert(bookkeeping_data.get_leg_data(0).leg_property_data().security_key() == 2468); - bts_assert(bookkeeping_data.get_leg_data(1).leg_property_data().security_key() == 13579); + REQUIRE(bookkeeping_data.get_leg_data(0).leg_property_data().security_key() == 2468); + REQUIRE(bookkeeping_data.get_leg_data(1).leg_property_data().security_key() == 13579); } SECTION("1. on_init_new.not_resolved") { testonly_spreader_pao_services.set_resolve_flag(false); spreader.test_only_on_init_new (order_def, pao_services); - bts_assert(spreader.test_only_func_spreader_state() == SpreaderState::END); + REQUIRE(spreader.test_only_func_spreader_state() == SpreaderState::END); } SECTION("2. on_activate") { @@ -1611,7 +1611,7 @@ TEST_CASE ("spreader_START", "[spreader]") SECTION("5. on_cancel") { spreader.on_cancel(); - bts_assert(spreader.test_only_func_spreader_state() == SpreaderState::END); + REQUIRE(spreader.test_only_func_spreader_state() == SpreaderState::END); LOG(OrderMan, Diag, "spreader_START.on_cancel"); } } @@ -1640,7 +1640,7 @@ TEST_CASE ("spreader_WORKING", "[spreader]") SpreaderUtils::resolve_synthetic_spread(pao_services, order_def, leg_props); SpreaderManagerForTest spreader_manager (order_key, order_def, pao_services, leg_props); SpreaderOrder spreader; - bts_assert(spreader.test_only_func_spreader_state() == SpreaderState::START); + REQUIRE(spreader.test_only_func_spreader_state() == SpreaderState::START); // on_init_new and activate spreader.test_only_on_init_new (order_def, pao_services); SpreaderOrderServices order_services (nullptr); @@ -1684,8 +1684,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]") spreader.test_only_on_child_order_update (leg_data_1.get_hedger(i).order_update_message().order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0)); for (size_t i = 0; i < leg_data_2.n_hedgers(); i++) spreader.test_only_on_child_order_update (leg_data_2.get_hedger(i).order_update_message().order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0)); - bts_assert (leg_data_1.n_hedgers () == 3); - bts_assert (leg_data_2.n_hedgers () == 2); + REQUIRE (leg_data_1.n_hedgers () == 3); + REQUIRE (leg_data_2.n_hedgers () == 2); verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false); verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); @@ -1701,8 +1701,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]") }; auto generic_validate_hedgers = [&](HedgerState hedger_state) -> void { - bts_assert (leg_data_1.n_hedgers () == 3); - bts_assert (leg_data_2.n_hedgers () == 2); + REQUIRE (leg_data_1.n_hedgers () == 3); + REQUIRE (leg_data_2.n_hedgers () == 2); verify_complete_hedger_state (leg_data_1.get_hedger(0).hedger(), hedger_state, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); verify_complete_hedger_state (leg_data_1.get_hedger(1).hedger(), hedger_state, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); verify_complete_hedger_state (leg_data_1.get_hedger(2).hedger(), hedger_state, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); @@ -1828,8 +1828,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]") spreader.test_only_on_child_order_update (leg_data_1.order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_ERROR, Quantity (30), Price (2000)); verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); // the one that has an error goes to the end, the others are waiting on cancel ack's - bts_assert(spreader.test_only_func_spreader_full_data().get_leg_data(0).quoter().test_only_func_quoter_state() == QuoterState::END); - bts_assert(spreader.test_only_func_spreader_full_data().get_leg_data(1).quoter().test_only_func_quoter_state() == QuoterState::WAITING_FOR_CANCEL_ACK); + REQUIRE(spreader.test_only_func_spreader_full_data().get_leg_data(0).quoter().test_only_func_quoter_state() == QuoterState::END); + REQUIRE(spreader.test_only_func_spreader_full_data().get_leg_data(1).quoter().test_only_func_quoter_state() == QuoterState::WAITING_FOR_CANCEL_ACK); generic_validate_hedgers (HedgerState::WAITING_FOR_CANCEL_ACK); LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_error"); } @@ -1841,8 +1841,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]") spreader.test_only_on_child_order_update (leg_data_1.get_hedger(i).order_update_message().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0)); for (size_t i = 0; i < leg_data_2.n_hedgers(); i++) spreader.test_only_on_child_order_update (leg_data_2.get_hedger(i).order_update_message().order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0)); - bts_assert (leg_data_1.n_hedgers () == 4); - bts_assert (leg_data_2.n_hedgers () == 2); + REQUIRE (leg_data_1.n_hedgers () == 4); + REQUIRE (leg_data_2.n_hedgers () == 2); verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(65), Price(2003), Quantity(35), Quantity(5), false); verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (65), Quantity(30), Price(1999), Quantity(70), Quantity(5), false); verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); @@ -1862,8 +1862,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]") spreader.test_only_on_child_order_update (leg_data_1.get_hedger(i).order_update_message().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0)); for (size_t i = 0; i < leg_data_2.n_hedgers(); i++) spreader.test_only_on_child_order_update (leg_data_2.get_hedger(i).order_update_message().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0)); - bts_assert (leg_data_1.n_hedgers () == 4); - bts_assert (leg_data_2.n_hedgers () == 2); + REQUIRE (leg_data_1.n_hedgers () == 4); + REQUIRE (leg_data_2.n_hedgers () == 2); verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (30), Quantity(70), Price(2003), Quantity(45), Quantity(0), true); verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(0), Quantity(0), Quantity(0), true); verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); @@ -1879,11 +1879,11 @@ TEST_CASE ("spreader_WORKING", "[spreader]") spreader.test_only_on_child_order_update (leg_data_1.get_hedger(0).order_update_message().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_ERROR, Quantity (0), Price (0)); verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity); generic_validate_quoters (QuoterState::WAITING_FOR_CANCEL_ACK, true); - bts_assert(leg_data_1.get_hedger(0).hedger().test_only_func_hedger_state() == HedgerState::END); - bts_assert(leg_data_1.get_hedger(1).hedger().test_only_func_hedger_state() == HedgerState::WAITING_FOR_CANCEL_ACK); - bts_assert(leg_data_1.get_hedger(2).hedger().test_only_func_hedger_state() == HedgerState::WAITING_FOR_CANCEL_ACK); - bts_assert(leg_data_2.get_hedger(0).hedger().test_only_func_hedger_state() == HedgerState::WAITING_FOR_CANCEL_ACK); - bts_assert(leg_data_2.get_hedger(1).hedger().test_only_func_hedger_state() == HedgerState::WAITING_FOR_CANCEL_ACK); + REQUIRE(leg_data_1.get_hedger(0).hedger().test_only_func_hedger_state() == HedgerState::END); + REQUIRE(leg_data_1.get_hedger(1).hedger().test_only_func_hedger_state() == HedgerState::WAITING_FOR_CANCEL_ACK); + REQUIRE(leg_data_1.get_hedger(2).hedger().test_only_func_hedger_state() == HedgerState::WAITING_FOR_CANCEL_ACK); + REQUIRE(leg_data_2.get_hedger(0).hedger().test_only_func_hedger_state() == HedgerState::WAITING_FOR_CANCEL_ACK); + REQUIRE(leg_data_2.get_hedger(1).hedger().test_only_func_hedger_state() == HedgerState::WAITING_FOR_CANCEL_ACK); LOG(OrderMan, Diag, "spreader_WORKING.on_hedger_order_error"); } SECTION("12. on_hedger_order_update") @@ -1892,8 +1892,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]") spreader.test_only_on_child_order_update (leg_data_1.get_hedger(0).order_update_message().order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (10), Price (2002)); verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity); generic_validate_quoters (QuoterState::WORKING, false); - bts_assert (leg_data_1.n_hedgers () == 3); - bts_assert (leg_data_2.n_hedgers () == 2); + REQUIRE (leg_data_1.n_hedgers () == 3); + REQUIRE (leg_data_2.n_hedgers () == 2); verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (10), Price(2002), Quantity (15), Quantity (5)); verify_complete_hedger_state (leg_data_1.get_hedger (1).hedger(), HedgerState::WORKING, Price (2002), Quantity(30), Quantity (0), Price(2002), Quantity (30), Quantity (30)); verify_complete_hedger_state (leg_data_1.get_hedger (2).hedger(), HedgerState::WORKING, Price (2002), Quantity(10), Quantity (0), Price(2002), Quantity (10), Quantity (10)); @@ -1910,8 +1910,8 @@ TEST_CASE ("spreader_WORKING", "[spreader]") // resubmit and continue // leg has 30 hedge deduction, and 55 filled, another 15 will fill it completely spreader.test_only_on_child_order_update (leg_data_2.order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity (70), Price (2001)); - bts_assert (leg_data_1.n_hedgers () == 4); - bts_assert (leg_data_2.n_hedgers () == 2); + REQUIRE (leg_data_1.n_hedgers () == 4); + REQUIRE (leg_data_2.n_hedgers () == 2); verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (30), Quantity(70), Price(2003), Quantity(45), Quantity(0), true); verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(30), Price(0), Quantity(0), Quantity(0), true); verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); @@ -1968,7 +1968,7 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") SpreaderUtils::resolve_synthetic_spread(pao_services, order_def, leg_props); SpreaderManagerForTest spreader_manager (order_key, order_def, pao_services, leg_props); SpreaderOrder spreader; - bts_assert(spreader.test_only_func_spreader_state() == SpreaderState::START); + REQUIRE(spreader.test_only_func_spreader_state() == SpreaderState::START); // on_init_new and activate spreader.test_only_on_init_new (order_def, pao_services); SpreaderOrderServices order_services (nullptr); @@ -2012,8 +2012,8 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") spreader.test_only_on_child_order_update (leg_data_1.get_hedger(i).order_update_message().order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0)); for (size_t i = 0; i < leg_data_2.n_hedgers(); i++) spreader.test_only_on_child_order_update (leg_data_2.get_hedger(i).order_update_message().order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (0), Price (0)); - bts_assert (leg_data_1.n_hedgers () == 3); - bts_assert (leg_data_2.n_hedgers () == 2); + REQUIRE (leg_data_1.n_hedgers () == 3); + REQUIRE (leg_data_2.n_hedgers () == 2); verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false); verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::WORKING, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); @@ -2030,8 +2030,8 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") 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); + REQUIRE (leg_data_1.n_hedgers () == 3); + REQUIRE (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)); @@ -2080,7 +2080,7 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") // std::this_thread::sleep_for(std::chrono::milliseconds(1)); // } // int64_t time_since_cxl = ms_diff (std::chrono::system_clock::now(), cancel_timestamp); - // bts_assert (time_since_cxl >= spreader.test_cancel_timeout()); + // REQUIRE (time_since_cxl >= spreader.test_cancel_timeout()); // verify_complete_quoter_state (leg_data_1.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (30), Quantity(55), Price(2003), Quantity(45), Quantity(15), false); // verify_complete_quoter_state (leg_data_2.quoter(), QuoterState::END, true, spreader_price, Quantity (100), Quantity (55), Quantity(30), Price(2000), Quantity(70), Quantity(15), false); // verify_complete_hedger_state (leg_data_1.get_hedger (0).hedger(), HedgerState::END, Price (2002), Quantity(15), Quantity (0), Price(2002), Quantity (15), Quantity (15)); @@ -2102,8 +2102,8 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") // state of leg 1, but no other action will take place spreader.test_only_on_child_order_update (leg_data_1.order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity (40), Price (2000.5)); 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); + REQUIRE (leg_data_1.n_hedgers () == 3); + REQUIRE (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)); @@ -2118,8 +2118,8 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") // cancelled update spreader.test_only_on_child_order_update (leg_data_1.order_key(), bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED, Quantity (30), Price (2000)); 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); + REQUIRE (leg_data_1.n_hedgers () == 3); + REQUIRE (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)); @@ -2173,6 +2173,74 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") LOG(OrderMan, Diag, "spreader_WAITING_FOR_CANCEL_ACK.on_check_termination"); } } +TEST_CASE ("find_target_price_in_book", "[spreader]"){ + SECTION("0.05"){ + Quantity out_level_qty, out_cum_qty; + bts::orderman::Book book; + uint16_t sizes[] = { 11, 13, 17, 19, 23 }; + double prices[] = { 22, 21.15, 20.10, 20.05, 20.00 }; + fill_book (book, prices, sizes, bts::api::Side::SIDE_BUY); + // middle + bool res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_BUY, Price(20.10), 0.05, out_level_qty, out_cum_qty); + REQUIRE(res); + REQUIRE(out_level_qty.value()==17); + REQUIRE(out_cum_qty.value()==41); + // first + res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_BUY, Price(22.00), 0.05, out_level_qty, out_cum_qty); + REQUIRE(res); + REQUIRE(out_level_qty.value()==11); + REQUIRE(out_cum_qty.value()==11); + // last + res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_BUY, Price(20.00), 0.05, out_level_qty, out_cum_qty); + REQUIRE(res); + REQUIRE(out_level_qty.value()==23); + REQUIRE(out_cum_qty.value()==83); + // not found + res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_BUY, Price(21.00), 0.05, out_level_qty, out_cum_qty); + REQUIRE(!res); + // rounding error + res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_BUY, Price(20.04999999), 0.05, out_level_qty, out_cum_qty); + REQUIRE(res); + REQUIRE(out_level_qty.value()==19); + REQUIRE(out_cum_qty.value()==60); + } + SECTION("1/32"){ + Quantity out_level_qty, out_cum_qty; + bts::orderman::Book book; + uint16_t sizes[] = { 12, 91, 5, 24, 33 }; + double prices[] = { 100.21875, 100.28125, 101, 101.53125, 101.71875 }; + fill_book (book, prices, sizes, bts::api::Side::SIDE_SELL); + // first + bool res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_SELL, Price(100.21875), 0.03125, out_level_qty, out_cum_qty); + REQUIRE(res); + REQUIRE(out_level_qty.value()==12); + REQUIRE(out_cum_qty.value()==12); + // middle + res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_SELL, Price(101.53125), 0.03125, out_level_qty, out_cum_qty); + REQUIRE(res); + REQUIRE(out_level_qty.value()==24); + REQUIRE(out_cum_qty.value()==132); + // end + res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_SELL, Price(101.71875), 0.03125, out_level_qty, out_cum_qty); + REQUIRE(res); + REQUIRE(out_level_qty.value()==33); + REQUIRE(out_cum_qty.value()==165); + // absent + res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_SELL, Price(101.5625), 0.03125, out_level_qty, out_cum_qty); + REQUIRE(!res); + REQUIRE(out_level_qty.value()==0); + REQUIRE(out_cum_qty.value()==0); + res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_BUY, Price(101.71875), 0.03125, out_level_qty, out_cum_qty); + REQUIRE(!res); + REQUIRE(out_level_qty.value()==0); + REQUIRE(out_cum_qty.value()==0); + // rounding + res = SpreaderUtils::find_qty_at_price_level(book, bts::api::Side::SIDE_SELL, Price(101.531249999999), 0.03125, out_level_qty, out_cum_qty); + REQUIRE(res); + REQUIRE(out_level_qty.value()==24); + REQUIRE(out_cum_qty.value()==132); + } +} // class Temp // { @@ -2185,15 +2253,15 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[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); +// REQUIRE (t_ptr->i == 100); +// REQUIRE (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); +// REQUIRE (t_ptr->i == 200); +// REQUIRE (t_ref.i == 200); // t_ptr->i = 300; -// bts_assert (t_ptr->i == 300); -// bts_assert (t_ref.i == 300); +// REQUIRE (t_ptr->i == 300); +// REQUIRE (t_ref.i == 300); // } // TEST_CASE ("vector ref test", "[spreader]") // { @@ -2204,13 +2272,13 @@ TEST_CASE ("spreader_WAITING_FOR_CANCEL_ACK", "[spreader]") // t_vect.push_back (t_val); // Temp& t_ref = t_vect[1]; // t_ref.i = 100; -// bts_assert (t_vect[1].i == 100); +// REQUIRE (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); +// REQUIRE (t_vect[1].i == 115); // } // class D{ diff --git a/src/server/sparkd/orderman/orders/spreader_orders/tests/tests_common.h b/src/server/sparkd/orderman/orders/spreader_orders/tests/tests_common.h index b630477f9..40faf514f 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/tests/tests_common.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/tests/tests_common.h @@ -227,7 +227,7 @@ void fill_book(bts::orderman::Book& book, double* prices, uint16_t* sizes, bts:: { bts::orderman::BookSide& bookside = book.side(side); for (size_t i = 0; i < book.n_levels(); i++) - bookside[i] = md::PriceSize::from_double<2>(prices[i], sizes[i]); + bookside[i] = md::PriceSize::from_double<6>(prices[i], sizes[i]); } void fill_book(bts::orderman::Book& book, double* bid_prices, uint16_t* bid_sizes, double* ask_prices, uint16_t* ask_sizes) @@ -236,8 +236,8 @@ void fill_book(bts::orderman::Book& book, double* bid_prices, uint16_t* bid_size bts::orderman::BookSide& askside = book.side(api::Side::SIDE_SELL); for (size_t i = 0; i < book.n_levels(); i++) { - bidside[i] = md::PriceSize::from_double<2>(bid_prices[i], bid_sizes[i]); - askside[i] = md::PriceSize::from_double<2>(ask_prices[i], ask_sizes[i]); + bidside[i] = md::PriceSize::from_double<6>(bid_prices[i], bid_sizes[i]); + askside[i] = md::PriceSize::from_double<6>(ask_prices[i], ask_sizes[i]); } } bts::orderman::Book get_book(SecurityKey key,