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

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, &quoter_1, order_key_1));
leg_data_v.push_back (SpreaderLegData (leg_prop_data_2, &quoter_2, order_key_2));
leg_data_v.push_back (SpreaderLegData (leg_prop_data_3, &quoter_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);
}
}}