public Open(OrderEntry orderEntry, long instrument, long bidPrice, long bidSize,
        long askPrice, long askSize) {
    super(orderEntry);

    this.enterBuyOrder = new POE.EnterOrder();

    ASCII.putLeft(this.enterBuyOrder.orderId, orderId.next());
    this.enterBuyOrder.side       = POE.BUY;
    this.enterBuyOrder.instrument = instrument;
    this.enterBuyOrder.quantity   = bidSize;
    this.enterBuyOrder.price      = bidPrice;

    this.enterSellOrder = new POE.EnterOrder();

    ASCII.putLeft(this.enterSellOrder.orderId, orderId.next());
    this.enterSellOrder.side       = POE.SELL;
    this.enterSellOrder.instrument = instrument;
    this.enterSellOrder.quantity   = askSize;
    this.enterSellOrder.price      = askPrice;
}
 

public void reset() {
    ASCII.putLongRight(lengthOfMessage, 0);
    ASCII.putLongRight(numberOfItems, 0);

    lengthOfMessagePosition = -1;
    numberOfCurrencyPairsPosition = -1;
    numberOfPricesPosition = -1;
    numberOfOrdersPosition = -1;

    currencyPairs = 0;
    prices        = 0;
    orders        = 0;

    ASCII.putLeft(currencyPair, " ");
    buyOrSellIndicator = ' ';
    ASCII.putLeft(price, " ");
}
 

@Test
public void loginRequest() throws Exception {
    ASCII.putLeft(loginRequest.loginName, "foo");
    ASCII.putLeft(loginRequest.password, "bar");
    loginRequest.marketDataUnsubscribe = ITCH.TRUE;
    ASCII.putLongRight(loginRequest.reserved, 0);

    client.login(loginRequest);

    while (serverEvents.collect().size() != 1)
        server.receive();

    assertEquals(asList(new LoginRequest(
                    "foo                                     ",
                    "bar                                     ",
                    ITCH.TRUE, 0)),
            serverEvents.collect());
}
 

static TerminalClient open(InetSocketAddress address, String username,
        String password, Instruments instruments) throws IOException {
    Events events = new Events();

    OrderEntry orderEntry = OrderEntry.open(address, events);

    SoupBinTCP.LoginRequest loginRequest = new SoupBinTCP.LoginRequest();

    ASCII.putLeft(loginRequest.username, username);
    ASCII.putLeft(loginRequest.password, password);
    ASCII.putRight(loginRequest.requestedSession, "");
    ASCII.putLongRight(loginRequest.requestedSequenceNumber, 0);

    orderEntry.getTransport().login(loginRequest);

    return new TerminalClient(events, orderEntry, instruments);
}
 

@Override
public void execute(TerminalClient client, Scanner arguments) throws IOException {
    try {
        double quantity   = arguments.nextDouble();
        long   instrument = ASCII.packLong(arguments.next());
        double price      = arguments.nextDouble();

        if (arguments.hasNext())
            throw new IllegalArgumentException();

        Instrument config = client.getInstruments().get(instrument);
        if (config == null)
            throw new IllegalArgumentException();

        execute(client, Math.round(quantity * config.getSizeFactor()), instrument, Math.round(price * config.getPriceFactor()));
    } catch (NoSuchElementException e) {
        throw new IllegalArgumentException();
    }
}
 

@Override
public void logon(FIXConnection connection, FIXMessage message) throws IOException {
    FIXValue username = message.valueOf(Username);
    FIXValue password = message.valueOf(Password);

    if (requiredTagMissing(message, username, "Username(553)"))
        return;

    if (requiredTagMissing(message, password, "Password(554)"))
        return;

    fix.updateCompID(message);

    ASCII.putLeft(loginRequest.username, username.asString());
    ASCII.putLeft(loginRequest.password, password.asString());
    ASCII.putRight(loginRequest.requestedSession, "");
    ASCII.putLongRight(loginRequest.requestedSequenceNumber, 0);

    orderEntry.login(loginRequest);
}
 

@Override
public void orderRejected(POE.OrderRejected message) throws IOException {
    long orderEntryId = ASCII.getLong(message.orderId);

    Order order = orders.findByOrderEntryID(orderEntryId);
    if (order == null)
        return;

    switch (message.reason) {
    case POE.ORDER_REJECT_REASON_UNKNOWN_INSTRUMENT:
        sendOrderRejected(order, OrdRejReasonValues.UnknownSymbol);
        break;
    case POE.ORDER_REJECT_REASON_INVALID_PRICE:
        sendOrderRejected(order, OrdRejReasonValues.Other);
        break;
    case POE.ORDER_REJECT_REASON_INVALID_QUANTITY:
        sendOrderRejected(order, OrdRejReasonValues.IncorrectQuantity);
        break;
    default:
        sendOrderRejected(order, OrdRejReasonValues.Other);
        break;
    }

    orders.removeByOrderEntryID(orderEntryId);
}
 

