tests.cpp

#include <iostream>
#include <cassert>
#include <chrono>
#include <random>
#include <iomanip>
#include "OrderBook.h"
#include "Order.h"
#include "Types.h"
#include "OrderType.h"

// Test helper macros
#define TEST(name) void name()
#define RUN_TEST(name) do { \
    std::cout << "Running " << #name << "... "; \
    name(); \
    std::cout << "PASSED\n"; \
} while(0)

#define ASSERT_EQ(a, b) assert((a) == (b))
#define ASSERT_TRUE(x) assert(x)
#define ASSERT_FALSE(x) assert(!(x))

// Helper function to format large numbers with commas
std::string formatNumber(long long num) {
    std::string str = std::to_string(num);
    int insertPosition = str.length() - 3;
    while (insertPosition > 0) {
        str.insert(insertPosition, ",");
        insertPosition -= 3;
    }
    return str;
}

// ==================== FUNCTIONALITY TESTS ====================

TEST(TestBasicAddOrder) {
    Orderbook orderbook;
    auto order = std::make_shared<Order>(OrderType::GoodTillCancel, 1, Side::Buy, 100, 10);
    orderbook.AddOrder(order);
    ASSERT_EQ(orderbook.Size(), 1);
}

TEST(TestCancelOrder) {
    Orderbook orderbook;
    OrderId orderId = 1;
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, orderId, Side::Buy, 100, 10));
    ASSERT_EQ(orderbook.Size(), 1);
    orderbook.CancelOrder(orderId);
    ASSERT_EQ(orderbook.Size(), 0);
}

TEST(TestDuplicateOrderRejection) {
    Orderbook orderbook;
    OrderId orderId = 1;
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, orderId, Side::Buy, 100, 10));
    auto trades = orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, orderId, Side::Buy, 100, 10));
    ASSERT_EQ(orderbook.Size(), 1);
    ASSERT_TRUE(trades.empty());
}

TEST(TestSimpleMatch) {
    Orderbook orderbook;
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 1, Side::Buy, 100, 10));
    auto trades = orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 2, Side::Sell, 100, 10));

    ASSERT_EQ(trades.size(), 1);
    ASSERT_EQ(orderbook.Size(), 0);
    ASSERT_EQ(trades[0].GetBidTrade().quantity_, 10);
    ASSERT_EQ(trades[0].GetAskTrade().quantity_, 10);
}

TEST(TestPartialMatch) {
    Orderbook orderbook;
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 1, Side::Buy, 100, 15));
    auto trades = orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 2, Side::Sell, 100, 10));

    ASSERT_EQ(trades.size(), 1);
    ASSERT_EQ(orderbook.Size(), 1);
    ASSERT_EQ(trades[0].GetBidTrade().quantity_, 10);
}

TEST(TestMultipleMatchesAtSamePrice) {
    Orderbook orderbook;
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 1, Side::Buy, 100, 5));
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 2, Side::Buy, 100, 5));
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 3, Side::Buy, 100, 5));

    auto trades = orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 4, Side::Sell, 100, 12));

    ASSERT_EQ(trades.size(), 3);
    ASSERT_EQ(orderbook.Size(), 1);
}

TEST(TestPricePriority) {
    Orderbook orderbook;
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 1, Side::Buy, 100, 10));
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 2, Side::Buy, 105, 10));

    auto trades = orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 3, Side::Sell, 100, 10));

    ASSERT_EQ(trades.size(), 1);
    ASSERT_EQ(trades[0].GetBidTrade().orderId_, 2);
    ASSERT_EQ(trades[0].GetBidTrade().price_, 100);           // executed at ask price (price-time priority)
}

TEST(TestTimePriority_FIFO) {
    Orderbook orderbook;
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 1, Side::Buy, 100, 10));
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 2, Side::Buy, 100, 10));

    auto trades = orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 3, Side::Sell, 100, 10));

    ASSERT_EQ(trades.size(), 1);
    ASSERT_EQ(trades[0].GetBidTrade().orderId_, 1);
}

TEST(TestMarketOrderBuy) {
    Orderbook orderbook;
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 1, Side::Sell, 100, 10));

    auto marketOrder = std::make_shared<Order>(2, Side::Buy, 10);
    auto trades = orderbook.AddOrder(marketOrder);

    ASSERT_EQ(trades.size(), 1);
    ASSERT_EQ(orderbook.Size(), 0);
}

