#ifndef _WIN32 #include "../MDClient.h" #include "../SecurityCache.h" #include "../SettlementRecorder.h" #include "../coconut2.h" #include "../relay/QueryServer.h" #include "Co2TestInstrument.h" #include "catch/catch.hpp" #include "lib/config/config.h" #include "lib/metrics/metrics.h" #include "lib/os/os.h" #include "lib/utils/Dispatcher.h" #include "lib/utils/bts_chrono.h" #include "lib/utils/defer.h" #include "lib/utils/warn_ctrl.h" #include "lib/utils/Shuffle.h" #include "lib/config/protos/market_data.pb.h" #include "lib/utils/Sqlite_utils.h" #include "md_test_utils.h" #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; namespace bts { #ifdef _WIN32 namespace metrics { struct MetricCollection {}; MetricsContainer::MetricsContainer() {} MetricsContainer::~MetricsContainer() {} } // namespace metrics #endif int md_tests = 0; namespace md { // import this from RelayClient.cpp PriceSize book_at( const google::protobuf::RepeatedPtrField &side, int index); namespace test { using namespace api; using namespace co2; Platform TEST_PLATFORM = PLATFORM_SIM; // // Helper functions for Producer/Consumer tests // std::vector create_test_securities(MDProducer &producer, const char *postfix = ""); set get_test_symbols(const char *postfix = "") { set symbols; UserSymbol future_symbol( string("FOO") + postfix, VENUE_BTS, SECURITYTYPE_FUTURE); symbols.insert(future_symbol); UserSymbol option_symbol( string("FOOX") + postfix, VENUE_BTS, SECURITYTYPE_OPTION); symbols.insert(option_symbol); return symbols; } Security mkfuture(string symbol, security_key key, int year, int month, int day) { Security result; result.set_symbol(symbol); result.set_exchange(VENUE_BTS); result.set_id(key); result.mutable_future()->set_expiration_day(day); result.mutable_future()->set_expiration_month(month); result.mutable_future()->set_expiration_year(year); return result; } Security mkoption( string symbol, security_key key, int year, int month, int day, double strike) { Security result; result.set_symbol(symbol); result.set_exchange(VENUE_BTS); result.set_id(key); result.mutable_option()->set_expiration_day(day); result.mutable_option()->set_expiration_month(month); result.mutable_option()->set_expiration_year(year); result.mutable_option()->set_strike(strike); result.mutable_option()->set_call_put(PUTORCALL_PUT); return result; } unique_ptr mkfixedfuture(string symbol, security_key key, int year, int month, int day) { unique_ptr ffs(new FixedFutureSecurity()); ffs->type = SECURITYTYPE_FUTURE; ffs->exchange = VENUE_BTS; ffs->key = key; ffs->expiration_day = day; ffs->expiration_month = month; ffs->expiration_year = year; ffs->symbol(symbol); return ffs; } Security mkspread(string symbol, security_key key, const vector &legs) { Security result; result.set_symbol(symbol); result.set_exchange(VENUE_BTS); result.set_id(key); for (const auto &leg : legs) { auto *pleg = result.mutable_spread()->add_legs(); pleg->mutable_security()->CopyFrom(leg); } return result; } Security mkspread(string symbol, security_key key, Security leg1, Security leg2) { vector vlegs; vlegs.push_back(leg1); vlegs.push_back(leg2); return mkspread(symbol, key, vlegs); } Security mkspread( string symbol, security_key key, Security leg1, Security leg2, Security leg3) { vector vlegs; vlegs.push_back(leg1); vlegs.push_back(leg2); vlegs.push_back(leg3); return mkspread(symbol, key, vlegs); } class Co2Tests { public: void setup() { config::internal::initialize_for_test( "PlatformMap {" " value {" " glbx_platform: 'PLATFORM_SIM'" " }" "}" "PublisherOptions {" " value {" " heartbeat_ms: 100" " heartbeat_boot_seconds: 1" " }" "}"); } #ifndef _WIN32 void test_security_id_recorder(const std::string &db_name) { // Verify callbacks happen after work complete auto db1 = sqlite::open_db(db_name.c_str()); REQUIRE(db1); auto db2 = sqlite::open_db(db_name.c_str()); REQUIRE(db2); SecurityIDRecorder idsvc{{db1}}, idsvc2{{db2}}; security_key result = invalid_security_key; Security s1 = mkoption("FOOX", invalid_security_key, 2018, 1, 20, 1850); Security f1 = mkfuture("FOO", invalid_security_key, 2018, 1, 20); idsvc.assign_key(f1, [](const api::Security &s) { REQUIRE(s.id() != invalid_security_key); }); idsvc.assign_key( s1, [&result](const api::Security &s) { result = s.id(); }); idsvc.do_work(); REQUIRE(s1.id() == invalid_security_key); REQUIRE(result != invalid_security_key); security_key result2 = invalid_security_key; idsvc2.assign_key( s1, [&result2](const api::Security &s) { result2 = s.id(); }); idsvc2.do_work(); if (db_name == ":memory:") { // This is a meta-test to make sure we don't accidently generate the // same key sequence when writing to different databases. REQUIRE(result != result2); } else { REQUIRE(result == result2); } } void test_security_id_recorder_spreads() { // Test that security id recorder can resolve spread legs // Set up "shared memory" auto cold_header = std::make_shared(); auto hot_header = std::make_shared(); // Create a spread with 2 legs auto f1 = mkfuture("FO1", invalid_security_key, 2018, 1, 17); f1.mutable_glbx()->set_exchange_id(100); REQUIRE(f1.id() == invalid_security_key); auto f1handle = std::make_unique(f1, cold_header, hot_header); auto f2 = mkfuture("FO2", invalid_security_key, 2018, 1, 20); f2.mutable_glbx()->set_exchange_id(200); auto f2handle = std::make_unique(f2, cold_header, hot_header); auto s1 = mkspread("FOO", invalid_security_key, {f1, f2}); auto s1handle = std::make_unique(s1, cold_header, hot_header); // Add spread to SecurityIDRecorder and work it auto db = sqlite::open_db(":memory:"); REQUIRE(db); SecurityIDRecorder idsvc{ {db, [&](ExchangeKey k) -> SecurityKey { for (const auto &fut : {f1handle->producer(), f2handle->producer()}) { if (k.value() == fut.security().numeric_id) return SecurityKey(fut.key()); } return SecurityKey(invalid_security_key); }}}; auto workwork = [&]() { idsvc.do_work(); idsvc.do_work(); }; idsvc.ensure_key(s1handle->producer()); workwork(); // Expect no key REQUIRE(s1handle->consumer().key() == invalid_security_key); // Add leg spreads idsvc.ensure_key(f1handle->producer()); idsvc.ensure_key(f2handle->producer()); workwork(); // Expect legs to have keys REQUIRE(f1handle->consumer().key() != invalid_security_key); REQUIRE(f2handle->consumer().key() != invalid_security_key); // Expect spread to have keys REQUIRE(s1handle->consumer().key() != invalid_security_key); } #endif void test_price_size() { // PriceSize violates some type punning rules // So it is important to have this test work correctly on the target // platform PriceSize p2; auto bid = PriceSize_from_double<2>(4.5, 14); auto ask = PriceSize_from_double<9>(4.5, 14); PriceLevel memory; memory = PriceLevel(bid, ask); REQUIRE(bid.price() == memory.bid().price()); REQUIRE(bid.size() == memory.bid().size()); REQUIRE(ask.price() == memory.ask().price()); REQUIRE(ask.size() == memory.ask().size()); for (auto p : {memory.bid(), memory.ask()}) { REQUIRE(p.price() == 4.5); REQUIRE(p.size() == 14); } auto p = PriceSize_from_double<2>(4.0, 5); memory = PriceLevel(p, p); for (auto p2 : {memory.bid(), memory.ask()}) { REQUIRE(p2.price() == 4.0); REQUIRE(p2.size() == 5); } p = PriceSize_from_double<2>(-4.2, 6); memory = PriceLevel(p, p); for (auto p2 : {memory.bid(), memory.ask()}) { REQUIRE(p2.price() == -4.2); REQUIRE(p2.size() == 6); } p = PriceSize({4, -1}, 2); memory = PriceLevel(p, p); for (auto p2 : {memory.bid(), memory.ask()}) { REQUIRE(p2.price() == 0.4); REQUIRE(p2.size() == 2); } // Test requirement for more than 32 bit mantissa double bigval = -9999.9921875; p = PriceSize_from_double<7>(bigval, 42); memory = PriceLevel(p, p); for (auto p2 : {memory.bid(), memory.ask()}) { REQUIRE(p2.price() == bigval); REQUIRE(p2.size() == 42); } } void test_price_size_required_precision() { auto min_tick_2017 = 9999.0078125; auto p17 = PriceSize_from_double<7>(min_tick_2017, 2017); PriceLevel m17(p17, p17); for (auto p : {m17.bid(), m17.ask()}) { REQUIRE(min_tick_2017 == p.price()); REQUIRE(p.size() == 2017); } auto min_tick_2018 = 1999.00390625; auto p18 = PriceSize_from_double<8>(min_tick_2018, 2018); PriceLevel m18(p18, p18); for (auto p : {m18.bid(), m18.ask()}) { REQUIRE(min_tick_2018 == p.price()); REQUIRE(p.size() == 2018); } } void test_slow_double_conversion() { double values[] = {1.5, 0.5, 0.2155, 0.216, 42.1}; int expected[] = {-1, -1, -4, -3, -1}; static_assert(BTS_ARRAYSIZE(values) == BTS_ARRAYSIZE(expected), ""); for (size_t x = 0; x < BTS_ARRAYSIZE(values); ++x) { REQUIRE(to_exponent(values[x]) == expected[x]); } // Tests powers of 10. Important for display_factor conversion for (int x = 8; x > -8; --x) { double d = pow10(x); REQUIRE(to_exponent(d) == x); } } struct ExchangeDecimal { int64_t mantissa; int32_t exponent; }; bool close_enough(double a, double b) { // We need at least 7 places but we're testing with 10 just in case const double acceptable_error = 1E-12; double delta = abs(a - b); // Equal if the delta is less than error return delta < acceptable_error; } void test_producer_consumer() { MDProducer producer(TEST_PLATFORM); vector producers = create_test_securities(producer); // Add bbo data for those expirations auto write_time = TimeStamp::now(); for (auto &p : producers) { p.update_bbo( write_time, PriceSize_from_double<2>(5.0, 5), PriceSize_from_double<2>(5.0, 5)); } // Symbol list for the consumer set symbols; UserSymbol future_symbol("FOO", VENUE_BTS, SECURITYTYPE_FUTURE); symbols.insert(future_symbol); UserSymbol option_symbol("FOOX", VENUE_BTS, SECURITYTYPE_OPTION); symbols.insert(option_symbol); SecurityCache cache; MDConsumer consumer( cache, nullptr, nullptr, &symbols, true, TEST_PLATFORM); vector consumer_securities; // Poll for security list - none visible until they have keys size_t count = consumer.walk_security_list( [&](const SecurityPtr &security, MDConsumerHandle) { consumer_securities.push_back(*security); }); // Since no security has an id none are "public" REQUIRE(consumer_securities.size() == count); REQUIRE(count == 0); // Assign a unique ID to each security (from the producer) assign_ids(producers.begin(), producers.end()); // Now securities can be enumerated by the client count = consumer.walk_security_list( [&](const SecurityPtr &security, MDConsumerHandle) { consumer_securities.push_back(*security); }); REQUIRE(consumer_securities.size() == count); REQUIRE(count == 24); vector consumers; for (const auto &security : consumer_securities) { consumers.push_back(consumer.get_handle(security.id())); } for (const auto &c : consumers) { PriceSize bid, ask; TimeStamp read_time; // get_boo returns true becuase this time is after the change REQUIRE( c.get_direct_book(read_time, 1, &bid, &ask) == HandleReadResult::SUCCESS); REQUIRE((read_time - TimeStamp()).seconds() > 0); REQUIRE(bid.price() == 5.0); REQUIRE(ask.price() == 5.0); REQUIRE(bid.size() == 5); REQUIRE(ask.size() == 5); } // Second query before a write has happend finds no updates auto read_time = TimeStamp::now(); for (const auto &c : consumers) { PriceSize bid, ask; REQUIRE( c.get_direct_book(read_time, 1, &bid, &ask) != HandleReadResult::SUCCESS); } // update everything once more write_time = TimeStamp::now(); for (auto &p : producers) { // Update bid/ask with one call p.update_bbo( write_time, PriceSize_from_double<2>(6.55, 6), PriceSize_from_double<2>(6.55, 6)); } // Now read_time is < write_time for (const auto &c : consumers) { TimeStamp modified_time = read_time; PriceSize bid, ask; // get_direct_book returns true becuase this time is after the change REQUIRE( c.get_direct_book(modified_time, 1, &bid, &ask) == HandleReadResult::SUCCESS); REQUIRE((modified_time - read_time).seconds() > 0); REQUIRE(bid.price() == 6.55); REQUIRE(ask.price() == 6.55); REQUIRE(bid.size() == 6); REQUIRE(ask.size() == 6); } } // When a security is added the consumer should provide callback void test_consumer_callback_on_security_added() { MDProducer producer(TEST_PLATFORM); vector producers = create_test_securities(producer); // Symbol list for the consumer set symbols; UserSymbol future_symbol("FOO", VENUE_BTS, SECURITYTYPE_FUTURE); symbols.insert(future_symbol); UserSymbol option_symbol("FOOX", VENUE_BTS, SECURITYTYPE_OPTION); symbols.insert(option_symbol); SecurityCache cache; MDConsumer consumer( cache, nullptr, nullptr, &symbols, true, TEST_PLATFORM); // Add the on_security callback vector securities; consumer.on_security( [&](const SecurityPtr &security, MDConsumerHandle handle) { REQUIRE(security->id() != invalid_security_key); REQUIRE(security->id() == handle.key()); securities.push_back(*security); }); // No securities have ids yet REQUIRE(securities.size() == 0); // Check for new securities consumer.scan_securities(); // Still none REQUIRE(securities.size() == 0); producers.front().set_key(1001); consumer.scan_securities(); REQUIRE(securities.size() == 1); // Assign the rest of the ids assign_ids( producers.begin() + 1, producers.end(), producers.front().security().key); consumer.scan_securities(); REQUIRE(securities.size() == producers.size()); } // If an MDConsumer is asked for a handle to a security which does not exist // in the system The consumer should return a handle which always returns // false on all calls but wakes up when the security is added. // * Case 1 - the shared memory has been created but the security has not // been discovered // * Case 2 - The producer has never been created void test_consumer_defer_handle1() { MDProducer producer(TEST_PLATFORM); vector producers = create_test_securities(producer); set symbols; UserSymbol future_symbol("FOO", VENUE_BTS, SECURITYTYPE_FUTURE); symbols.insert(future_symbol); UserSymbol option_symbol("FOOX", VENUE_BTS, SECURITYTYPE_OPTION); symbols.insert(option_symbol); SecurityCache cache; MDConsumer consumer( cache, nullptr, nullptr, &symbols, true, TEST_PLATFORM); // Get a handle to 24 consumers which haven't been created yet vector consumers; vector> managed_consumers; security_key key = 1; for (; key < 24; ++key) { consumers.push_back(consumer.get_handle(key + 1000)); managed_consumers.push_back(consumer.get_managed_handle(key + 1000)); } // Set bbo on the producers - still not public TimeStamp write_time = TimeStamp::now(); for (auto &p : producers) { p.update_bbo( write_time, PriceSize_from_double<3>(4.5, 5), PriceSize_from_double<3>(6.75, 7)); } // Even though bbo is available it is not given out because the producing // security does not have an id PriceSize bid, ask; for (auto &c : consumers) { TimeStamp zerotime; REQUIRE( c.get_direct_book(zerotime, 1, &bid, &ask) != HandleReadResult::SUCCESS); } for (auto &mc : managed_consumers) { TimeStamp zerotime; REQUIRE( mc->get_direct_book(zerotime, 1, &bid, &ask) != HandleReadResult::SUCCESS); } assign_ids(producers.begin(), producers.end()); consumer.scan_securities(); size_t bbo_count = 0; // Existing old handles remain invalid for (auto &c : consumers) { TimeStamp zerotime; if (c.get_direct_book(zerotime, 1, &bid, &ask) == HandleReadResult::SUCCESS) { bbo_count++; } } REQUIRE(bbo_count == 0); // Now, magically, the existing (managed) handles are valid for (auto &mc : managed_consumers) { TimeStamp zerotime; if (mc->get_direct_book(zerotime, 1, &bid, &ask) == HandleReadResult::SUCCESS) { bbo_count++; } } REQUIRE(bbo_count > 0); } // It is legal and valid to create a consumer before the producer process has // started Handles given out by that consumer will become valid once the // securities are discovered void test_consumer_defer_handle2() { set symbols; UserSymbol future_symbol("FOO", VENUE_BTS, SECURITYTYPE_FUTURE); symbols.insert(future_symbol); UserSymbol option_symbol("FOOX", VENUE_BTS, SECURITYTYPE_OPTION); symbols.insert(option_symbol); SecurityCache cache; MDConsumer consumer( cache, nullptr, nullptr, &symbols, true, TEST_PLATFORM); // Get a handle to 24 consumers which haven't been created yet vector consumers; vector> managed_consumers; security_key key = 1; for (; key < 24; ++key) { consumers.push_back(consumer.get_handle(key + 1000)); managed_consumers.push_back(consumer.get_managed_handle(key + 1000)); } // Even though bbo is available it is not given out because the producing // security does not have an id PriceSize bid, ask; for (auto &c : consumers) { TimeStamp zerotime; REQUIRE( c.get_direct_book(zerotime, 1, &bid, &ask) != HandleReadResult::SUCCESS); } for (auto &mc : managed_consumers) { TimeStamp zerotime; REQUIRE( mc->get_direct_book(zerotime, 1, &bid, &ask) != HandleReadResult::SUCCESS); } // Only NOW create the producers (and the shared memory) MDProducer producer(TEST_PLATFORM); vector producers = create_test_securities(producer); // Set bbo on the producers - still not public TimeStamp write_time = TimeStamp::now(); for (auto &p : producers) { p.update_bbo( write_time, PriceSize_from_double<3>(4.5, 5), PriceSize_from_double<3>(6.75, 7)); } assign_ids(producers.begin(), producers.end()); consumer.scan_securities(); size_t bbo_count = 0; // Existing old handles remain invalid for (auto &c : consumers) { TimeStamp zerotime; if (c.get_direct_book(zerotime, 1, &bid, &ask) == HandleReadResult::SUCCESS) { bbo_count++; } } REQUIRE(bbo_count == 0); // Now, magically, the existing (managed) handles are valid for (auto &mc : managed_consumers) { TimeStamp zerotime; if (mc->get_direct_book(zerotime, 1, &bid, &ask) == HandleReadResult::SUCCESS) { bbo_count++; } } REQUIRE(bbo_count > 0); } void test_no_double_security_callback() { MDProducer producer(TEST_PLATFORM); vector producers = create_test_securities(producer); // Assign ids so securities are already public in the producer assign_ids(producers.begin(), producers.end()); // Symbol list for the consumer auto symbols = get_test_symbols(); SecurityCache cache; MDConsumer consumer( cache, nullptr, nullptr, &symbols, true, TEST_PLATFORM); // Add the on_security callback - callback fires for existing securities vector securities; consumer.on_security( [&](const SecurityPtr &security, MDConsumerHandle handle) { REQUIRE(security->id() != invalid_security_key); REQUIRE(security->id() == handle.key()); securities.push_back(*security); }); // Found all securities REQUIRE(securities.size() == producers.size()); // Check for new securities consumer.scan_securities(); // Expect no duplicates REQUIRE(securities.size() == producers.size()); } void test_recovery() { auto producer1 = make_shared(TEST_PLATFORM); vector producers = create_test_securities(*producer1); assign_ids(producers.begin(), producers.end()); producer1->get_channel("FOO", SECURITYTYPE_FUTURE, VENUE_BTS).heartbeat(); producer1->get_channel("FOOX", SECURITYTYPE_OPTION, VENUE_BTS) .heartbeat(); for (auto &pro : producers) { pro.update_bbo( TimeStamp::now(), PriceSize({1, 0}, 1), PriceSize({2, 0}, 2)); } // Symbol list for the consumer SecurityCache cache; auto symbols = get_test_symbols(); MDClient client(nullptr, nullptr, nullptr, &symbols); MDConsumer consumer = client.current_consumer(); map products; consumer.on_security( [&](const SecurityPtr &security, MDConsumerHandle handle) { REQUIRE(security->id() == handle.key()); products.insert(make_pair(security->id(), handle)); }); client.scan_securities(); REQUIRE(products.size() == producers.size()); // Check handles for (auto &pair : products) { auto &handle = pair.second; REQUIRE(handle.is_initialized()); REQUIRE(handle.is_heart_beating()); } // Delete the producer try { producers.clear(); producer1.reset(); } catch (std::exception &) { LOG(md, Error, "Failed test trying to destroy producer."); REQUIRE(false); } // Wait out the heartbeat auto options = config::get(); auto ms = std::max( options.heartbeat_ms(), options.heartbeat_boot_seconds() * 1000) + 10; std::this_thread::sleep_for(std::chrono::duration(ms)); // Make sure heartbeat is done try { for (auto &pair : products) { auto &handle = pair.second; REQUIRE(handle.is_initialized()); REQUIRE(handle.is_heart_beating() == false); } } catch (std::exception &) { LOG(md, Error, "Failed to validate heartbeat while producer is down."); REQUIRE(false); } // Create a new producer and attempt to recover shared_ptr producer2; try { producer2 = make_shared(TEST_PLATFORM); } catch (std::exception &) { LOG(md, Error, "Failed to create new producer"); REQUIRE(false); } producers = create_test_securities(*producer2); REQUIRE(products.size() == producers.size()); assign_ids(producers.begin(), producers.end()); producer2->get_channel("FOO", SECURITYTYPE_FUTURE, VENUE_BTS).heartbeat(); producer2->get_channel("FOOX", SECURITYTYPE_OPTION, VENUE_BTS) .heartbeat(); // set bbo to a different value for (auto &pro : producers) { pro.update_bbo( TimeStamp::now(), PriceSize({4, 0}, 5), PriceSize({6, 0}, 7)); } // Attempt to recover the managed handles int on_consumer_count = 0; auto handle = client.on_consumer().subscribe([&](const MDConsumer &c) { ++on_consumer_count; consumer = c; products.clear(); }); client.check_heartbeats(); REQUIRE(on_consumer_count == 1); REQUIRE(products.empty()); // Consumer has been updated consumer.on_security( [&](const SecurityPtr &security, MDConsumerHandle handle) { REQUIRE(security->id() == handle.key()); products.insert(make_pair(security->id(), handle)); }); client.on_consumer().unsubscribe(handle); // Check that the new product handles have been updated for (auto &pair : products) { auto &handle = pair.second; REQUIRE(handle.is_initialized()); REQUIRE(handle.is_heart_beating()); TimeStamp tzero; PriceSize bid, ask; REQUIRE( handle.get_direct_book(tzero, 1, &bid, &ask) == HandleReadResult::SUCCESS); REQUIRE(bid.price() == 4.0); REQUIRE(bid.size() == 5); REQUIRE(ask.price() == 6.0); REQUIRE(ask.size() == 7); } } void test_no_block_forever_on_publisher_crash() { #ifdef _WIN32 #pragma warning(push, 0) #endif // OK if this isn't aligned for testing auto src = std::make_unique("Foo", SECURITYTYPE_FUTURE); #ifdef _WIN32 #pragma warning(pop) #endif TimeStamp read = TimeStamp::now(); src->producer().update_bbo( TimeStamp::invalid(), PriceSize_from_double<3>(100.0, 100), PriceSize_from_double<3>(101.0, 101)); PriceSize bid, ask; TimeStamp start = TimeStamp::now(); auto result = src->consumer().get_direct_book(read, 1, &bid, &ask); TimeStamp end = TimeStamp::now(); REQUIRE(result != HandleReadResult::SUCCESS); REQUIRE((end - start).seconds() < 5); } void test_get_handles() { MDProducer producer(TEST_PLATFORM); vector producers = create_test_securities(producer); // Add entries to the shared memory that we aren't looking for vector p2_no_id = create_test_securities(producer, "2"); vector p3 = create_test_securities(producer, "3"); for (auto &p : producers) { p.update_bbo( TimeStamp::now(), PriceSize_from_double<3>(5.0, 5), PriceSize_from_double<3>(5.0, 5)); } assign_ids(producers.begin(), producers.end()); assign_ids(p3.begin(), p3.end()); // Symbol list for the consumer - only search half of the symbols set symbols; UserSymbol future_symbol("FOO", VENUE_BTS, SECURITYTYPE_FUTURE); symbols.insert(future_symbol); UserSymbol option_symbol("FOOX", VENUE_BTS, SECURITYTYPE_OPTION); symbols.insert(option_symbol); SecurityCache cache; MDConsumer consumer( cache, nullptr, nullptr, &symbols, true, TEST_PLATFORM); set keys; consumer.walk_security_list( [&](const SecurityPtr &security, MDConsumerHandle) { keys.insert(security->id()); }); REQUIRE(keys.size() == producers.size()); auto map = consumer.get_handles(keys); REQUIRE(map.size() == keys.size()); for (const auto &entry : map) { REQUIRE(entry.second.is_initialized()); } } void test_denormalization() { // By using a different symbol for each security // we put them all on separate shared mem sections (co2 channels) security_key key = 999; Security f1 = mkfuture("F1", ++key, 2016, 5, 1); Security o1 = mkoption("O1", ++key, 2016, 5, 1, 100); Security o2 = mkoption("O2", ++key, 2016, 5, 2, 200); Security o3 = mkoption("O3", ++key, 2016, 5, 3, 300); Security s4 = mkspread("S3", ++key, o2, o3); Security s3 = mkspread("S4", ++key, o1, s4); Security s2 = mkspread("S2", ++key, o1, s4, s3); Security s1 = mkspread("S1", ++key, f1, s2); Security all_secs_array[] = {f1, o1, o2, o3, s1, s2, s3, s4}; MDProducer producer(TEST_PLATFORM); vector producers; for (auto &sec : all_secs_array) { with_security_like(sec, [&](FixedSecurity &fsec) { convert_security(sec, fsec, true); producers.push_back(producer.add_security(fsec)); }); } set csymbols; csymbols.insert(UserSymbol("F1", VENUE_BTS, SECURITYTYPE_FUTURE)); csymbols.insert(UserSymbol("O1", VENUE_BTS, SECURITYTYPE_OPTION)); csymbols.insert(UserSymbol("O2", VENUE_BTS, SECURITYTYPE_OPTION)); csymbols.insert(UserSymbol("O3", VENUE_BTS, SECURITYTYPE_OPTION)); csymbols.insert(UserSymbol("S1", VENUE_BTS, SECURITYTYPE_SPREAD)); csymbols.insert(UserSymbol("S2", VENUE_BTS, SECURITYTYPE_SPREAD)); csymbols.insert(UserSymbol("S3", VENUE_BTS, SECURITYTYPE_SPREAD)); csymbols.insert(UserSymbol("S4", VENUE_BTS, SECURITYTYPE_SPREAD)); SecurityCache cache; MDConsumer consumer( cache, nullptr, nullptr, &csymbols, true, TEST_PLATFORM); auto check_sec = [&](const SecurityPtr &security, MDConsumerHandle handle) { REQUIRE(security->id() == handle.key()); auto iter = find_if( std::begin(all_secs_array), std::end(all_secs_array), [&](const Security &sec) { return sec.id() == security->id(); }); REQUIRE(iter != end(all_secs_array)); REQUIRE(iter->symbol() == (security->symbol())); if (security->Contract_case() == Security::kSpread) { REQUIRE(security->spread().normalized() == false); REQUIRE( security->spread().legs_size() == iter->spread().legs_size()); for (int x = 0; x < security->spread().legs_size(); ++x) { REQUIRE( (security->spread().legs(x).security().id()) == (iter->spread().legs(x).security().id())); } } }; consumer.walk_security_list(check_sec); consumer.on_security(check_sec); consumer.scan_securities(); } void test_denormalization2() { // Just like test_denormailzation but with a different memory layout security_key key = 999; Security f1 = mkfuture("FF", ++key, 2016, 5, 1); Security o1 = mkoption("OO", ++key, 2016, 5, 1, 100); Security o2 = mkoption("OO", ++key, 2016, 5, 2, 200); Security o3 = mkoption("OO", ++key, 2016, 5, 3, 300); Security s4 = mkspread("SS", ++key, o2, o3); Security s3 = mkspread("SS", ++key, o1, s4); Security s2 = mkspread("SS", ++key, o1, s4, s3); Security s1 = mkspread("SS", ++key, f1, s2); Security all_secs_array[] = {f1, o1, o2, o3, s1, s2, s3, s4}; MDProducer producer(TEST_PLATFORM); vector producers; for (auto &sec : all_secs_array) { with_security_like(sec, [&](FixedSecurity &fsec) { convert_security(sec, fsec, true); producers.push_back(producer.add_security(fsec)); }); } set csymbols; csymbols.insert(UserSymbol("FF", VENUE_BTS, SECURITYTYPE_FUTURE)); csymbols.insert(UserSymbol("OO", VENUE_BTS, SECURITYTYPE_OPTION)); csymbols.insert(UserSymbol("SS", VENUE_BTS, SECURITYTYPE_SPREAD)); SecurityCache cache; MDConsumer consumer( cache, nullptr, nullptr, &csymbols, true, TEST_PLATFORM); auto check_sec = [&](const SecurityPtr &security, MDConsumerHandle handle) { REQUIRE(security->id() == handle.key()); auto iter = find_if( begin(all_secs_array), end(all_secs_array), [&](const Security &sec) { return sec.id() == security->id(); }); REQUIRE(iter != end(all_secs_array)); REQUIRE((iter->id()) == (security->id())); if (security->Contract_case() == Security::kSpread) { REQUIRE(security->spread().normalized() == false); REQUIRE( security->spread().legs_size() == iter->spread().legs_size()); for (int x = 0; x < security->spread().legs_size(); ++x) { REQUIRE( (security->spread().legs(x).security().id()) == (iter->spread().legs(x).security().id())); } } }; consumer.walk_security_list(check_sec); consumer.on_security(check_sec); consumer.scan_securities(); } void test_retry_unresolved_spread() { // Make 2 spreads with option legs // Leave out one leg for hte other spread // The other spread only shows up once its option leg is produced Security o1 = mkoption("OO", 400, 2016, 5, 1, 100); Security o2 = mkoption("OO", 401, 2016, 5, 2, 200); Security o3 = mkoption("OO", 402, 2016, 5, 3, 300); Security s1 = mkspread("SS", 500, o1, o2); Security s2 = mkspread("SS", 501, o2, o3); MDProducer producer(TEST_PLATFORM); map handles; auto add_security = [&](const Security &sec) { with_security_like(sec, [&](FixedSecurity &fsec) { convert_security(sec, fsec, true); handles.insert(make_pair(fsec.key, producer.add_security(fsec))); }); }; // "options publisher has not started yet" // add_security(o1); // add_security(o2); // add_security(o3); add_security(s1); add_security(s2); // Create consumer set consumer_symbols; consumer_symbols.insert(UserSymbol("OO", VENUE_BTS, SECURITYTYPE_OPTION)); consumer_symbols.insert(UserSymbol("SS", VENUE_BTS, SECURITYTYPE_SPREAD)); SecurityCache cache; MDConsumer consumer( cache, nullptr, nullptr, &consumer_symbols, true, TEST_PLATFORM); size_t security_count = 0; // Indirection for check function function check_func; check_func = [&](const Security &) { REQUIRE(false); }; consumer.on_security([&](const SecurityPtr &sec, MDConsumerHandle) { ++security_count; check_func(*sec); }); consumer.scan_securities(); REQUIRE(security_count == 0); // OK, now add enough options to resolve s1 but not s2 add_security(o1); add_security(o2); check_func = [&](const Security &security) { if (security.Contract_case() == Security::kSpread) { set legs; for (const auto &leg : security.spread().legs()) { legs.insert(leg.security().id()); } REQUIRE(security.id() == 500); REQUIRE(legs.size() == 2); REQUIRE(legs.count(400) == 1); REQUIRE(legs.count(401) == 1); } }; consumer.scan_securities(); // finds o1,o2,s1 consumer.scan_securities(); // finds nothing REQUIRE(security_count == 3); // Then add the last security and we should see s2 add_security(o3); check_func = [&](const Security &security) { if (security.Contract_case() == Security::kSpread) { set legs; for (const auto &leg : security.spread().legs()) { legs.insert(leg.security().id()); } REQUIRE(security.id() == 501); REQUIRE(legs.size() == 2); REQUIRE(legs.count(401) == 1); REQUIRE(legs.count(402) == 1); } }; consumer.scan_securities(); REQUIRE(security_count == 5); } #ifndef _WIN32 void test_settlement_recorder() { using namespace datetime; security_key k1 = 401, k2 = 402; Security o1 = mkoption("OO", k1, 2016, 5, 1, 100); Security o2 = mkoption("OO", k2, 2016, 5, 2, 200); MDProducer producer(TEST_PLATFORM); auto add_security = [&](const Security &sec) { unique_ptr phandle; with_security_like(sec, [&](FixedSecurity &fsec) { convert_security(sec, fsec, true); phandle.reset(new MDProducerHandle(producer.add_security(fsec))); }); return phandle; }; auto ph1 = *add_security(o1); auto ph2 = *add_security(o2); set consumer_symbols; consumer_symbols.insert(UserSymbol("OO", VENUE_BTS, SECURITYTYPE_OPTION)); SecurityCache cache; MDConsumer consumer( cache, nullptr, nullptr, &consumer_symbols, true, TEST_PLATFORM); auto h1 = consumer.get_handle(k1); REQUIRE(h1.is_initialized()); auto h2 = consumer.get_handle(k2); // Pick 2 valid dates in the future auto today = datetime::today(); today.year += 1; auto yesterday = datetime::add_days(today, -1); { co2::SettlementRecorder recorder(PLATFORM_UNSET); recorder.add_settlement(ph1, {101, 0}, yesterday); recorder.add_settlement(ph1, {102, 0}, today); recorder.add_settlement(ph2, {199, 0}, yesterday); recorder.add_settlement(ph2, {188, 0}, today); recorder.do_work(); recorder.do_work(); } REQUIRE(h1.settlement_price().price() == 102); REQUIRE(h1.misc().settlement_date == today); REQUIRE(h1.misc().previous_settlement_price.price() == 101); REQUIRE(h1.misc().previous_settlement_date == yesterday); REQUIRE(h2.settlement_price().price() == 188); REQUIRE(h2.misc().settlement_date == today); REQUIRE(h2.misc().previous_settlement_price.price() == 199); REQUIRE(h2.misc().previous_settlement_date == yesterday); // Update but skip persist auto tomorrow = datetime::add_days(today, 1); ph1.update_settlement(TimeStamp::now(), {103, 0}, tomorrow); REQUIRE(h1.settlement_price().price() == 103); REQUIRE(h1.misc().settlement_date == tomorrow); REQUIRE(h1.misc().previous_settlement_price.price() == 102); REQUIRE(h1.misc().previous_settlement_date == today); ph1.update_previous_settlement(TimeStamp::now(), {0, 0}, Date()); REQUIRE(h1.settlement_price().price() == 103); REQUIRE(h1.misc().settlement_date == tomorrow); ph1.update_settlement(TimeStamp::now(), {0, 0}, Date()); REQUIRE(h1.settlement_price().price() == 0); REQUIRE(h1.misc().settlement_date.day == 0); // pushing a new settlement for today doesn't invalidate yesterday ph2.update_settlement(TimeStamp::now(), {201, 0}, today); REQUIRE(h2.settlement_price().price() == 201); REQUIRE(h2.misc().settlement_date == today); REQUIRE(h2.misc().previous_settlement_price.price() == 199); REQUIRE(h2.misc().previous_settlement_date == yesterday); // Restore persisted state { co2::SettlementRecorder recorder(PLATFORM_UNSET); recorder.restore_settlement(ph1); recorder.restore_settlement(ph2); recorder.do_work(); } REQUIRE(h1.settlement_price().price() == 102); REQUIRE(h1.misc().settlement_date == today); REQUIRE(h1.misc().previous_settlement_price.price() == 101); REQUIRE(h1.misc().previous_settlement_date == yesterday); REQUIRE(h2.settlement_price().price() == 188); REQUIRE(h2.misc().settlement_date == today); REQUIRE(h2.misc().previous_settlement_price.price() == 199); REQUIRE(h2.misc().previous_settlement_date == yesterday); } #endif void teardown() {} }; std::unique_ptr co2_tests; TEST_CASE("CO2Tests", "[md]") { // Lazy created this for config if (!co2_tests) co2_tests = std::make_unique(); co2_tests->setup(); #ifndef _WIN32 SECTION("test_security_id_recorder") { co2_tests->test_security_id_recorder(":memory:"); co2_tests->test_security_id_recorder("file::memory:?cache=shared"); } SECTION("test_security_id_recorder_spreads") { co2_tests->test_security_id_recorder_spreads(); } #endif SECTION("test_price_size") { co2_tests->test_price_size(); } SECTION("test_price_size_required_precision") { co2_tests->test_price_size_required_precision(); } SECTION("test_slow_double_conversion") { co2_tests->test_slow_double_conversion(); } SECTION("test_producer_consumer") { co2_tests->test_producer_consumer(); } SECTION("test_consumer_callback_on_security_added") { co2_tests->test_consumer_callback_on_security_added(); } SECTION("test_consumer_defer_handle1") { co2_tests->test_consumer_defer_handle1(); } SECTION("test_consumer_defer_handle2") { co2_tests->test_consumer_defer_handle2(); } SECTION("test_no_double_security_callback") { co2_tests->test_no_double_security_callback(); } SECTION("test_recovery") { co2_tests->test_recovery(); } SECTION("test_no_block_forever_on_publisher_crash") { co2_tests->test_no_block_forever_on_publisher_crash(); } SECTION("test_get_handles") { co2_tests->test_get_handles(); } SECTION("test_denormalization") { co2_tests->test_denormalization(); } SECTION("test_denormalization2") { co2_tests->test_denormalization2(); } SECTION("test_retry_unresolved_spread") { co2_tests->test_retry_unresolved_spread(); } #ifndef _WIN32 SECTION("test_settlement_recorder") { co2_tests->test_settlement_recorder(); } #endif } struct Co2IndexTests { vector random_ids; set used_ids; const int iterations; tbb::task_scheduler_init _tbb; Co2IndexTests() : random_ids(), used_ids(), iterations(50), _tbb(tbb::task_scheduler_init::automatic) {} void setup() { used_ids.clear(); random_ids.clear(); std::uniform_int_distribution rand_distribution(1, 0x7FFFFFFF); std::mt19937 random_number_engine; auto genrandom = std::bind(rand_distribution, random_number_engine); set temp_ids; for (int x = 0; x < 9999; ++x) { auto r = genrandom(); if (x < 1000) { used_ids.insert(r); } temp_ids.insert(r); } for (uint64_t id : temp_ids) { random_ids.push_back(id); } REQUIRE(random_ids.size() > 1000); } struct Handle { Handle() : _key(0) {} uint64_t _key; security_key key() const { return _key; } void key(security_key key) { _key = key; } }; struct SecurityData { uint64_t exchange_id; Security security; Handle handle; }; template void gen_securities(Index &index) { unique_ptr temp; uint32_t count = 0; for (auto &id : used_ids) { ++count; temp.reset(new SecurityData()); temp->security.Clear(); temp->security.set_symbol("FOOX"); temp->security.mutable_option(); temp->security.mutable_glbx()->set_exchange_id(id); temp->exchange_id = id; temp->handle.key(count); index.add_security(id, std::move(temp)); } } template void test_random_search(Index &index) { vector temp(random_ids); utils::Shuffle::shuffle(temp.begin(), temp.end()); for (auto &id : temp) { if (used_ids.find(id) != used_ids.end()) { REQUIRE(index.has_security(id)); } else { REQUIRE(index.get_security(id) == nullptr); } } } template void test_walk(Index &index) { int count = 0; index.walk_security_list([&count](const SecurityData &) { ++count; }); REQUIRE(count == (int)used_ids.size()); } typedef SimpleSecurityIndex MySimpleIndex; void test_simple_index_search() { MySimpleIndex index; gen_securities(index); for (int x = 0; x < iterations; ++x) { test_random_search(index); } } void test_simple_index_parallel_search() { MySimpleIndex index; gen_securities(index); tbb::parallel_for(0, iterations, [&](int) { test_random_search(index); }); } void test_simple_index_iterate() { MySimpleIndex index; gen_securities(index); test_walk(index); } typedef ConcurrentSecurityIndex MyConcurrentIndex; void test_concurrent_index_search() { MyConcurrentIndex index; gen_securities(index); for (int x = 0; x < iterations; ++x) { test_random_search(index); } } void test_concurrent_index_parallel_search() { MyConcurrentIndex index; gen_securities(index); tbb::parallel_for(0, iterations, [&](int) { test_random_search(index); }); } void test_concurrent_index_iterate() { MyConcurrentIndex index; gen_securities(index); test_walk(index); } }; struct Co2RelayTests { SecurityCache cache; Co2RelayTests() : _stats() {} void setup() { config::internal::initialize_for_test( "PlatformMap {" " value {" " glbx_platform: 'PLATFORM_SIM'" " }" "}"); } void teardown() {} MDConsumer create_consumer() { set symbols; UserSymbol future_symbol("FOO", VENUE_BTS, SECURITYTYPE_FUTURE); symbols.insert(future_symbol); UserSymbol option_symbol("FOOX", VENUE_BTS, SECURITYTYPE_OPTION); symbols.insert(option_symbol); SecurityCache cache; MDConsumer consumer(cache, nullptr, nullptr, &symbols); return consumer; } template T simulate_wire_transfer(const T &request) { T temp; std::string buffer; request.SerializeToString(&buffer); temp.ParseFromString(buffer); return temp; } metrics::MetricsContainer _stats; const std::set setup_symbols() { std::set result; for (const auto &symbol : {"FOO", "FOOF"}) { result.insert({symbol, VENUE_BTS, SECURITYTYPE_FUTURE}); } return result; } std::unique_ptr setup_query_server( MDClient &client, MDProducer &producer, Entitlements *out_entitlements, vector *out_producers) { // Create a bunch of securities for (size_t x = 0; x < 100; ++x) { // That's right. Expirations daily. out_producers->push_back(producer.add_security(*mkfixedfuture( "FOO", invalid_security_key, 2017, 1 + (x / 28), x % 27 + 1))); out_producers->push_back(producer.add_security(*mkfixedfuture( "FOOF", invalid_security_key, 2017, 1 + (x / 28), x % 27 + 1))); } assign_ids(out_producers->begin(), out_producers->end(), 1000); // set query server set symbols; symbols.insert({"FOO", VENUE_BTS, SECURITYTYPE_FUTURE}); symbols.insert({"FOOF", VENUE_BTS, SECURITYTYPE_FUTURE}); for (const auto &s : symbols) { out_entitlements->insert(s.symbol()); } auto server = create_query_server(client, _stats); REQUIRE(server); client.scan_securities(); return server; } void relay_nans() { MDProducer producer(TEST_PLATFORM); Entitlements entitlements; // initialize data vector producers; // // todo: setup_query_server should use client.symbols() instead of it's // own list // const auto symbols = setup_symbols(); MDClient client(nullptr, nullptr, nullptr, &symbols); auto server = setup_query_server(client, producer, &entitlements, &producers); // assign prices PriceSize price35 = PriceSize_from_double<2>(3.5, 5); PriceSize price5 = PriceSize_from_double<2>(5, 5); for (auto p : producers) { p.update_bbo(TimeStamp::now(), price35, price35); } // Request via query server co2::MDRequest request; for (const auto &symbol : symbols) { auto *chan = request.add_channels(); chan->set_type(symbol.type()); chan->set_symbol(symbol.symbol()); chan->set_exchange(symbol.exchange()); chan->set_flags(co2::MDRequest::BBO | co2::MDRequest::SECURITY); chan->set_entitled(true); } // This request should include everything co2::MDReply reply; server->query(request, &reply, &entitlements, false); reply = simulate_wire_transfer(reply); REQUIRE((size_t)reply.channels().size() == 2); // update the request to match the server time for (int ch = 0; ch < 2; ++ch) { REQUIRE( (size_t)reply.channels(ch).updates().size() == producers.size() / 2); for (auto &update : reply.channels(ch).updates()) { REQUIRE(update.has_security()); REQUIRE(update.has_direct()); REQUIRE(update.direct().asks_size() > 0); REQUIRE(update.direct().bids_size() > 0); REQUIRE(book_at(update.direct().bids(), 0) == price35); REQUIRE(book_at(update.direct().asks(), 0) == price35); } } // Second request with updated time should include nothing request.mutable_channels(0)->set_time(reply.channels(0).channel().time()); request.mutable_channels(1)->set_time(reply.channels(1).channel().time()); reply.Clear(); server->query(request, &reply, &entitlements, false); reply = simulate_wire_transfer(reply); REQUIRE(reply.channels().size() == 2); REQUIRE(reply.channels(0).updates().size() == 0); REQUIRE(reply.channels(1).updates().size() == 0); // Update a single price and make sure we get that back producers[0].update_bbo(TimeStamp::now(), price5, price5, 1); request.mutable_channels(0)->set_time(reply.channels(0).channel().time()); reply.Clear(); server->query(request, &reply, &entitlements, false); reply = simulate_wire_transfer(reply); REQUIRE(reply.channels().size() == 2); REQUIRE(reply.channels(0).updates().size() == 1); REQUIRE(reply.channels(1).updates().size() == 0); REQUIRE(reply.channels(0).updates(0).has_direct()); REQUIRE( book_at(reply.channels(0).updates(0).direct().bids(), 0) == price5); REQUIRE( book_at(reply.channels(0).updates(0).direct().asks(), 0) == price5); // NaN out all the prices - expect to get a full set of updates for (auto p : producers) { p.update_bbo(TimeStamp::now(), NO_MARKET, NO_MARKET, 2); } request.mutable_channels(0)->set_time(reply.channels(0).channel().time()); reply.Clear(); server->query(request, &reply, &entitlements, false); reply = simulate_wire_transfer(reply); REQUIRE(reply.channels().size() == 2); REQUIRE( (size_t)reply.channels(0).updates().size() == producers.size() / 2); REQUIRE( (size_t)reply.channels(1).updates().size() == producers.size() / 2); for (auto &channel : reply.channels()) { for (auto &update : channel.updates()) { REQUIRE(update.has_direct()); // We need to have a book to signal that it was updated but it can // have no rows. This signifies an empty book and will be written // as such by the relay client. REQUIRE(book_at(update.direct().bids(), 0) == NO_MARKET); REQUIRE(book_at(update.direct().asks(), 0) == NO_MARKET); } } // Fill up the markets again for (auto p : producers) { p.update_bbo(TimeStamp::now(), price35, price35, 3); } request.mutable_channels(0)->set_time(reply.channels(0).channel().time()); request.mutable_channels(1)->set_time(reply.channels(1).channel().time()); reply.Clear(); server->query(request, &reply, &entitlements, false); reply = simulate_wire_transfer(reply); REQUIRE(reply.channels().size() == 2); REQUIRE( (size_t)reply.channels(0).updates().size() == producers.size() / 2); REQUIRE( (size_t)reply.channels(1).updates().size() == producers.size() / 2); for (auto &channel : reply.channels()) { for (auto &update : channel.updates()) { REQUIRE(update.has_direct()); REQUIRE(update.direct().bids_size() > 0); REQUIRE(update.direct().asks_size() > 0); REQUIRE(book_at(update.direct().bids(), 0) == price35); REQUIRE(book_at(update.direct().asks(), 0) == price35); } } // NaN out the bids for (auto p : producers) { p.update_bbo(TimeStamp::now(), NO_MARKET, price35, 4); } request.mutable_channels(0)->set_time(reply.channels(0).channel().time()); request.mutable_channels(1)->set_time(reply.channels(1).channel().time()); reply.Clear(); server->query(request, &reply, &entitlements, false); reply = simulate_wire_transfer(reply); REQUIRE(reply.channels().size() == 2); REQUIRE( (size_t)reply.channels(0).updates().size() == producers.size() / 2); REQUIRE( (size_t)reply.channels(1).updates().size() == producers.size() / 2); for (auto &channel : reply.channels()) { for (auto &update : channel.updates()) { REQUIRE(update.has_direct()); REQUIRE(book_at(update.direct().bids(), 0) == NO_MARKET); REQUIRE(book_at(update.direct().asks(), 0) == price35); } } } void relay_implied() { MDProducer producer(TEST_PLATFORM); // initialize data vector producers; Entitlements entitlements; const auto symbols = setup_symbols(); MDClient client(nullptr, nullptr, nullptr, &symbols); auto server = setup_query_server(client, producer, &entitlements, &producers); // assign prices to all levels auto set_direct = [&](PriceSize bid, PriceSize ask) { for (auto p : producers) { std::array bids, asks; for (auto &p : bids) p = bid; for (auto &p : asks) p = ask; p.update_direct(TimeStamp::now(), bids, asks); } }; auto set_implied = [&](PriceSize bid, PriceSize ask) { for (auto p : producers) { std::array implied_bids, implied_asks; for (auto &p : implied_bids) p = bid; for (auto &p : implied_asks) p = ask; p.update_implied(TimeStamp::now(), implied_bids, implied_asks); } }; PriceSize price35 = PriceSize_from_double<7>(3.5, 5); PriceSize price5 = PriceSize_from_double<7>(5, 5); set_direct(price35, price5); set_implied(price35, price5); // Form the request co2::MDRequest request; auto *chan = request.add_channels(); chan->set_type(SECURITYTYPE_FUTURE); chan->set_symbol("FOO"); chan->set_exchange(VENUE_BTS); chan->set_flags(co2::MDRequest::DIRECT | co2::MDRequest::IMPLIED); // Send the request co2::MDReply reply; server->query(request, &reply, &entitlements, false); reply = simulate_wire_transfer(reply); // check price levels REQUIRE(reply.channels_size() > 0); for (auto &channel : reply.channels()) { for (auto &update : channel.updates()) { REQUIRE(update.has_direct()); REQUIRE(update.has_implied()); REQUIRE(update.direct().bids_size() == COCONUT_MAX_DEPTH); REQUIRE(update.direct().asks_size() == COCONUT_MAX_DEPTH); REQUIRE(update.implied().bids_size() == COCONUT_MAX_IMPLIED_DEPTH); REQUIRE(update.implied().asks_size() == COCONUT_MAX_IMPLIED_DEPTH); for (size_t x = 0; x < COCONUT_MAX_DEPTH; ++x) { REQUIRE(book_at(update.direct().bids(), x) == price35); REQUIRE(book_at(update.direct().asks(), x) == price5); } for (size_t x = 0; x < COCONUT_MAX_IMPLIED_DEPTH; ++x) { REQUIRE(book_at(update.implied().bids(), x) == price35); REQUIRE(book_at(update.implied().asks(), x) == price5); } } } // // Nan out implied request.mutable_channels(0)->set_time(reply.channels(0).channel().time()); set_implied(NO_MARKET, NO_MARKET); reply.Clear(); server->query(request, &reply, &entitlements, false); reply = simulate_wire_transfer(reply); for (auto &channel : reply.channels()) { for (auto &update : channel.updates()) { REQUIRE(update.has_direct()); REQUIRE(update.has_implied()); REQUIRE(update.direct().bids_size() == COCONUT_MAX_DEPTH); REQUIRE(update.direct().asks_size() == COCONUT_MAX_DEPTH); REQUIRE(update.implied().bids_size() == 0); REQUIRE(update.implied().asks_size() == 0); for (size_t x = 0; x < COCONUT_MAX_DEPTH; ++x) { REQUIRE(book_at(update.direct().bids(), x) == price35); REQUIRE(book_at(update.direct().asks(), x) == price5); } for (size_t x = 0; x < COCONUT_MAX_IMPLIED_DEPTH; ++x) { REQUIRE(book_at(update.implied().bids(), x) == NO_MARKET); REQUIRE(book_at(update.implied().asks(), x) == NO_MARKET); } } } // // Nan out direct request.mutable_channels(0)->set_time(reply.channels(0).channel().time()); set_direct(NO_MARKET, NO_MARKET); reply.Clear(); server->query(request, &reply, &entitlements, false); reply = simulate_wire_transfer(reply); for (auto &channel : reply.channels()) { for (auto &update : channel.updates()) { REQUIRE(update.has_direct()); REQUIRE(update.has_implied()); REQUIRE(update.direct().bids_size() == 0); REQUIRE(update.direct().asks_size() == 0); REQUIRE(update.implied().bids_size() == 0); REQUIRE(update.implied().asks_size() == 0); for (size_t x = 0; x < COCONUT_MAX_DEPTH; ++x) { REQUIRE(book_at(update.direct().bids(), x) == NO_MARKET); REQUIRE(book_at(update.direct().asks(), x) == NO_MARKET); } for (size_t x = 0; x < COCONUT_MAX_IMPLIED_DEPTH; ++x) { REQUIRE(book_at(update.implied().bids(), x) == NO_MARKET); REQUIRE(book_at(update.implied().asks(), x) == NO_MARKET); } } } // // restore values request.mutable_channels(0)->set_time(reply.channels(0).channel().time()); set_direct(price5, price35); set_implied(price5, price35); reply.Clear(); server->query(request, &reply, &entitlements, false); reply = simulate_wire_transfer(reply); for (auto &channel : reply.channels()) { for (auto &update : channel.updates()) { REQUIRE(update.has_direct()); REQUIRE(update.has_implied()); REQUIRE(update.direct().bids_size() == COCONUT_MAX_DEPTH); REQUIRE(update.direct().asks_size() == COCONUT_MAX_DEPTH); REQUIRE(update.implied().bids_size() == COCONUT_MAX_IMPLIED_DEPTH); REQUIRE(update.implied().asks_size() == COCONUT_MAX_IMPLIED_DEPTH); for (size_t x = 0; x < COCONUT_MAX_DEPTH; ++x) { REQUIRE(book_at(update.direct().bids(), x) == price5); REQUIRE(book_at(update.direct().asks(), x) == price35); } for (size_t x = 0; x < COCONUT_MAX_IMPLIED_DEPTH; ++x) { REQUIRE(book_at(update.implied().bids(), x) == price5); REQUIRE(book_at(update.implied().asks(), x) == price35); } } } } }; TEST_CASE("Co2RelayTests", "[md]") { Co2RelayTests co2_relay_tests; co2_relay_tests.setup(); SECTION("relay_nans") { co2_relay_tests.relay_nans(); } SECTION("relay_implied") { co2_relay_tests.relay_implied(); } } namespace ImpliedTests { void test_merge( const std::array &direct_bid, const std::array &implied_bid, const std::array &direct_ask, const std::array &implied_ask, const std::function &)> &validate) { MDProducer producer(TEST_PLATFORM); vector producers = create_test_securities(producer); auto write_time = TimeStamp::now(); // update both direct and implied for (auto &p : producers) { p.update_direct(write_time, direct_bid, direct_ask, 0); p.update_implied(write_time, implied_bid, implied_ask, 1); } // read from both set symbols; UserSymbol future_symbol("FOO", VENUE_BTS, SECURITYTYPE_FUTURE); symbols.insert(future_symbol); UserSymbol option_symbol("FOOX", VENUE_BTS, SECURITYTYPE_OPTION); symbols.insert(option_symbol); SecurityCache cache; MDConsumer consumer(cache, nullptr, nullptr, &symbols); vector consumer_securities; // Poll for security list - none visible until they have keys size_t count = consumer.walk_security_list( [&](const SecurityPtr &security, MDConsumerHandle) { consumer_securities.push_back(*security); }); // Since no security has an id none are "public" REQUIRE(consumer_securities.size() == count); REQUIRE(count == 0); assign_ids(producers.begin(), producers.end()); // Now securities can be enumerated by the client count = consumer.walk_security_list( [&](const SecurityPtr &security, MDConsumerHandle) { consumer_securities.push_back(*security); }); REQUIRE(consumer_securities.size() == count); REQUIRE(count == 24); vector consumers; for (const auto &security : consumer_securities) { consumers.push_back(consumer.get_handle(security.id())); } validate(consumers); } } // namespace ImpliedTests TEST_CASE("MergeImpliedTests", "[md]") { config::internal::initialize_for_test( "PlatformMap {" " value {" " glbx_platform: 'PLATFORM_SIM'" " }" "}"); // create a handle with implied and direct std::array direct_bid, direct_ask; std::array implied_bid, implied_ask; SECTION("equal_impiled_deep") { for (size_t x = 0; x < direct_bid.size(); ++x) { direct_bid[x] = PriceSize_from_double<7>(x * 100, 2); if (x < implied_bid.size()) { implied_bid[x] = PriceSize_from_double<7>(x * 100, 1); } } direct_ask = direct_bid; implied_ask = implied_bid; ImpliedTests::test_merge( direct_bid, implied_bid, direct_ask, implied_ask, [](const vector &consumers) { for (const auto &c : consumers) { std::array bids, asks; TimeStamp read_time; // get_book returns true becuase this time is after the change REQUIRE( c.get_direct_book( read_time, COCONUT_MAX_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); for (size_t x = 0; x < COCONUT_MAX_DEPTH; ++x) { REQUIRE(bids[x].size() == 2); REQUIRE(bids[x].direct_size() == 2); REQUIRE(bids[x].implied_size() == 0); REQUIRE(asks[x].size() == 2); REQUIRE(asks[x].direct_size() == 2); REQUIRE(asks[x].implied_size() == 0); } read_time = TimeStamp(); REQUIRE( c.get_implied_book( read_time, COCONUT_MAX_IMPLIED_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); for (size_t x = 0; x < COCONUT_MAX_IMPLIED_DEPTH; ++x) { REQUIRE(bids[x].size() == 1); REQUIRE(asks[x].size() == 1); REQUIRE(bids[x].direct_size() == 0); REQUIRE(bids[x].implied_size() == 1); REQUIRE(asks[x].direct_size() == 0); REQUIRE(asks[x].implied_size() == 1); } read_time = TimeStamp(); REQUIRE( c.get_book( read_time, COCONUT_MAX_IMPLIED_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); for (size_t x = 0; x < COCONUT_MAX_DEPTH; ++x) { if (x < COCONUT_MAX_IMPLIED_DEPTH) { REQUIRE(bids[x].size() == 3); REQUIRE(asks[x].size() == 3); REQUIRE(bids[x].direct_size() == 2); REQUIRE(bids[x].implied_size() == 1); REQUIRE(asks[x].direct_size() == 2); REQUIRE(asks[x].implied_size() == 1); } else { REQUIRE(bids[x].size() == 2); REQUIRE(asks[x].size() == 2); REQUIRE(bids[x].direct_size() == 2); REQUIRE(bids[x].implied_size() == 0); REQUIRE(asks[x].direct_size() == 2); REQUIRE(asks[x].implied_size() == 0); } } } }); } SECTION("partial_Read") { direct_bid[0] = {{700, 1}, 1}; direct_bid[1] = {{600, 1}, 1}; direct_bid[2] = {{500, 1}, 1}; direct_bid[3] = {{400, 1}, 1}; direct_ask[0] = {{800, 1}, 1}; direct_ask[1] = {{900, 1}, 1}; direct_ask[2] = {{1000, 1}, 1}; direct_ask[3] = {{1100, 1}, 1}; implied_bid[0] = {{700, 1}, 2}; implied_bid[1] = {{600, 1}, 2}; implied_ask[0] = {{800, 1}, 2}; implied_ask[1] = {{900, 1}, 2}; ImpliedTests::test_merge( direct_bid, implied_bid, direct_ask, implied_ask, [](const vector &consumers) { const size_t TEST_DEPTH = 4; for (const auto &c : consumers) { std::array bids, asks; int canary = 0; TimeStamp read_time; // get_boo returns true becuase this time is after the change REQUIRE( c.get_direct_book( read_time, TEST_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); for (size_t x = 0; x < TEST_DEPTH; ++x) { REQUIRE(bids[x].size() == 1); REQUIRE(asks[x].size() == 1); REQUIRE(bids[x].direct_size() == 1); REQUIRE(bids[x].implied_size() == 0); REQUIRE(asks[x].direct_size() == 1); REQUIRE(asks[x].implied_size() == 0); } read_time = TimeStamp(); REQUIRE( c.get_implied_book( read_time, COCONUT_MAX_IMPLIED_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); for (size_t x = 0; x < COCONUT_MAX_IMPLIED_DEPTH; ++x) { REQUIRE(bids[x].size() == 2); REQUIRE(asks[x].size() == 2); REQUIRE(bids[x].direct_size() == 0); REQUIRE(bids[x].implied_size() == 2); REQUIRE(asks[x].direct_size() == 0); REQUIRE(asks[x].implied_size() == 2); } read_time = TimeStamp(); REQUIRE( c.get_book(read_time, TEST_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); for (size_t x = 0; x < TEST_DEPTH; ++x) { if (x < COCONUT_MAX_IMPLIED_DEPTH) { REQUIRE(bids[x].size() == 3); REQUIRE(asks[x].size() == 3); REQUIRE(bids[x].direct_size() == 1); REQUIRE(bids[x].implied_size() == 2); REQUIRE(asks[x].direct_size() == 1); REQUIRE(asks[x].implied_size() == 2); } else { REQUIRE(bids[x].size() == 1); REQUIRE(asks[x].size() == 1); REQUIRE(bids[x].direct_size() == 1); REQUIRE(bids[x].implied_size() == 0); REQUIRE(asks[x].direct_size() == 1); REQUIRE(asks[x].implied_size() == 0); } } REQUIRE(canary == 0); } }); } SECTION("better_implied") { direct_bid[0] = {{500, 1}, 1}; direct_bid[1] = {{400, 1}, 1}; direct_bid[2] = {{300, 1}, 1}; direct_bid[3] = {{200, 1}, 1}; direct_ask[0] = {{1000, 1}, 1}; direct_ask[1] = {{1100, 1}, 1}; direct_ask[2] = {{1200, 1}, 1}; direct_ask[3] = {{1300, 1}, 1}; implied_bid[0] = {{600, 1}, 2}; implied_bid[1] = {{500, 1}, 2}; implied_ask[0] = {{900, 1}, 2}; implied_ask[1] = {{1000, 1}, 2}; ImpliedTests::test_merge( direct_bid, implied_bid, direct_ask, implied_ask, [=](const vector &consumers) { const size_t TEST_DEPTH = 4; for (const auto &c : consumers) { std::array bids, asks; int canary = 0; TimeStamp read_time; // get_boo returns true becuase this time is after the change REQUIRE( c.get_direct_book( read_time, TEST_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); for (size_t x = 0; x < TEST_DEPTH; ++x) { REQUIRE(bids[x].size() == 1); REQUIRE(asks[x].size() == 1); REQUIRE(bids[x].direct_size() == 1); REQUIRE(bids[x].implied_size() == 0); REQUIRE(asks[x].direct_size() == 1); REQUIRE(asks[x].implied_size() == 0); } read_time = TimeStamp(); REQUIRE( c.get_implied_book( read_time, COCONUT_MAX_IMPLIED_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); for (size_t x = 0; x < COCONUT_MAX_IMPLIED_DEPTH; ++x) { REQUIRE(bids[x].size() == 2); REQUIRE(asks[x].size() == 2); REQUIRE(bids[x].direct_size() == 0); REQUIRE(bids[x].implied_size() == 2); REQUIRE(asks[x].direct_size() == 0); REQUIRE(asks[x].implied_size() == 2); } read_time = TimeStamp(); REQUIRE( c.get_book(read_time, TEST_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); REQUIRE(bids[0].size() == 2); REQUIRE(bids[0].mantissa() == 600); REQUIRE(asks[0].size() == 2); REQUIRE(asks[0].mantissa() == 900); REQUIRE(bids[1].size() == 3); REQUIRE(asks[1].size() == 3); REQUIRE(bids[1].direct_size() == 1); REQUIRE(bids[1].implied_size() == 2); REQUIRE(asks[1].direct_size() == 1); REQUIRE(asks[1].implied_size() == 2); for (size_t x = 2; x < TEST_DEPTH; ++x) { REQUIRE(bids[x].size() == 1); REQUIRE(asks[x].size() == 1); REQUIRE(bids[x].direct_size() == 1); REQUIRE(bids[x].implied_size() == 0); REQUIRE(asks[x].direct_size() == 1); REQUIRE(asks[x].implied_size() == 0); } REQUIRE(canary == 0); } }); } SECTION("worse_implied") { direct_bid[0] = {{500, 1}, 1}; direct_bid[1] = {{400, 1}, 1}; direct_bid[2] = {{300, 1}, 1}; direct_bid[3] = {{200, 1}, 1}; direct_ask[0] = {{1000, 1}, 1}; direct_ask[1] = {{1100, 1}, 1}; direct_ask[2] = {{1200, 1}, 1}; direct_ask[3] = {{1300, 1}, 1}; implied_bid[0] = {{400, 1}, 2}; implied_bid[1] = {{300, 1}, 2}; implied_ask[0] = {{1100, 1}, 2}; implied_ask[1] = {{1200, 1}, 2}; ImpliedTests::test_merge( direct_bid, implied_bid, direct_ask, implied_ask, [=](const vector &consumers) { const size_t TEST_DEPTH = 4; for (const auto &c : consumers) { std::array bids, asks; int canary = 0; TimeStamp read_time; // get_boo returns true becuase this time is after the change REQUIRE( c.get_direct_book( read_time, TEST_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); for (size_t x = 0; x < TEST_DEPTH; ++x) { REQUIRE(bids[x].size() == 1); REQUIRE(asks[x].size() == 1); REQUIRE(bids[x].direct_size() == 1); REQUIRE(bids[x].implied_size() == 0); REQUIRE(asks[x].direct_size() == 1); REQUIRE(asks[x].implied_size() == 0); } read_time = TimeStamp(); REQUIRE( c.get_implied_book( read_time, COCONUT_MAX_IMPLIED_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); for (size_t x = 0; x < COCONUT_MAX_IMPLIED_DEPTH; ++x) { REQUIRE(bids[x].size() == 2); REQUIRE(asks[x].size() == 2); REQUIRE(bids[x].direct_size() == 0); REQUIRE(bids[x].implied_size() == 2); REQUIRE(asks[x].direct_size() == 0); REQUIRE(asks[x].implied_size() == 2); } read_time = TimeStamp(); REQUIRE( c.get_book(read_time, TEST_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); REQUIRE(bids[0].mantissa() == 500); REQUIRE(bids[0].size() == 1); REQUIRE(asks[0].mantissa() == 1000); REQUIRE(asks[0].size() == 1); REQUIRE(bids[0].direct_size() == 1); REQUIRE(bids[0].implied_size() == 0); REQUIRE(asks[0].direct_size() == 1); REQUIRE(asks[0].implied_size() == 0); REQUIRE(bids[1].mantissa() == 400); REQUIRE(bids[1].size() == 3); REQUIRE(asks[1].mantissa() == 1100); REQUIRE(asks[1].size() == 3); REQUIRE(bids[1].direct_size() == 1); REQUIRE(bids[1].implied_size() == 2); REQUIRE(asks[1].direct_size() == 1); REQUIRE(asks[1].implied_size() == 2); REQUIRE(bids[2].mantissa() == 300); REQUIRE(bids[2].size() == 3); REQUIRE(asks[2].mantissa() == 1200); REQUIRE(asks[2].size() == 3); REQUIRE(bids[2].direct_size() == 1); REQUIRE(bids[2].implied_size() == 2); REQUIRE(asks[2].direct_size() == 1); REQUIRE(asks[2].implied_size() == 2); REQUIRE(bids[3].mantissa() == 200); REQUIRE(bids[3].size() == 1); REQUIRE(asks[3].mantissa() == 1300); REQUIRE(asks[3].size() == 1); REQUIRE(bids[3].direct_size() == 1); REQUIRE(bids[3].implied_size() == 0); REQUIRE(asks[3].direct_size() == 1); REQUIRE(asks[3].implied_size() == 0); REQUIRE(canary == 0); } }); } SECTION("worse_implied_bid") { direct_bid[0] = {{500, 1}, 1}; direct_bid[1] = {{400, 1}, 1}; direct_bid[2] = {{300, 1}, 1}; direct_bid[3] = {{200, 1}, 1}; direct_ask[0] = {{1000, 1}, 1}; direct_ask[1] = {{1100, 1}, 1}; direct_ask[2] = {{1200, 1}, 1}; direct_ask[3] = {{1300, 1}, 1}; implied_bid[0] = {{400, 1}, 2}; implied_bid[1] = {{300, 1}, 2}; implied_ask[0] = {{1000, 1}, 2}; implied_ask[1] = {{1100, 1}, 2}; ImpliedTests::test_merge( direct_bid, implied_bid, direct_ask, implied_ask, [=](const vector &consumers) { const size_t TEST_DEPTH = 4; for (const auto &c : consumers) { std::array bids, asks; int canary = 0; TimeStamp read_time; // get_boo returns true becuase this time is after the change REQUIRE( c.get_direct_book( read_time, TEST_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); for (size_t x = 0; x < TEST_DEPTH; ++x) { REQUIRE(bids[x].size() == 1); REQUIRE(asks[x].size() == 1); REQUIRE(bids[x].direct_size() == 1); REQUIRE(bids[x].implied_size() == 0); REQUIRE(asks[x].direct_size() == 1); REQUIRE(asks[x].implied_size() == 0); } read_time = TimeStamp(); REQUIRE( c.get_implied_book( read_time, COCONUT_MAX_IMPLIED_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); for (size_t x = 0; x < COCONUT_MAX_IMPLIED_DEPTH; ++x) { REQUIRE(bids[x].size() == 2); REQUIRE(asks[x].size() == 2); REQUIRE(bids[x].direct_size() == 0); REQUIRE(bids[x].implied_size() == 2); REQUIRE(asks[x].direct_size() == 0); REQUIRE(asks[x].implied_size() == 2); } read_time = TimeStamp(); REQUIRE( c.get_book(read_time, TEST_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); REQUIRE(bids[0].mantissa() == 500); REQUIRE(bids[0].size() == 1); REQUIRE(asks[0].mantissa() == 1000); REQUIRE(asks[0].size() == 3); REQUIRE(bids[0].direct_size() == 1); REQUIRE(bids[0].implied_size() == 0); REQUIRE(asks[0].direct_size() == 1); REQUIRE(asks[0].implied_size() == 2); REQUIRE(bids[1].mantissa() == 400); REQUIRE(bids[1].size() == 3); REQUIRE(asks[1].mantissa() == 1100); REQUIRE(asks[1].size() == 3); REQUIRE(bids[1].direct_size() == 1); REQUIRE(bids[1].implied_size() == 2); REQUIRE(asks[1].direct_size() == 1); REQUIRE(asks[1].implied_size() == 2); REQUIRE(bids[2].mantissa() == 300); REQUIRE(bids[2].size() == 3); REQUIRE(asks[2].mantissa() == 1200); REQUIRE(asks[2].size() == 1); REQUIRE(bids[2].direct_size() == 1); REQUIRE(bids[2].implied_size() == 2); REQUIRE(asks[2].direct_size() == 1); REQUIRE(asks[2].implied_size() == 0); REQUIRE(bids[3].mantissa() == 200); REQUIRE(bids[3].size() == 1); REQUIRE(asks[3].mantissa() == 1300); REQUIRE(asks[3].size() == 1); REQUIRE(bids[3].direct_size() == 1); REQUIRE(bids[3].implied_size() == 0); REQUIRE(asks[3].direct_size() == 1); REQUIRE(asks[3].implied_size() == 0); REQUIRE(canary == 0); } }); } SECTION("worse_implied_ask") { direct_bid[0] = {{500, 1}, 1}; direct_bid[1] = {{400, 1}, 1}; direct_bid[2] = {{300, 1}, 1}; direct_bid[3] = {{200, 1}, 1}; direct_ask[0] = {{1000, 1}, 1}; direct_ask[1] = {{1100, 1}, 1}; direct_ask[2] = {{1200, 1}, 1}; direct_ask[3] = {{1300, 1}, 1}; implied_bid[0] = {{500, 1}, 2}; implied_bid[1] = {{400, 1}, 2}; implied_ask[0] = {{1300, 1}, 2}; implied_ask[1] = {{1400, 1}, 2}; ImpliedTests::test_merge( direct_bid, implied_bid, direct_ask, implied_ask, [=](const vector &consumers) { const size_t TEST_DEPTH = 4; for (const auto &c : consumers) { std::array bids, asks; int canary = 0; TimeStamp read_time; // get_boo returns true becuase this time is after the change REQUIRE( c.get_direct_book( read_time, TEST_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); for (size_t x = 0; x < TEST_DEPTH; ++x) { REQUIRE(bids[x].size() == 1); REQUIRE(asks[x].size() == 1); REQUIRE(bids[x].direct_size() == 1); REQUIRE(bids[x].implied_size() == 0); REQUIRE(asks[x].direct_size() == 1); REQUIRE(asks[x].implied_size() == 0); } read_time = TimeStamp(); REQUIRE( c.get_implied_book( read_time, COCONUT_MAX_IMPLIED_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); for (size_t x = 0; x < COCONUT_MAX_IMPLIED_DEPTH; ++x) { REQUIRE(bids[x].size() == 2); REQUIRE(asks[x].size() == 2); REQUIRE(bids[x].direct_size() == 0); REQUIRE(bids[x].implied_size() == 2); REQUIRE(asks[x].direct_size() == 0); REQUIRE(asks[x].implied_size() == 2); } read_time = TimeStamp(); REQUIRE( c.get_book(read_time, TEST_DEPTH + 1, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); REQUIRE(bids[0].mantissa() == 500); REQUIRE(bids[0].size() == 3); REQUIRE(asks[0].mantissa() == 1000); REQUIRE(asks[0].size() == 1); REQUIRE(bids[0].direct_size() == 1); REQUIRE(bids[0].implied_size() == 2); REQUIRE(asks[0].direct_size() == 1); REQUIRE(asks[0].implied_size() == 0); REQUIRE(bids[1].mantissa() == 400); REQUIRE(bids[1].size() == 3); REQUIRE(asks[1].mantissa() == 1100); REQUIRE(asks[1].size() == 1); REQUIRE(bids[1].direct_size() == 1); REQUIRE(bids[1].implied_size() == 2); REQUIRE(asks[1].direct_size() == 1); REQUIRE(asks[1].implied_size() == 0); REQUIRE(bids[2].mantissa() == 300); REQUIRE(bids[2].size() == 1); REQUIRE(asks[2].mantissa() == 1200); REQUIRE(asks[2].size() == 1); REQUIRE(bids[2].direct_size() == 1); REQUIRE(bids[2].implied_size() == 0); REQUIRE(asks[2].direct_size() == 1); REQUIRE(asks[2].implied_size() == 0); REQUIRE(bids[3].mantissa() == 200); REQUIRE(bids[3].size() == 1); REQUIRE(asks[3].mantissa() == 1300); REQUIRE(asks[3].size() == 3); REQUIRE(bids[3].direct_size() == 1); REQUIRE(bids[3].implied_size() == 0); REQUIRE(asks[3].direct_size() == 1); REQUIRE(asks[3].implied_size() == 2); REQUIRE(bids[4].mantissa() == 0); REQUIRE(bids[4].size() == 0); REQUIRE(asks[4].mantissa() == 1400); REQUIRE(asks[4].size() == 2); REQUIRE(bids[4].direct_size() == 0); REQUIRE(bids[4].implied_size() == 0); REQUIRE(asks[4].direct_size() == 0); REQUIRE(asks[4].implied_size() == 2); REQUIRE(canary == 0); } }); } SECTION("nan_implied") { direct_bid[0] = {{500, 1}, 1}; direct_bid[1] = {{400, 1}, 1}; direct_bid[2] = {{300, 1}, 1}; direct_bid[3] = {{200, 1}, 1}; direct_ask[0] = {{1000, 1}, 1}; direct_ask[1] = {{1100, 1}, 1}; direct_ask[2] = {{1200, 1}, 1}; direct_ask[3] = {{1300, 1}, 1}; implied_bid[0] = {INT_NAN, 0}; implied_bid[1] = {INT_NAN, 0}; implied_ask[0] = {INT_NAN, 0}; implied_ask[1] = {INT_NAN, 0}; ImpliedTests::test_merge( direct_bid, implied_bid, direct_ask, implied_ask, [=](const vector &consumers) { const size_t TEST_DEPTH = 4; for (const auto &c : consumers) { std::array bids, asks; int canary = 0; TimeStamp read_time; // get_boo returns true becuase this time is after the change REQUIRE( c.get_direct_book( read_time, TEST_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); for (size_t x = 0; x < TEST_DEPTH; ++x) { REQUIRE(bids[x].size() == 1); REQUIRE(asks[x].size() == 1); REQUIRE(bids[x].direct_size() == 1); REQUIRE(bids[x].implied_size() == 0); REQUIRE(asks[x].direct_size() == 1); REQUIRE(asks[x].implied_size() == 0); } read_time = TimeStamp(); REQUIRE( c.get_implied_book( read_time, COCONUT_MAX_IMPLIED_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); for (size_t x = 0; x < COCONUT_MAX_IMPLIED_DEPTH; ++x) { REQUIRE(bids[x].size() == 0); REQUIRE(asks[x].size() == 0); REQUIRE(bids[x].direct_size() == 0); REQUIRE(bids[x].implied_size() == 0); REQUIRE(asks[x].direct_size() == 0); REQUIRE(asks[x].implied_size() == 0); } read_time = TimeStamp(); REQUIRE( c.get_book(read_time, TEST_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); REQUIRE(bids[0].mantissa() == 500); REQUIRE(bids[0].size() == 1); REQUIRE(asks[0].mantissa() == 1000); REQUIRE(asks[0].size() == 1); REQUIRE(bids[0].direct_size() == 1); REQUIRE(bids[0].implied_size() == 0); REQUIRE(asks[0].direct_size() == 1); REQUIRE(asks[0].implied_size() == 0); REQUIRE(bids[1].mantissa() == 400); REQUIRE(bids[1].size() == 1); REQUIRE(asks[1].mantissa() == 1100); REQUIRE(asks[1].size() == 1); REQUIRE(bids[1].direct_size() == 1); REQUIRE(bids[1].implied_size() == 0); REQUIRE(asks[1].direct_size() == 1); REQUIRE(asks[1].implied_size() == 0); REQUIRE(bids[2].mantissa() == 300); REQUIRE(bids[2].size() == 1); REQUIRE(asks[2].mantissa() == 1200); REQUIRE(asks[2].size() == 1); REQUIRE(bids[2].direct_size() == 1); REQUIRE(bids[2].implied_size() == 0); REQUIRE(asks[2].direct_size() == 1); REQUIRE(asks[2].implied_size() == 0); REQUIRE(bids[3].mantissa() == 200); REQUIRE(bids[3].size() == 1); REQUIRE(asks[3].mantissa() == 1300); REQUIRE(asks[3].size() == 1); REQUIRE(bids[3].direct_size() == 1); REQUIRE(bids[3].implied_size() == 0); REQUIRE(asks[3].direct_size() == 1); REQUIRE(asks[3].implied_size() == 0); REQUIRE(canary == 0); } }); } SECTION("nan_direct") { direct_bid[0] = {INT_NAN, 0}; direct_bid[1] = {INT_NAN, 0}; direct_bid[2] = {INT_NAN, 0}; direct_bid[3] = {INT_NAN, 0}; direct_ask[0] = {INT_NAN, 0}; direct_ask[1] = {INT_NAN, 0}; direct_ask[2] = {INT_NAN, 0}; direct_ask[3] = {INT_NAN, 0}; implied_bid[0] = {{500, 1}, 2}; implied_bid[1] = {{400, 1}, 2}; implied_ask[0] = {{1000, 1}, 2}; implied_ask[1] = {{1100, 1}, 2}; ImpliedTests::test_merge( direct_bid, implied_bid, direct_ask, implied_ask, [=](const vector &consumers) { const size_t TEST_DEPTH = 4; for (const auto &c : consumers) { std::array bids, asks; int canary = 0; TimeStamp read_time; // get_boo returns true becuase this time is after the change REQUIRE( c.get_direct_book( read_time, TEST_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); for (size_t x = 0; x < TEST_DEPTH; ++x) { REQUIRE(bids[x].size() == 0); REQUIRE(asks[x].size() == 0); REQUIRE(bids[x].direct_size() == 0); REQUIRE(bids[x].implied_size() == 0); REQUIRE(asks[x].direct_size() == 0); REQUIRE(asks[x].implied_size() == 0); } read_time = TimeStamp(); REQUIRE( c.get_implied_book( read_time, COCONUT_MAX_IMPLIED_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); for (size_t x = 0; x < COCONUT_MAX_IMPLIED_DEPTH; ++x) { REQUIRE(bids[x].size() == 2); REQUIRE(asks[x].size() == 2); REQUIRE(bids[x].direct_size() == 0); REQUIRE(bids[x].implied_size() == 2); REQUIRE(asks[x].direct_size() == 0); REQUIRE(asks[x].implied_size() == 2); } read_time = TimeStamp(); REQUIRE( c.get_book(read_time, TEST_DEPTH, &bids[0], &asks[0]) == HandleReadResult::SUCCESS); REQUIRE(bids[0].mantissa() == 500); REQUIRE(bids[0].size() == 2); REQUIRE(asks[0].mantissa() == 1000); REQUIRE(asks[0].size() == 2); REQUIRE(bids[0].direct_size() == 0); REQUIRE(bids[0].implied_size() == 2); REQUIRE(asks[0].direct_size() == 0); REQUIRE(asks[0].implied_size() == 2); REQUIRE(bids[1].mantissa() == 400); REQUIRE(bids[1].size() == 2); REQUIRE(asks[1].mantissa() == 1100); REQUIRE(asks[1].size() == 2); REQUIRE(bids[1].direct_size() == 0); REQUIRE(bids[1].implied_size() == 2); REQUIRE(asks[1].direct_size() == 0); REQUIRE(asks[1].implied_size() == 2); REQUIRE(bids[2].size() == 0); REQUIRE(asks[2].size() == 0); REQUIRE(bids[2].direct_size() == 0); REQUIRE(bids[2].implied_size() == 0); REQUIRE(asks[2].direct_size() == 0); REQUIRE(asks[2].implied_size() == 0); REQUIRE(bids[3].size() == 0); REQUIRE(asks[3].size() == 0); REQUIRE(bids[3].direct_size() == 0); REQUIRE(bids[3].implied_size() == 0); REQUIRE(asks[3].direct_size() == 0); REQUIRE(asks[3].implied_size() == 0); REQUIRE(canary == 0); } }); } } TEST_CASE("IntPrice", "[md]") { SECTION("sign extend") { auto a = IntPrice_from_double<4>(101.111); REQUIRE(std::to_string(a.price()) == "101.111000"); REQUIRE(a.mantissa() == 1011110); a = a.sign_extend(-5); REQUIRE(std::to_string(a.price()) == "101.111000"); REQUIRE(a.mantissa() == 10111100); a = a.sign_extend(-9); REQUIRE(std::to_string(a.price()) == "101.111000"); REQUIRE(a.mantissa() == 101111000000); } SECTION("< equal exponent") { auto a = IntPrice_from_double<4>(101.111); auto b = IntPrice_from_double<4>(100.111); REQUIRE((int)a.exponent() == (int)b.exponent()); REQUIRE(b < a); REQUIRE(!(a < b)); } SECTION("< different exponent") { auto a = IntPrice_from_double<4>(101.111); // -4 auto b = IntPrice_from_double<0>(100); // 0 REQUIRE((int)a.exponent() < (int)b.exponent()); REQUIRE(b < a); REQUIRE(!(a < b)); auto c = std::max(a, b); REQUIRE(c == a); } // subtract with equal exponent SECTION("subtract equal exponent") { IntPrice a = IntPrice_from_double<4>(100.333); IntPrice b = IntPrice_from_double<4>(100.222); IntPrice delta = a - b; REQUIRE(delta == IntPrice_from_double<4>(0.111)); } // subtract smaller from greater SECTION("subtract smaller from greater") { IntPrice a = IntPrice_from_double<4>(100.333); IntPrice b = IntPrice_from_double<5>(100.222); IntPrice delta = a - b; REQUIRE(delta == IntPrice_from_double<5>(0.111)); } // subtract greater from smaller SECTION("subtract greater from smaller") { IntPrice a = IntPrice_from_double<4>(100.333); IntPrice b = IntPrice_from_double<3>(100.111); IntPrice delta = a - b; REQUIRE(delta == IntPrice_from_double<4>(0.222)); } SECTION("subtract NAN from something") { IntPrice a = IntPrice_from_double<4>(100.333); IntPrice delta = a - INT_NAN; REQUIRE(delta == INT_NAN); } SECTION("subtract something from NAN") { IntPrice a = IntPrice_from_double<4>(100.333); IntPrice delta = INT_NAN - a; REQUIRE(delta == INT_NAN); } SECTION("round equal exponents") { auto price = IntPrice_from_double<4>(100.333); auto tick = IntPrice_from_double<4>(0.25); // buy - round down auto buy = round_to_quote_price(tick, price, api::SIDE_BUY); REQUIRE(buy == IntPrice_from_double<4>(100.25)); // sell - round up auto sell = round_to_quote_price(tick, price, api::SIDE_SELL); REQUIRE(sell == IntPrice_from_double<4>(100.50)); } SECTION("round smaller tick exponent") { auto price = IntPrice_from_double<4>(100.333); auto tick = IntPrice_from_double<3>(0.25); // buy - round down auto buy = round_to_quote_price(tick, price, api::SIDE_BUY); REQUIRE(buy == IntPrice_from_double<4>(100.25)); // sell - round up auto sell = round_to_quote_price(tick, price, api::SIDE_SELL); REQUIRE(sell == IntPrice_from_double<4>(100.50)); } SECTION("round smaller price exponent") { auto price = IntPrice_from_double<4>(100.333); auto tick = IntPrice_from_double<7>(0.25); // buy - round down auto buy = round_to_quote_price(tick, price, api::SIDE_BUY); REQUIRE(buy == IntPrice_from_double<7>(100.25)); // sell - round up auto sell = round_to_quote_price(tick, price, api::SIDE_SELL); REQUIRE(sell == IntPrice_from_double<4>(100.50)); } SECTION("round 0.005") { IntPrice price = {-43595000, -7}; IntPrice tick = {50000, -7}; auto buy = round_to_quote_price(tick, price, api::SIDE_BUY); REQUIRE(buy == IntPrice_from_double<7>(-4.360)); } SECTION("division by double") { IntPrice price = {-43595000, -7}; IntPrice price_div10 = {-43595000, -8}; REQUIRE(price / 10.0 == price_div10); } } } // namespace test } // namespace md } // namespace bts #endif