Files
spark/src/server/sparkd/orderman/tests/spreader_tests.cpp
T

2310 lines
155 KiB
C++

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