TEST(TestMarketOrderSell) {
    Orderbook orderbook;
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 1, Side::Buy, 100, 10));

    auto marketOrder = std::make_shared<Order>(2, Side::Sell, 10);
    auto trades = orderbook.AddOrder(marketOrder);

    ASSERT_EQ(trades.size(), 1);
    ASSERT_EQ(orderbook.Size(), 0);
}

TEST(TestMarketOrderEmptyBook) {
    Orderbook orderbook;
    auto marketOrder = std::make_shared<Order>(1, Side::Buy, 10);
    auto trades = orderbook.AddOrder(marketOrder);

    ASSERT_TRUE(trades.empty());
    ASSERT_EQ(orderbook.Size(), 0);
}

TEST(TestImmediateOrCancel_PartialFill) {
    Orderbook orderbook;
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 1, Side::Sell, 100, 5));

    auto fakOrder = std::make_shared<Order>(OrderType::ImmediateOrCancel, 2, Side::Buy, 100, 10);
    auto trades = orderbook.AddOrder(fakOrder);

    ASSERT_EQ(trades.size(), 1);
    ASSERT_EQ(trades[0].GetBidTrade().quantity_, 5);
    ASSERT_EQ(orderbook.Size(), 0);
}

TEST(TestImmediateOrCancel_NoMatch) {
    Orderbook orderbook;
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 1, Side::Sell, 105, 10));

    auto fakOrder = std::make_shared<Order>(OrderType::ImmediateOrCancel, 2, Side::Buy, 100, 10);
    auto trades = orderbook.AddOrder(fakOrder);

    ASSERT_TRUE(trades.empty());
    ASSERT_EQ(orderbook.Size(), 1);
}

TEST(TestFillOrKill_FullFill) {
    Orderbook orderbook;
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 1, Side::Sell, 100, 10));

    auto fokOrder = std::make_shared<Order>(OrderType::FillOrKill, 2, Side::Buy, 100, 10);
    auto trades = orderbook.AddOrder(fokOrder);

    ASSERT_EQ(trades.size(), 1);
    ASSERT_EQ(trades[0].GetBidTrade().quantity_, 10);
    ASSERT_EQ(orderbook.Size(), 0);
}

TEST(TestFillOrKill_PartialAvailable) {
    Orderbook orderbook;
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 1, Side::Sell, 100, 5));

    auto fokOrder = std::make_shared<Order>(OrderType::FillOrKill, 2, Side::Buy, 100, 10);
    auto trades = orderbook.AddOrder(fokOrder);

    ASSERT_TRUE(trades.empty());
    ASSERT_EQ(orderbook.Size(), 1);
}

TEST(TestFillOrKill_MultipleOrders) {
    Orderbook orderbook;
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 1, Side::Sell, 100, 5));
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 2, Side::Sell, 100, 5));

    auto fokOrder = std::make_shared<Order>(OrderType::FillOrKill, 3, Side::Buy, 100, 10);
    auto trades = orderbook.AddOrder(fokOrder);

    ASSERT_EQ(trades.size(), 2);
    ASSERT_EQ(orderbook.Size(), 0);
}

TEST(TestOrderModify) {
    Orderbook orderbook;
    OrderId orderId = 1;
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, orderId, Side::Buy, 100, 10));

    OrderModify modify(orderId, Side::Buy, 105, 15);
    orderbook.MatchOrder(modify);

    ASSERT_EQ(orderbook.Size(), 1);
    auto infos = orderbook.GetOrderInfos();
    ASSERT_EQ(infos.GetBids()[0].price_, 105);
    ASSERT_EQ(infos.GetBids()[0].quantity_, 15);
}

TEST(TestOrderbookLevelInfos) {
    Orderbook orderbook;
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 1, Side::Buy, 100, 10));
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 2, Side::Buy, 100, 5));
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 3, Side::Sell, 105, 20));

    auto infos = orderbook.GetOrderInfos();
    ASSERT_EQ(infos.GetBids().size(), 1);
    ASSERT_EQ(infos.GetBids()[0].quantity_, 15);
    ASSERT_EQ(infos.GetAsks().size(), 1);
    ASSERT_EQ(infos.GetAsks()[0].quantity_, 20);
}