@Override
public void orderExecuted(POE.OrderExecuted message) throws IOException {
    long orderEntryId = ASCII.getLong(message.orderId);

    Order order = orders.findByOrderEntryID(orderEntryId);
    if (order == null)
        return;

    Instrument config = instruments.get(order.getSymbol());

    double lastQty = message.quantity / config.getSizeFactor();
    double lastPx  = message.price    / config.getPriceFactor();

    order.orderExecuted(lastQty, lastPx);

    sendOrderExecuted(order, lastQty, lastPx, config);

    if (order.getLeavesQty() == 0) {
        orders.removeByOrderEntryID(orderEntryId);

        if (order.isInPendingStatus())
            sendOrderCancelReject(order);
    }
}
 

@Override
public void orderCanceled(POE.OrderCanceled message) throws IOException {
    long orderEntryId = ASCII.getLong(message.orderId);

    Order order = orders.findByOrderEntryID(orderEntryId);
    if (order == null)
        return;

    Instrument config = instruments.get(order.getSymbol());

    order.orderCanceled(message.canceledQuantity / config.getSizeFactor());

    sendOrderCanceled(order, config);

    if (order.getLeavesQty() == 0)
        orders.removeByOrderEntryID(orderEntryId);
}
 

@Override
    public void stockDirectory(ITCH50.StockDirectory itchMsg) {
//                log.debug("{}", itchMsg);

        symbolDescr.put(itchMsg.stockLocate, new StockDescr(ASCII.unpackLong(itchMsg.stock), itchMsg.etpFlag, itchMsg.etpLeverageFactor));

//        CoreSymbolSpecification symbolSpecification = CoreSymbolSpecification.builder()
//                .symbolId(itchMsg.stockLocate)
//                .type(SymbolType.FUTURES_CONTRACT) // allow margin trade TODO calculate based on ETP
//                .baseCurrency(itchMsg.stockLocate + 10_000)
//                .quoteCurrency(TestConstants.CURRENECY_USD)
//                .takerFee(3)
//                .makerFee(1)
//                .quoteScaleK(2)
//                .baseScaleK(itchMsg.roundLotSize)
//                .marginBuy(itchMsg.etpLeverageFactor + 100L) // TODO price
//                .marginSell(itchMsg.etpLeverageFactor + 100L) // TODO price
//                .build();
//
//        final CompletableFuture<OrderCommand> response = api.submitBinaryCommandAsync(new BatchAddSymbolsCommand(symbolSpecification), itchMsg.stockLocate, Function.identity());
//
//        response.thenAccept(cmdRes -> {
//            if (cmdRes.resultCode != CommandResultCode.SUCCESS) {
//                log.error("symbol add failed: {}", response);
//            }
//            if (ASCII.unpackLong(itchMsg.stock).trim().equals("INTL")) {
//                log.debug("{} {} ls={} mc={} etpF={} etpL={} rlo={}",
//                        ASCII.unpackLong(itchMsg.stock),
//                        itchMsg.stockLocate,
//                        itchMsg.roundLotSize,
//                        (char) itchMsg.marketCategory,
//                        (char) itchMsg.etpFlag,
//                        itchMsg.etpLeverageFactor,
//                        (char) itchMsg.roundLotsOnly);
//            }
//        });
    }
 

private static MarketData marketData(Config config) throws IOException {
    NetworkInterface multicastInterface = Configs.getNetworkInterface(config, "market-data.multicast-interface");
    InetAddress      multicastGroup     = Configs.getInetAddress(config, "market-data.multicast-group");
    int              multicastPort      = Configs.getPort(config, "market-data.multicast-port");
    InetAddress      requestAddress     = Configs.getInetAddress(config, "market-data.request-address");
    int              requestPort        = Configs.getPort(config, "market-data.request-port");

    String instrument = config.getString("instrument");

    return MarketData.open(multicastInterface,
            new InetSocketAddress(multicastGroup, multicastPort),
            new InetSocketAddress(requestAddress, requestPort),
            ASCII.packLong(instrument));
}
 

private static Open open(Config config) throws IOException {
    double bidPrice = config.getDouble("open.bid.price");
    long   bidSize  = config.getLong("open.bid.size");
    double askPrice = config.getDouble("open.ask.price");
    long   askSize  = config.getLong("open.ask.size");

    String instrument = config.getString("instrument");

    return new Open(orderEntry(config), ASCII.packLong(instrument),
            (long)(bidPrice * PRICE_FACTOR), bidSize,
            (long)(askPrice * PRICE_FACTOR), askSize);
}
 

