2310 lines
155 KiB
C++
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);
|
|
// }
|
|
// };
|
|
|
|
}}
|
|
|