TEST(TestExchangeRulesBasic) {
    Orderbook orderbook;
    ExchangeRules rules;
    rules.tickSize = 5; // Prices in multiples of 5 cents
    rules.lotSize = 10; // Quantities in multiples of 10
    rules.minQuantity = 10; // Minimum 10 shares
    orderbook.SetExchangeRules(rules);

    // Valid order
    auto validOrder = std::make_shared<Order>(OrderType::GoodTillCancel, 1, Side::Buy, 100, 20);
    orderbook.AddOrder(validOrder);
    ASSERT_EQ(orderbook.Size(), 1);

    // Invalid tick size
    auto invalidTick = std::make_shared<Order>(OrderType::GoodTillCancel, 2, Side::Buy, 103, 20);
    orderbook.AddOrder(invalidTick);
    ASSERT_EQ(orderbook.Size(), 1); // Rejected

    // Invalid lot size
    auto invalidLot = std::make_shared<Order>(OrderType::GoodTillCancel, 3, Side::Buy, 100, 15);
    orderbook.AddOrder(invalidLot);
    ASSERT_EQ(orderbook.Size(), 1); // Rejected

    // Below minimum quantity
    auto belowMin = std::make_shared<Order>(OrderType::GoodTillCancel, 4, Side::Buy, 100, 5);
    orderbook.AddOrder(belowMin);
    ASSERT_EQ(orderbook.Size(), 1); // Rejected
}

TEST(TestMinNotionalValidation) {
    Orderbook orderbook;
    ExchangeRules rules;
    rules.minNotional = 1000; // Minimum order value is 1000 cents ($10)
    orderbook.SetExchangeRules(rules);

    // Valid: 150 * 10 = 1500 >= 1000
    auto validOrder = std::make_shared<Order>(OrderType::GoodTillCancel, 1, Side::Buy, 150, 10);
    orderbook.AddOrder(validOrder);
    ASSERT_EQ(orderbook.Size(), 1);

    // Invalid: 50 * 10 = 500 < 1000
    auto invalidOrder = std::make_shared<Order>(OrderType::GoodTillCancel, 2, Side::Buy, 50, 10);
    orderbook.AddOrder(invalidOrder);
    ASSERT_EQ(orderbook.Size(), 1); // Rejected
}

TEST(TestMarketOrderValidation) {
    Orderbook orderbook;
    ExchangeRules rules;
    rules.lotSize = 10;
    orderbook.SetExchangeRules(rules);
    // Add liquidity
    orderbook.AddOrder(std::make_shared<Order>(OrderType::GoodTillCancel, 1, Side::Sell, 100, 50));

    // Valid market order (quantity is multiple of 10)
    auto validMarket = std::make_shared<Order>(2, Side::Buy, 20);
    auto trades = orderbook.AddOrder(validMarket);
    ASSERT_EQ(trades.size(), 1);

    // Invalid market order (quantity not multiple of 10)
    auto invalidMarket = std::make_shared<Order>(3, Side::Buy, 15);
    auto noTrades = orderbook.AddOrder(invalidMarket);
    ASSERT_TRUE(noTrades.empty()); // Rejected
}

// ==================== PERFORMANCE TESTS ====================

void PrintPerformanceHeader() {
    std::cout << "\n" << std::string(70, '=') << "\n";
    std::cout << std::setw(45) << "PERFORMANCE BENCHMARKS\n";
    std::cout << std::string(70, '=') << "\n\n";
}

// Benchmark: Add orders with random prices and quantities
void BenchmarkAddOrders(int numOrders) {
    Orderbook orderbook;
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<Price> priceDist(90, 110);
    std::uniform_int_distribution<Quantity> qtyDist(1, 100);
    std::uniform_int_distribution<int> sideDist(0, 1);

    auto start = std::chrono::high_resolution_clock::now();

    // Add random orders to the book
    for (int i = 0; i < numOrders; ++i) {
        auto order = std::make_shared<Order>(
            OrderType::GoodTillCancel,
            i,
            sideDist(gen) ? Side::Buy : Side::Sell,
            priceDist(gen),
            qtyDist(gen)
        );
        orderbook.AddOrder(order);
    }

    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);

    double seconds = duration.count() / 1000000.0;
    long long ordersPerSec = static_cast<long long>(numOrders / seconds);

    std::cout << "Add " << formatNumber(numOrders) << " orders:\n";
    std::cout << "  Time: " << std::fixed << std::setprecision(2)
            << duration.count() / 1000.0 << " ms\n";
    std::cout << "  Throughput: " << formatNumber(ordersPerSec) << " orders/sec\n";
    std::cout << "  Latency: " << std::fixed << std::setprecision(3)
            << (double) duration.count() / numOrders << " μs/order\n\n";
}