private void enter(byte side, double price) throws IOException {
    ASCII.putLeft(enterOrder.orderId, orderId.next());
    enterOrder.side  = side;
    enterOrder.price = (long)Math.round(price * 100.0) * 100;

    getOrderEntry().send(enterOrder);
}
 

public void login(String username, String password) throws IOException {
    SoupBinTCP.LoginRequest request = new SoupBinTCP.LoginRequest();

    ASCII.putLeft(request.username, username);
    ASCII.putLeft(request.password, password);
    ASCII.putRight(request.requestedSession, "");
    ASCII.putLongRight(request.requestedSequenceNumber, 0);

    transport.login(request);
}
 

/**
 * Start a Market Snapshot message.
 *
 * @param buffer a buffer
 */
public void marketSnapshotStart(ByteBuffer buffer) {
    state.reset();

    // Message Type
    buffer.put(MESSAGE_TYPE_MARKET_SNAPSHOT);

    state.lengthOfMessagePosition = buffer.position();

    // Length of Message
    ASCII.putLongRight(state.lengthOfMessage, 0);
    buffer.put(state.lengthOfMessage);

    state.numberOfCurrencyPairsPosition = buffer.position();
}
 

/**
 * End a Market Snapshot message.
 *
 * @param buffer a buffer
 */
public void marketSnapshotEnd(ByteBuffer buffer) {
    if (state.currencyPairs > 0) {

        // Number of Currency Pairs
        ASCII.putLongRight(state.numberOfItems, state.currencyPairs);
        put(buffer, state.numberOfItems, state.numberOfCurrencyPairsPosition);
    }

    if (state.buyOrSellIndicator == BUY) {

        // Number Of Offer Prices
        ASCII.putLongRight(state.numberOfItems, 0);
        buffer.put(state.numberOfItems);
    }

    if (state.prices > 0) {

        // Number of Bid/Offer Prices
        ASCII.putLongRight(state.numberOfItems, state.prices);
        put(buffer, state.numberOfItems, state.numberOfPricesPosition);
    }

    if (state.orders > 0) {

        // Number of Bid/Offer Orders
        ASCII.putLongRight(state.numberOfItems, state.orders);
        put(buffer, state.numberOfItems, state.numberOfOrdersPosition);
    }

    int endPosition = buffer.position();

    int lengthOfMessage = endPosition - state.numberOfCurrencyPairsPosition;

    // Length of Message
    ASCII.putLongRight(state.lengthOfMessage, lengthOfMessage);
    put(buffer, state.lengthOfMessage, state.lengthOfMessagePosition);
}
 

@Override
public void sequencedData(ITCHClient session, ITCH.SequencedData header, ByteBuffer payload) {
    String time  = ASCII.get(header.time);
    byte[] bytes = new byte[payload.remaining()];

    payload.get(bytes);

    events.add(new SequencedData(time, bytes));
}
 

@Override
public void instrumentDirectory(ITCHClient session, ITCH.InstrumentDirectory packet) {
    long numberOfCurrencyPairs = ASCII.getLong(packet.numberOfCurrencyPairs);

    List<String> currencyPairs = new ArrayList<>();

    for (int i = 0; i < numberOfCurrencyPairs; i++)
        currencyPairs.add(ASCII.get(packet.currencyPair[i]));

    events.add(new InstrumentDirectory(currencyPairs));
}
 

@Override
public void newOrder(CboeFXBook.NewOrder message) {
    byte   buyOrSellIndicator = message.buyOrSellIndicator;
    String currencyPair       = ASCII.get(message.currencyPair);
    String orderId            = ASCII.get(message.orderId);
    long   price              = ASCII.getFixed(message.price, PRICE_DECIMALS);
    long   amount             = ASCII.getLong(message.amount);
    long   minqty             = ASCII.getLong(message.minqty);
    long   lotsize            = ASCII.getLong(message.lotsize);

    events.add(new NewOrder(buyOrSellIndicator, currencyPair, orderId,
                price, amount, minqty, lotsize));
}
 

@Override
public void modifyOrder(CboeFXBook.ModifyOrder message) {
    String currencyPair = ASCII.get(message.currencyPair);
    String orderId      = ASCII.get(message.orderId);
    long   amount       = ASCII.getLong(message.amount);
    long   minqty       = ASCII.getLong(message.minqty);
    long   lotsize      = ASCII.getLong(message.lotsize);

    events.add(new ModifyOrder(currencyPair, orderId, amount,
                minqty, lotsize));
}
 

