spreader tests
This commit is contained in:
1 parent
792801f936
commit
bc4643fbf3
4 files changed
+393
-325
No files matched your search
@@ -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,
|
||||
|
||||
Reference in new issue
Block a user