// Benchmark: Order matching performance
void BenchmarkMatching(int numOrders) {
    Orderbook orderbook;
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<Quantity> qtyDist(1, 100);

    // Fill one side of the book with buy orders
    for (int i = 0; i < numOrders / 2; ++i) {
        orderbook.AddOrder(std::make_shared<Order>(
            OrderType::GoodTillCancel, i, Side::Buy, 100, qtyDist(gen)
        ));
    }

    int tradesExecuted = 0;
    auto start = std::chrono::high_resolution_clock::now();

    // Add matching sell orders and measure matching speed
    for (int i = numOrders / 2; i < numOrders; ++i) {
        auto trades = orderbook.AddOrder(std::make_shared<Order>(
            OrderType::GoodTillCancel, i, Side::Sell, 100, qtyDist(gen)
        ));
        tradesExecuted += trades.size();
    }

    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);

    double seconds = duration.count() / 1000000.0;
    long long matchesPerSec = static_cast<long long>((numOrders / 2) / seconds);
    long long tradesPerSec = static_cast<long long>(tradesExecuted / seconds);

    std::cout << "Match " << formatNumber(numOrders / 2) << " orders:\n";
    std::cout << "  Time: " << std::fixed << std::setprecision(2)
            << duration.count() / 1000.0 << " ms\n";
    std::cout << "  Trades executed: " << formatNumber(tradesExecuted) << "\n";
    std::cout << "  Throughput: " << formatNumber(matchesPerSec) << " matches/sec\n";
    std::cout << "  Trade rate: " << formatNumber(tradesPerSec) << " trades/sec\n\n";
}

// Benchmark: Order cancellation performance
void BenchmarkCancelOrders(int numOrders) {
    Orderbook orderbook;
    std::vector<OrderId> orderIds;

    // Add orders to the book
    for (int i = 0; i < numOrders; ++i) {
        orderbook.AddOrder(std::make_shared<Order>(
            OrderType::GoodTillCancel, i, Side::Buy, 100, 10
        ));
        orderIds.push_back(i);
    }

    auto start = std::chrono::high_resolution_clock::now();

    // Cancel all orders and measure speed
    for (auto orderId: orderIds) {
        orderbook.CancelOrder(orderId);
    }

    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);

    double seconds = duration.count() / 1000000.0;
    long long cancelsPerSec = static_cast<long long>(numOrders / seconds);

    std::cout << "Cancel " << formatNumber(numOrders) << " orders:\n";
    std::cout << "  Time: " << std::fixed << std::setprecision(2)
            << duration.count() / 1000.0 << " ms\n";
    std::cout << "  Throughput: " << formatNumber(cancelsPerSec) << " cancels/sec\n";
    std::cout << "  Latency: " << std::fixed << std::setprecision(3)
            << (double) duration.count() / numOrders << " μs/cancel\n\n";
}

// Benchmark: Order modification performance (cancel + re-add)
void BenchmarkModifyOrders(int numOrders) {
    Orderbook orderbook;
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<Price> priceDist(95, 105);
    std::uniform_int_distribution<Quantity> qtyDist(1, 100);

    std::vector<OrderId> orderIds;
    // Add initial orders
    for (int i = 0; i < numOrders; ++i) {
        orderbook.AddOrder(std::make_shared<Order>(
            OrderType::GoodTillCancel, i, Side::Buy, 100, 10
        ));
        orderIds.push_back(i);
    }

    auto start = std::chrono::high_resolution_clock::now();

    // Modify all orders with new random prices/quantities
    for (auto orderId: orderIds) {
        OrderModify modify(orderId, Side::Buy, priceDist(gen), qtyDist(gen));
        orderbook.MatchOrder(modify);
    }

    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);

    double seconds = duration.count() / 1000000.0;
    long long modifiesPerSec = static_cast<long long>(numOrders / seconds);

    std::cout << "Modify " << formatNumber(numOrders) << " orders:\n";
    std::cout << "  Time: " << std::fixed << std::setprecision(2)
            << duration.count() / 1000.0 << " ms\n";
    std::cout << "  Throughput: " << formatNumber(modifiesPerSec) << " modifies/sec\n";
    std::cout << "  Latency: " << std::fixed << std::setprecision(3)
            << (double) duration.count() / numOrders << " μs/modify\n\n";
}

