spreader tests

This commit is contained in:
Taha Afzal committed 2018-05-25 17:33:35 -04:00
1 parent 792801f936
commit bc4643fbf3
4 files changed
+393 -325

No files matched your search

+2 -1
View File
@@ -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:
@@ -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<uint32_t>(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<LegPropertyData>& 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<LegPropertyData>& spreader_legs,
size_t reserve_sz,
bool is_quoter,
std::vector<SpreaderOrderBuilder>& 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<uint32_t>(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<uint32_t>(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);
};
}}
@@ -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<uint32_t> (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<uint32_t> (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{
@@ -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,