@Override
public void cancelOrder(CboeFXBook.CancelOrder message) {
    String currencyPair = ASCII.get(message.currencyPair);
    String orderId      = ASCII.get(message.orderId);

    events.add(new CancelOrder(currencyPair, orderId));
}
 

@Override
public void marketSnapshotEntry(CboeFXBook.MarketSnapshotEntry entry) {
    String currencyPair       = ASCII.get(entry.currencyPair);
    byte   buyOrSellIndicator = entry.buyOrSellIndicator;
    long   price              = ASCII.getFixed(entry.price, PRICE_DECIMALS);
    long   amount             = ASCII.getLong(entry.amount);
    long   minqty             = ASCII.getLong(entry.minqty);
    long   lotsize            = ASCII.getLong(entry.lotsize);
    String orderId            = ASCII.get(entry.orderId);

    events.add(new MarketSnapshotEntry(currencyPair, buyOrSellIndicator,
                price, amount, minqty, lotsize, orderId));
}
 

@Override
public void ticker(CboeFXBook.Ticker message) {
    byte   aggressorBuyOrSellIndicator = message.aggressorBuyOrSellIndicator;
    String currencyPair                = ASCII.get(message.currencyPair);
    long   price                       = ASCII.getFixed(message.price, PRICE_DECIMALS);
    long   transactionDate             = ASCII.getLong(message.transactionDate);
    long   transactionTime             = ASCII.getLong(message.transactionTime);

    events.add(new Ticker(aggressorBuyOrSellIndicator, currencyPair,
                price, transactionDate, transactionTime));
}
 

@Test
public void loginAccepted() throws Exception {
    ASCII.putLongRight(loginAccepted.sequenceNumber, 1);

    server.accept(loginAccepted);

    while (clientEvents.collect().size() != 1)
        client.receive();

    assertEquals(asList(new LoginAccepted(1)), clientEvents.collect());
}
 

@Test
public void loginRejected() throws Exception {
    ASCII.putLeft(loginRejected.reason, "foo");

    server.reject(loginRejected);

    while (clientEvents.collect().size() != 1)
        client.receive();

    assertEquals(asList(new LoginRejected("foo                 ")),
                clientEvents.collect());
}
 

@Test
public void sequencedData() throws Exception {
    ASCII.putLeft(sequencedData.time, "093000250");

    byte[] payload = new byte[] { 'f', 'o', 'o' };

    server.send(sequencedData, ByteBuffer.wrap(payload));

    while (clientEvents.collect().size() != 1)
        client.receive();

    assertEquals(asList(new SequencedData("093000250", payload)),
            clientEvents.collect());
}
 

@Test
public void fullBuffer() throws Exception {
    ASCII.putLeft(sequencedData.time, "093000250");

    byte[] payload = repeat((byte)'A', RX_BUFFER_CAPACITY - 11);

    server.send(sequencedData, ByteBuffer.wrap(payload));

    while (clientEvents.collect().size() != 1)
        client.receive();

    assertEquals(asList(new SequencedData("093000250", payload)),
            clientEvents.collect());
}
 

@Test(expected=ITCHException.class)
public void packetLengthExceedsBufferCapacity() throws Exception {
    ASCII.putLeft(sequencedData.time, "093000250");

    byte[] payload = repeat((byte)'A', RX_BUFFER_CAPACITY - 10);

    server.send(sequencedData, ByteBuffer.wrap(payload));

    while (true)
        client.receive();
}
 

@Test
public void errorNotification() throws Exception {
    ASCII.putLeft(errorNotification.errorExplanation, "foo");

    server.notifyError(errorNotification);

    while (clientEvents.collect().size() != 1)
        client.receive();

    assertEquals(asList(new ErrorNotification(
                    "foo                                               " +
                    "                                                  ")),
            clientEvents.collect());
}
 

@Test
public void instrumentDirectory() throws Exception {
    ASCII.putLongRight(instrumentDirectory.numberOfCurrencyPairs, 3);
    ASCII.putLeft(instrumentDirectory.currencyPair[0], "FOO/BAR");
    ASCII.putLeft(instrumentDirectory.currencyPair[1], "BAR/BAZ");
    ASCII.putLeft(instrumentDirectory.currencyPair[2], "BAZ/FOO");

    server.instrumentDirectory(instrumentDirectory);

    while (clientEvents.collect().size() != 1)
        client.receive();

    assertEquals(asList(new InstrumentDirectory(asList("FOO/BAR", "BAR/BAZ", "BAZ/FOO"))),
            clientEvents.collect());
}