// Benchmark: Market data snapshot generation
void BenchmarkGetOrderInfos(int numOrders, int numCalls) {
    Orderbook orderbook;

    // Populate book with orders at different price levels
    for (int i = 0; i < numOrders; ++i) {
        orderbook.AddOrder(std::make_shared<Order>(
            OrderType::GoodTillCancel, i, Side::Buy, 100 + (i % 10), 10
        ));
    }

    auto start = std::chrono::high_resolution_clock::now();

    // Generate market data snapshots repeatedly
    for (int i = 0; i < numCalls; ++i) {
        auto infos = orderbook.GetOrderInfos();
    }

    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);

    double seconds = duration.count() / 1000000.0;
    long long callsPerSec = static_cast<long long>(numCalls / seconds);

    std::cout << "GetOrderInfos (" << formatNumber(numOrders) << " orders, "
            << formatNumber(numCalls) << " calls):\n";
    std::cout << "  Time: " << std::fixed << std::setprecision(2)
            << duration.count() / 1000.0 << " ms\n";
    std::cout << "  Throughput: " << formatNumber(callsPerSec) << " snapshots/sec\n";
    std::cout << "  Latency: " << std::fixed << std::setprecision(3)
            << (double) duration.count() / numCalls << " μs/snapshot\n\n";
}

// Simulates HFT with a realistically large book by separating the warmup
// (building up resting orders) from the measured phase (steady-state churn).
// Uses a wide price range so orders don't immediately cross and consume each
// other, keeping thousands of orders alive on both sides throughout.
void BenchmarkHighFrequencyTrading() {
    Orderbook orderbook;
    std::random_device rd;
    std::mt19937 gen(rd());

    // Wide spread: buys up to 95, sells from 105 — orders won't cross
    std::uniform_int_distribution<Price> bidPriceDist(85, 95);
    std::uniform_int_distribution<Price> askPriceDist(105, 115);
    std::uniform_int_distribution<Quantity> qtyDist(1, 10);
    // 50% add, 30% cancel, 20% modify — skewed toward adds to keep book full
    std::uniform_int_distribution<int> actionDist(0, 9);

    const int warmupOrders = 10000; // pre-fill the book before measuring
    const int numOperations = 100000;
    std::vector<OrderId> activeOrders;
    activeOrders.reserve(warmupOrders + numOperations);
    OrderId nextOrderId = 0;

    // Warmup: build a large resting book, not measured
    for (int i = 0; i < warmupOrders; ++i) {
        Side side = (i % 2) ? Side::Buy : Side::Sell;
        Price price = (side == Side::Buy) ? bidPriceDist(gen) : askPriceDist(gen);
        auto order = std::make_shared<Order>(
            OrderType::GoodTillCancel, nextOrderId++, side, price, qtyDist(gen)
        );
        orderbook.AddOrder(order);
        if (!order->IsFilled()) {
            activeOrders.push_back(order->GetOrderId());
        }
    }

    int addCount = 0, cancelCount = 0, modifyCount = 0, tradeCount = 0;

    auto start = std::chrono::high_resolution_clock::now();

    for (int i = 0; i < numOperations; ++i) {
        int action = activeOrders.empty() ? 0 : actionDist(gen);

        if (action <= 4 || activeOrders.empty()) {
            // 50%: add a new resting order away from mid
            Side side = (nextOrderId % 2) ? Side::Buy : Side::Sell;
            Price price = (side == Side::Buy) ? bidPriceDist(gen) : askPriceDist(gen);
            auto order = std::make_shared<Order>(
                OrderType::GoodTillCancel, nextOrderId++, side, price, qtyDist(gen)
            );
            auto trades = orderbook.AddOrder(order);
            addCount++;
            tradeCount += trades.size();
            if (!order->IsFilled()) {
                activeOrders.push_back(order->GetOrderId());
            }
        } else if (action <= 7) {
            // 30%: cancel a random active order
            size_t idx = gen() % activeOrders.size();
            orderbook.CancelOrder(activeOrders[idx]);
            activeOrders.erase(activeOrders.begin() + idx);
            cancelCount++;
        } else {
            // 20%: modify a random active order (reprice within same side's range)
            size_t idx = gen() % activeOrders.size();
            Price price = (nextOrderId % 2) ? bidPriceDist(gen) : askPriceDist(gen);
            OrderModify modify(activeOrders[idx], Side::Buy, price, qtyDist(gen));
            orderbook.MatchOrder(modify);
            modifyCount++;
        }
    }

    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);

    double seconds = duration.count() / 1000.0;
    long long opsPerSec = static_cast<long long>(numOperations / seconds);

    std::cout << "High-Frequency Trading Simulation:\n";
    std::cout << "  Warmup book size: " << formatNumber(warmupOrders) << " orders\n";
    std::cout << "  Operations: " << formatNumber(numOperations) << " (Add: "
            << formatNumber(addCount) << ", Cancel: " << formatNumber(cancelCount)
            << ", Modify: " << formatNumber(modifyCount) << ")\n";
    std::cout << "  Trades executed: " << formatNumber(tradeCount) << "\n";
    std::cout << "  Time: " << std::fixed << std::setprecision(2) << duration.count() << " ms\n";
    std::cout << "  Throughput: " << formatNumber(opsPerSec) << " operations/sec\n";
    std::cout << "  Final book size: " << formatNumber((long long)orderbook.Size()) << " orders\n\n";
}

