2132 lines
142 KiB
C++
2132 lines
142 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")
|
|
{
|
|
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")
|
|
{
|
|
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")
|
|
{
|
|
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")
|
|
{
|
|
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
|
|
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]")
|
|
{
|
|
// 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);
|
|
// leg property data
|
|
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);
|
|
QuoteParams qp_1, qp_2, qp_3;
|
|
fill_quote_params(qp_1, lean_ratio_1);
|
|
fill_quote_params(qp_2, lean_ratio_2);
|
|
fill_quote_params(qp_3, lean_ratio_3);
|
|
LegSpreaderParams lsp_1, lsp_2, lsp_3;
|
|
fill_leg_spreader_params (lsp_1, price_mult_1, true, qp_1);
|
|
fill_leg_spreader_params (lsp_2, price_mult_2, true, qp_2);
|
|
fill_leg_spreader_params (lsp_3, price_mult_3, true, qp_3);
|
|
LegPropertyData leg_prop_data_1 (0, leg_1, lsp_1, api::Side::SIDE_SELL);
|
|
LegPropertyData leg_prop_data_2 (1, leg_2, lsp_2, api::Side::SIDE_BUY);
|
|
LegPropertyData leg_prop_data_3 (2, leg_3, lsp_3, api::Side::SIDE_SELL);
|
|
Book book1, book2, book3;
|
|
// SpreaderManager
|
|
std::vector<LegPropertyData> legs;
|
|
legs.push_back (leg_prop_data_1);legs.push_back (leg_prop_data_2);legs.push_back (leg_prop_data_3);
|
|
std::vector<Book> books;
|
|
books.push_back (book1);books.push_back (book2);books.push_back (book3);
|
|
SpreaderManagerForTest spreader_manager (legs, books);
|
|
// quoter
|
|
SingleLegQuoter quoter_1 (spreader_manager, leg_prop_data_1, 3, spread_price , spread_quantity, bts::orderman::SpreaderOrderBase::ChildOrder());
|
|
SingleLegQuoter quoter_2 (spreader_manager, leg_prop_data_2, 3, spread_price , spread_quantity, bts::orderman::SpreaderOrderBase::ChildOrder());
|
|
SingleLegQuoter quoter_3 (spreader_manager, leg_prop_data_3, 3, spread_price , spread_quantity, bts::orderman::SpreaderOrderBase::ChildOrder());
|
|
// bookkeeping data
|
|
std::vector<SpreaderLegData> leg_data_v;
|
|
leg_data_v.push_back (SpreaderLegData (leg_prop_data_1, "er_1, order_key_1));
|
|
leg_data_v.push_back (SpreaderLegData (leg_prop_data_2, "er_2, order_key_2));
|
|
leg_data_v.push_back (SpreaderLegData (leg_prop_data_3, "er_3, order_key_3));
|
|
SpreaderBookkeepingData bookkeeping_data (leg_data_v, spread_price, spread_quantity);
|
|
SECTION("verify security key access")
|
|
{
|
|
SpreaderLegData res_3 = bookkeeping_data.get_leg_data (SecurityKey (sec_key_3));
|
|
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.get_leg_data (SecurityKey (sec_key_2));
|
|
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.get_leg_data (SecurityKey (sec_key_1));
|
|
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);
|
|
}
|
|
SECTION("verify index access")
|
|
{
|
|
SpreaderLegData res_3 = bookkeeping_data.get_leg_data (2);
|
|
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.get_leg_data (1);
|
|
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.get_leg_data (0);
|
|
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);
|
|
}
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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]")
|
|
{
|
|
Price spreader_price = Price (0.35); Quantity spreader_quantity (100);
|
|
SpreaderManagerForTest sm = create_spreader_manager_2_legs (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);
|
|
SingleLegQuoter quoter (sm, sm.get_leg_data (1), 2, spreader_price, spreader_quantity, bts::orderman::SpreaderOrderBase::ChildOrder());
|
|
|
|
SECTION("0. transition_to_start")
|
|
{
|
|
verify_complete_quoter_state (quoter, QuoterState::START, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (100), false);
|
|
LOG(OrderMan, Diag, "quoter_START_state.transition_to_start");
|
|
}
|
|
SECTION("1. init")
|
|
{
|
|
verify_complete_quoter_state (quoter, QuoterState::START, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (100), false);
|
|
quoter.init ();
|
|
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, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (100), false);
|
|
quoter.cancel_order();
|
|
verify_complete_quoter_state (quoter, QuoterState::END, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (100), false);
|
|
LOG(OrderMan, Diag, "quoter_START_state.cancel_order");
|
|
}
|
|
SECTION("5. terminate")
|
|
{
|
|
verify_complete_quoter_state (quoter, QuoterState::START, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (100), false);
|
|
quoter.cancel_order();
|
|
verify_complete_quoter_state (quoter, QuoterState::END, true, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (100), false);
|
|
LOG(OrderMan, Diag, "quoter_START_state.terminate");
|
|
}
|
|
SECTION("7. update_other_leg_fills")
|
|
{
|
|
verify_complete_quoter_state (quoter, QuoterState::START, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (100), false);
|
|
quoter.update_other_leg_fills (0, Quantity(50));
|
|
verify_complete_quoter_state (quoter, QuoterState::START, 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::START, 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_START_state.update_other_leg_fills");
|
|
}
|
|
SECTION("8. update_order_price_quantity")
|
|
{
|
|
verify_complete_quoter_state (quoter, QuoterState::START, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (100), false);
|
|
spreader_price = Price (0.5); spreader_quantity = Quantity (200);
|
|
quoter.update_order_price_quantity (spreader_price, spreader_quantity);
|
|
verify_complete_quoter_state (quoter, QuoterState::START, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(0), Quantity(0), Quantity (200), 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_START_state.update_order_price_quantity");
|
|
}
|
|
}
|
|
|
|
TEST_CASE ("quoter_WAITING_FOR_SIZE_state", "[spreader]")
|
|
{
|
|
Price spreader_price = Price (0.35); Quantity spreader_quantity (100);
|
|
SpreaderManagerForTest sm = create_spreader_manager_2_legs (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);
|
|
SingleLegQuoter quoter (sm, sm.get_leg_data (1), 2, spreader_price, spreader_quantity, bts::orderman::SpreaderOrderBase::ChildOrder());
|
|
quoter.init ();
|
|
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]")
|
|
{
|
|
Price spreader_price = Price (0.35); Quantity spreader_quantity (100);
|
|
SpreaderManagerForTest sm = create_spreader_manager_2_legs (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);
|
|
SingleLegQuoter quoter (sm, sm.get_leg_data (1), 2, spreader_price, spreader_quantity, bts::orderman::SpreaderOrderBase::ChildOrder());
|
|
quoter.init ();
|
|
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")
|
|
{
|
|
SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0));
|
|
u.update (api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (70), Price (2000), nullptr);
|
|
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")
|
|
{
|
|
SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0));
|
|
u.update (api::orderman::OrderStatus::OS_FILLED, Quantity (100), Price (2000), nullptr);
|
|
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]")
|
|
{
|
|
Price spreader_price = Price (0.35); Quantity spreader_quantity (100);
|
|
SpreaderManagerForTest sm = create_spreader_manager_2_legs (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);
|
|
SingleLegQuoter quoter (sm, sm.get_leg_data (1), 2, spreader_price, spreader_quantity, bts::orderman::SpreaderOrderBase::ChildOrder());
|
|
quoter.init ();
|
|
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")
|
|
{
|
|
SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0));
|
|
u.update (api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (70), Price (2000), nullptr);
|
|
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")
|
|
{
|
|
SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0));
|
|
u.update (api::orderman::OrderStatus::OS_FILLED, Quantity (100), Price (2000), nullptr);
|
|
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]")
|
|
{
|
|
Price spreader_price = Price (0.35); Quantity spreader_quantity (100);
|
|
SpreaderManagerForTest sm = create_spreader_manager_2_legs (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);
|
|
SingleLegQuoter quoter (sm, sm.get_leg_data (1), 2, spreader_price, spreader_quantity, bts::orderman::SpreaderOrderBase::ChildOrder());
|
|
quoter.init ();
|
|
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 ();
|
|
SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0));
|
|
u.update (api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (0), Price (0), nullptr);
|
|
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::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (70), Price (2000), nullptr);
|
|
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::orderman::OrderStatus::OS_FILLED, Quantity (100), Price (2000), nullptr);
|
|
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]")
|
|
{
|
|
Price spreader_price = Price (0.35); Quantity spreader_quantity (100);
|
|
SpreaderManagerForTest sm = create_spreader_manager_2_legs (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);
|
|
SingleLegQuoter quoter (sm, sm.get_leg_data (1), 2, spreader_price, spreader_quantity, bts::orderman::SpreaderOrderBase::ChildOrder());
|
|
quoter.init ();
|
|
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
|
|
SpreaderOrderUpdateMessage u (OrderKey(0));
|
|
u.update (api::orderman::OrderStatus::OS_FILLED, Quantity (75), Price (2000), nullptr);
|
|
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);
|
|
SpreaderOrderUpdateMessage u (OrderKey(0));
|
|
u.update (api::orderman::OrderStatus::OS_FILLED, Quantity (75), Price (2000), nullptr);
|
|
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]")
|
|
{
|
|
Price spreader_price = Price (0.5); Quantity spreader_quantity (100);
|
|
SpreaderManagerForTest sm = create_spreader_manager_2_legs (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);
|
|
SingleLegQuoter quoter (sm, sm.get_leg_data (1), 2, spreader_price, spreader_quantity, bts::orderman::SpreaderOrderBase::ChildOrder());
|
|
quoter.init ();
|
|
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);
|
|
SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0));
|
|
u.update (api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr);
|
|
quoter.update_order_status (u);
|
|
verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.50), Quantity(40), Quantity (100), false);
|
|
SECTION("2. reduced_size_update_order_status_non_terminal")
|
|
{
|
|
// partial fills
|
|
u.update (api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (15), Price (2000), nullptr);
|
|
quoter.update_order_status (u);
|
|
verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(15), Quantity(0), Price(2000.50), 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::orderman::OrderStatus::OS_FILLED, Quantity (40), Price (2000), nullptr);
|
|
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::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (20), Price (2000), nullptr);
|
|
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::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (10), Price (2000), nullptr);
|
|
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::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (10), Price (2000), nullptr);
|
|
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]")
|
|
{
|
|
Price spreader_price = Price (0.5); Quantity spreader_quantity (100);
|
|
SpreaderManagerForTest sm = create_spreader_manager_2_legs (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);
|
|
SingleLegQuoter quoter (sm, sm.get_leg_data (1), 2, spreader_price, spreader_quantity, bts::orderman::SpreaderOrderBase::ChildOrder());
|
|
quoter.init ();
|
|
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);
|
|
SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0));
|
|
u.update (api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr);
|
|
quoter.update_order_status (u);
|
|
verify_complete_quoter_state (quoter, QuoterState::WORKING, false, spreader_price, spreader_quantity, Quantity(0), Quantity(0), Price(2000.50), 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::orderman::OrderStatus::OS_FILLED, Quantity (40), Price (2000), nullptr);
|
|
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
|
|
SpreaderOrderUpdateMessage u2 (bts::orderman::OrderKey(0));
|
|
u2.update (api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr);
|
|
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::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (5), Price (2000), nullptr);
|
|
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::orderman::OrderStatus::OS_FILLED, Quantity (45), Price (2000), nullptr);
|
|
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
|
|
SpreaderOrderUpdateMessage u3 (bts::orderman::OrderKey(0));
|
|
u3.update (api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr);
|
|
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::orderman::OrderStatus::OS_FILLED, Quantity (15), Price (2000), nullptr);
|
|
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]")
|
|
{
|
|
Price hedger_price = Price (0.5); Quantity hedger_quantity (20);
|
|
SpreaderManagerForTest sm = create_spreader_manager_2_legs (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);
|
|
SingleFillHedger hedger (sm, sm.get_leg_data (1), bts::orderman::SpreaderOrderBase::ChildOrder(), hedger_price, hedger_quantity, api::Side::SIDE_SELL);
|
|
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::WAITING_FOR_FIRST_ACK, 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]")
|
|
{
|
|
Price hedger_price = Price (2000.0); Quantity hedger_quantity (20);
|
|
SpreaderManagerForTest sm = create_spreader_manager_2_legs (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);
|
|
SingleFillHedger hedger (sm, sm.get_leg_data (1), bts::orderman::SpreaderOrderBase::ChildOrder(), hedger_price, hedger_quantity, api::Side::SIDE_SELL);
|
|
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")
|
|
{
|
|
SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0));
|
|
u.update (api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (5), Price (2000), nullptr);
|
|
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")
|
|
{
|
|
SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0));
|
|
u.update (api::orderman::OrderStatus::OS_FILLED, Quantity (20), Price (2000), nullptr);
|
|
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]")
|
|
{
|
|
Price hedger_price = Price (2000.0); Quantity hedger_quantity (20);
|
|
SpreaderManagerForTest sm = create_spreader_manager_2_legs (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);
|
|
SingleFillHedger hedger (sm, sm.get_leg_data (1), bts::orderman::SpreaderOrderBase::ChildOrder(), hedger_price, hedger_quantity, api::Side::SIDE_SELL);
|
|
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")
|
|
{
|
|
SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0));
|
|
u.update (api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (5), Price (2000), nullptr);
|
|
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")
|
|
{
|
|
SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0));
|
|
u.update (api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr);
|
|
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]")
|
|
{
|
|
Price hedger_price = Price (2000.0); Quantity hedger_quantity (20);
|
|
SpreaderManagerForTest sm = create_spreader_manager_2_legs (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);
|
|
SingleFillHedger hedger (sm, sm.get_leg_data (1), bts::orderman::SpreaderOrderBase::ChildOrder(), hedger_price, hedger_quantity, api::Side::SIDE_SELL);
|
|
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);
|
|
SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0));
|
|
u.update (api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr);
|
|
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
|
|
SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0));
|
|
u.update (api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (5), Price (2000), nullptr);
|
|
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::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (10), Price (2000), nullptr);
|
|
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::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (15), Price (2000), nullptr);
|
|
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::orderman::OrderStatus::OS_CANCELED, Quantity (15), Price (2000), nullptr);
|
|
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]")
|
|
{
|
|
Price hedger_price = Price (2000.0); Quantity hedger_quantity (20);
|
|
SpreaderManagerForTest sm = create_spreader_manager_2_legs (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);
|
|
SingleFillHedger hedger (sm, sm.get_leg_data (1), bts::orderman::SpreaderOrderBase::ChildOrder(), hedger_price, hedger_quantity, api::Side::SIDE_SELL);
|
|
hedger.init ();
|
|
SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0));
|
|
u.update (api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr);
|
|
hedger.on_order_update (u);
|
|
hedger.cancel_hedge ();
|
|
u.update (api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr);
|
|
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::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr);
|
|
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]")
|
|
{
|
|
Price hedger_price = Price (2000.0); Quantity hedger_quantity (20);
|
|
SpreaderManagerForTest sm = create_spreader_manager_2_legs (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);
|
|
SingleFillHedger hedger (sm, sm.get_leg_data (1), bts::orderman::SpreaderOrderBase::ChildOrder(), hedger_price, hedger_quantity, api::Side::SIDE_SELL);
|
|
hedger.init ();
|
|
SpreaderOrderUpdateMessage u (bts::orderman::OrderKey(0));
|
|
u.update (api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr);
|
|
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::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (7), Price (2000), nullptr);
|
|
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::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (15), Price (2000), nullptr);
|
|
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::orderman::OrderStatus::OS_FILLED, Quantity (20), Price (2000), nullptr);
|
|
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");
|
|
}
|
|
}
|
|
|
|
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);
|
|
SECTION("1. init")
|
|
{
|
|
verify_basic_spreader_state (spreader, SpreaderState::START, spreader_price, spreader_quantity);
|
|
spreader.init ();
|
|
verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_FIRST_CONNECT, spreader_price, spreader_quantity);
|
|
LOG(OrderMan, Diag, "spreader_START.init");
|
|
}
|
|
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::START, Price (-0.05), Quantity (200));
|
|
LOG(OrderMan, Diag, "spreader_START.init");
|
|
}
|
|
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_START.on_cancel");
|
|
}
|
|
SECTION("13. on_external_error")
|
|
{
|
|
std::string err_msg = "stop and celebrate";
|
|
spreader.on_external_error (err_msg);
|
|
verify_basic_spreader_state (spreader, SpreaderState::END, spreader_price, spreader_quantity);
|
|
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);
|
|
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 spreaders should be in the end state
|
|
LOG(OrderMan, Diag, "spreader_WORKING.on_disconnect");
|
|
}
|
|
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::WORKING, Price (-0.05), Quantity (200));
|
|
// check spreader states
|
|
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);
|
|
// check spreader states
|
|
LOG(OrderMan, Diag, "spreader_WORKING.on_cancel");
|
|
}
|
|
SECTION("6. on_book")
|
|
{
|
|
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);
|
|
// send a book a on leg 1, this should make
|
|
// leg 2 send out an order - verify that
|
|
Book book_leg_1 = get_book (SecurityKey (leg_1.security().id()), 5,
|
|
new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10},
|
|
new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {10, 15, 25, 50, 10}, true);
|
|
spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_1);
|
|
validate_book (book_leg_1, leg_data_1.book());
|
|
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_SIZE, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(0), Quantity(0), Quantity(100), false);
|
|
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_FIRST_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false);
|
|
// send a book on leg 2, this should make
|
|
// leg 1 send out an order, so orders on
|
|
// both legs should be out there now
|
|
Book book_leg_2 = get_book (SecurityKey (leg_2.security().id()), 5,
|
|
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] {10, 10, 10, 10, 10}, true);
|
|
spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_2);
|
|
validate_book (book_leg_2, leg_data_2.book());
|
|
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_FIRST_ACK, 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::WAITING_FOR_FIRST_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false);
|
|
|
|
bts_assert (leg_data_1.order_key().value() != leg_data_2.order_key().value());
|
|
spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_NEW,
|
|
Quantity (0), Price (0), nullptr);
|
|
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::WAITING_FOR_FIRST_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false);
|
|
|
|
spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_NEW,
|
|
Quantity (0), Price (0), nullptr);
|
|
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);
|
|
|
|
// change the books and make sure the quoter
|
|
// adjusts its order
|
|
book_leg_1 = get_book (SecurityKey (leg_1.security().id()), 5,
|
|
new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10},
|
|
new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {10, 10, 10, 10, 10}, true);
|
|
spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_1);
|
|
validate_book (book_leg_1, leg_data_1.book());
|
|
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(2003), Quantity(50), Quantity(100), false);
|
|
book_leg_2 = get_book (SecurityKey (leg_2.security().id()), 5,
|
|
new double[5] {2002, 2001, 2000, 1999, 1998}, new uint16_t[5] {1, 2, 10, 1, 1},
|
|
new double[5] {2003, 2004, 2005, 2006, 2007}, new uint16_t[5] {10, 10, 10, 10, 10}, true);
|
|
spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_2);
|
|
validate_book (book_leg_2, leg_data_2.book());
|
|
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(15), Quantity(100), false);
|
|
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2003), Quantity(50), Quantity(100), false);
|
|
// remove the markets and the orders should be cancelled
|
|
book_leg_1 = get_book (SecurityKey (leg_1.security().id()), 5,
|
|
new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {0, 0, 0, 0, 0},
|
|
new double[5] {2000, 2001, 2002, 2003, 2004}, new uint16_t[5] {0, 0, 0, 0, 0}, true);
|
|
book_leg_2 = get_book (SecurityKey (leg_2.security().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] {0, 0, 0, 0, 0}, true);
|
|
spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_1);
|
|
spreader.on_book (bts::orderman::NullTickToTradeCorID, book_leg_2);
|
|
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(15), Quantity(100), false);
|
|
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2003), Quantity(50), Quantity(100), false);
|
|
LOG(OrderMan, Diag, "spreader_WORKING.on_book");
|
|
|
|
}
|
|
SECTION("7. on_time")
|
|
{
|
|
}
|
|
SECTION("8. on_quoter_order_error")
|
|
{
|
|
// get orders in working state
|
|
// and send an error
|
|
set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10},
|
|
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] {10, 10, 10, 10, 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 an error now, both quoters should
|
|
// go to cancel waiting
|
|
std::string err_msg = "error";
|
|
spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), &err_msg);
|
|
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(1999), Quantity(100), Quantity(100), false);
|
|
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(2002), Quantity(100), Quantity(100), false);
|
|
LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_error");
|
|
}
|
|
SECTION("9. on_quoter_order_fill")
|
|
{
|
|
set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10},
|
|
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] {10, 10, 10, 10, 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);
|
|
// now send a 20 lot fill in leg 1,
|
|
// verify leg 1's order data
|
|
// verify leg 2's order data
|
|
// verify that there a hedging order is worked
|
|
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);
|
|
std::vector<SpreaderHedgerData>& hedgers_leg_2 = leg_data_2.get_hedgers();
|
|
bts_assert (hedgers_leg_2.size() == 1);
|
|
SingleFillHedger& hedger = hedgers_leg_2[0].hedger();
|
|
verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20));
|
|
LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_error");
|
|
}
|
|
SECTION("10. on_quoter_order_status_update")
|
|
{
|
|
// already done in 9
|
|
}
|
|
SECTION("11. on_hedger_order_error")
|
|
{
|
|
//create the same scenario as 9, but send an error on the hedger order
|
|
set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10},
|
|
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] {10, 10, 10, 10, 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);
|
|
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);
|
|
std::vector<SpreaderHedgerData>& hedgers_leg_2 = leg_data_2.get_hedgers();
|
|
bts_assert (hedgers_leg_2.size() == 1);
|
|
SingleFillHedger& hedger = hedgers_leg_2[0].hedger();
|
|
verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20));
|
|
bts::orderman::OrderKey hedger_order_key = hedgers_leg_2[0].order_update_message().order_key;
|
|
spreader.on_child_update (hedger_order_key, api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr);
|
|
verify_complete_hedger_state (hedger, HedgerState::WORKING, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20));
|
|
std::string err_msg = "error";
|
|
spreader.on_child_update (hedger_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);
|
|
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false);
|
|
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false);
|
|
verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_CANCEL_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20));
|
|
// verify that all quoter and hedgers should
|
|
LOG(OrderMan, Diag, "spreader_WORKING.on_hedger_order_error");
|
|
}
|
|
SECTION("12. on_hedger_order_update")
|
|
{
|
|
//create the same scenario as 9, but send an error on the hedger order
|
|
set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10},
|
|
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] {10, 10, 10, 10, 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);
|
|
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);
|
|
std::vector<SpreaderHedgerData>& hedgers_leg_2 = leg_data_2.get_hedgers();
|
|
bts_assert (hedgers_leg_2.size() == 1);
|
|
SingleFillHedger& hedger = hedgers_leg_2[0].hedger();
|
|
verify_complete_hedger_state (hedger, HedgerState::WAITING_FOR_FIRST_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20));
|
|
// send fill on the hedger order
|
|
bts::orderman::OrderKey hedger_order_key = hedgers_leg_2[0].order_update_message().order_key;
|
|
spreader.on_child_update (hedger_order_key, api::orderman::OrderStatus::OS_NEW, Quantity (5), Price (2000), nullptr);
|
|
verify_complete_hedger_state (hedger, HedgerState::WORKING, Price(1999), Quantity(20), Quantity(5), Price (1999), Quantity(20), Quantity (15));
|
|
// verify that all quoter and hedgers should
|
|
LOG(OrderMan, Diag, "spreader_WORKING.on_hedger_order_update");
|
|
}
|
|
SECTION("13. on_external_error")
|
|
{
|
|
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);
|
|
set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10},
|
|
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] {10, 10, 10, 10, 10});
|
|
spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_PARTIALLY_FILLED, Quantity (20), Price (2000), nullptr);
|
|
SpreaderHedgerData& hedger_data = leg_data_2.get_hedgers()[0];
|
|
spreader.on_child_update (hedger_data.order_update_message().order_key, api::orderman::OrderStatus::OS_NEW, Quantity (0), Price (0), nullptr);
|
|
std::string err_msg = "external error";
|
|
spreader.on_external_error (err_msg);
|
|
verify_basic_spreader_state (spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price, spreader_quantity);
|
|
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (20), Quantity(0), Price(2000), Quantity(100), Quantity(80), false);
|
|
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, true, spreader_price, Quantity (100), Quantity (0), Quantity(20), Price(2002), Quantity(80), Quantity(80), false);
|
|
verify_complete_hedger_state (hedger_data.hedger(), HedgerState::WAITING_FOR_CANCEL_ACK, Price(1999), Quantity(20), Quantity(0), Price (1999), Quantity(20), Quantity (20));
|
|
LOG(OrderMan, Diag, "spreader_WORKING.on_external_error");
|
|
}
|
|
SECTION("14. on_check_termination")
|
|
{
|
|
// get active orders working, send a terminal
|
|
// status on each order and verify that the
|
|
// spreader reached a terminal state
|
|
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);
|
|
set_spreader_orders (spreader, new double[5] {1995, 1996, 1997, 1998, 1999}, new uint16_t[5] {10, 10, 10, 10, 10},
|
|
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] {10, 10, 10, 10, 10});
|
|
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
|
|
// completely fill leg 1, this should cxl the leg 2 quoting order and send a hedge
|
|
// fill the hedge completely
|
|
// this should cause on_check_termination to return true
|
|
spreader.on_child_update (leg_data_1.order_key(), api::orderman::OrderStatus::OS_FILLED, Quantity (100), Price (1999), nullptr);
|
|
// leg1's quoter should be in end state
|
|
verify_complete_quoter_state (*leg_data_1.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(0), Price(0), Quantity(0), Quantity(0), true);
|
|
// leg 2 should cancel its order now
|
|
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false, spreader_price, Quantity (100), Quantity (0), Quantity(100), Price(2002), Quantity(100), Quantity(0), true);
|
|
spreader.on_child_update (leg_data_2.order_key(), api::orderman::OrderStatus::OS_CANCELED, Quantity (0), Price (0), nullptr);
|
|
verify_complete_quoter_state (*leg_data_2.quoter(), QuoterState::END, false, spreader_price, Quantity (100), Quantity (0), Quantity(100), Price(0), Quantity(0), Quantity(0), true);
|
|
bts_assert (leg_data_2.get_hedgers().size() == 1);
|
|
SpreaderHedgerData leg_2_hedger_data = leg_data_2.get_hedgers()[0];
|
|
verify_complete_hedger_state (leg_2_hedger_data.hedger(), HedgerState::WAITING_FOR_FIRST_ACK, Price(1998), Quantity(100), Quantity(0), Price (1998), Quantity(100), Quantity (100));
|
|
verify_basic_spreader_state (spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
|
|
// send a fill, this should make the spreader go to end
|
|
spreader.on_child_update (leg_2_hedger_data.order_update_message().order_key, api::orderman::OrderStatus::OS_FILLED, Quantity (100), Price (1998), nullptr);
|
|
verify_complete_hedger_state (leg_2_hedger_data.hedger(), HedgerState::END, Price(1998), Quantity(100), Quantity(100), Price (0), Quantity(0), Quantity (0));
|
|
verify_basic_spreader_state (spreader, SpreaderState::END, spreader_price, spreader_quantity);
|
|
LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_error");
|
|
}
|
|
}
|
|
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
|
|
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.count(); 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")
|
|
{
|
|
}
|
|
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);
|
|
}
|
|
}}
|
|
|