// ==================== MAIN TEST RUNNER ====================

int main() {
    std::cout << std::string(70, '=') << "\n";
    std::cout << std::setw(45) << "ORDERBOOK FUNCTIONALITY TESTS\n";
    std::cout << std::string(70, '=') << "\n\n";

    RUN_TEST(TestBasicAddOrder);
    RUN_TEST(TestCancelOrder);
    RUN_TEST(TestDuplicateOrderRejection);
    RUN_TEST(TestSimpleMatch);
    RUN_TEST(TestPartialMatch);
    RUN_TEST(TestMultipleMatchesAtSamePrice);
    RUN_TEST(TestPricePriority);
    RUN_TEST(TestTimePriority_FIFO);
    RUN_TEST(TestMarketOrderBuy);
    RUN_TEST(TestMarketOrderSell);
    RUN_TEST(TestMarketOrderEmptyBook);
    RUN_TEST(TestImmediateOrCancel_PartialFill);
    RUN_TEST(TestImmediateOrCancel_NoMatch);
    RUN_TEST(TestFillOrKill_FullFill);
    RUN_TEST(TestFillOrKill_PartialAvailable);
    RUN_TEST(TestFillOrKill_MultipleOrders);
    RUN_TEST(TestOrderModify);
    RUN_TEST(TestOrderbookLevelInfos);
    RUN_TEST(TestExchangeRulesBasic);
    RUN_TEST(TestMinNotionalValidation);
    RUN_TEST(TestMarketOrderValidation);

    std::cout << "\nAll " << 21 << " functionality tests passed!\n";

    PrintPerformanceHeader();

    std::cout << "--- Order Addition Performance ---\n";
    BenchmarkAddOrders(1000);
    BenchmarkAddOrders(10000);
    BenchmarkAddOrders(100000);

    std::cout << "--- Order Matching Performance ---\n";
    BenchmarkMatching(1000);
    BenchmarkMatching(10000);
    BenchmarkMatching(50000);

    std::cout << "--- Order Cancellation Performance ---\n";
    BenchmarkCancelOrders(1000);
    BenchmarkCancelOrders(10000);
    BenchmarkCancelOrders(100000);

    std::cout << "--- Order Modification Performance ---\n";
    BenchmarkModifyOrders(1000);
    BenchmarkModifyOrders(10000);

    std::cout << "--- Market Data Snapshot Performance ---\n";
    BenchmarkGetOrderInfos(1000, 1000);
    BenchmarkGetOrderInfos(10000, 1000);

    std::cout << "--- High-Frequency Trading Simulation ---\n";
    BenchmarkHighFrequencyTrading();

    std::cout << "\nTesting complete!\n";

    return 0;
}