public void run()

in orderbook-it/src/main/java/com/epam/deltix/orderbook/it/OrderBookIT.java [131:252]
105 lines of code
7 McCabe index (conditional complexity)

    public void run() throws Throwable {
        final String timebaseUrl = getArgValue("-url", "dxtick://localhost:8011");
        final String timebaseUser = getArgValue("-user");
        final String timebasePassword = getArgValue("-password");
        final String streamKey = getArgValue("-stream", "bitmex");
        final String symbol = getArgValue("-symbol", "BTC/USD");

        long startTime = getLongArgValue("-start_time_ms", Long.MIN_VALUE);
        final String startTimeStr = getArgValue("-start_time");
        if (startTimeStr != null) {
            startTime = Instant.parse(startTimeStr).toEpochMilli();
        }

        long endTime = getLongArgValue("-end_time_ms", Long.MAX_VALUE);
        String endTimeStr = getArgValue("-end_time");
        if (endTimeStr != null) {
            endTime = Instant.parse(endTimeStr).toEpochMilli();
        }

        final DXTickDB db = timebaseUser != null ?
                TickDBFactory.createFromUrl(timebaseUrl, timebaseUser, timebasePassword) :
                TickDBFactory.createFromUrl(timebaseUrl);
        db.open(true);
        try {
            final DXTickStream stream = db.getStream(streamKey);
            if (stream == null) {
                throw new RuntimeException("Can't find stream " + streamKey);
            }
            final long[] range = stream.getTimeRange();
            if (startTime == Long.MIN_VALUE) {
                startTime = range[0];
            }

            final StringBuilder resultBuilder = new StringBuilder();

            LOGGER.info().append("Warmup pass...").commit();
            resultBuilder.append(executed(symbol, startTime, startTime + 60 * 60 * 1000, stream, p -> {
            }, "Black Hole", new Object()));
            LOGGER.info().append("Main pass...").commit();

            final OrderBookOptions symbolOptions = new OrderBookOptionsBuilder().symbol(symbol).build();

            final OrderBookOptions l1SingleExchangeOptions = new OrderBookOptionsBuilder()
                    .parent(symbolOptions)
                    .orderBookType(OrderBookType.SINGLE_EXCHANGE)
                    .quoteLevels(DataModelType.LEVEL_ONE)
                    .initialDepth(500)
                    .initialExchangesPoolSize(1)
                    .updateMode(UpdateMode.WAITING_FOR_SNAPSHOT).build();

            final OrderBook<OrderBookQuote> singleExchangeL1Book = OrderBookFactory.create(l1SingleExchangeOptions);
            resultBuilder.append(executed(
                    symbol,
                    startTime,
                    endTime,
                    stream,
                    singleExchangeL1Book::update,
                    singleExchangeL1Book.getDescription(),
                    singleExchangeL1Book)
            );
            //
            final OrderBookOptions l2CommonOptions = new OrderBookOptionsBuilder()
                    .parent(symbolOptions)
                    .quoteLevels(DataModelType.LEVEL_TWO)
                    .initialDepth(40).initialExchangesPoolSize(1)
                    .updateMode(UpdateMode.WAITING_FOR_SNAPSHOT).build();

            final OrderBookOptions l2ConsolidatedOptions = new OrderBookOptionsBuilder()
                    .parent(l2CommonOptions)
                    .orderBookType(OrderBookType.CONSOLIDATED)
                    .build();

            final OrderBook<OrderBookQuote> consolidatedBook = OrderBookFactory.create(l2ConsolidatedOptions);
            resultBuilder.append(executed(
                    symbol,
                    startTime,
                    endTime,
                    stream,
                    consolidatedBook::update,
                    consolidatedBook.getDescription(),
                    consolidatedBook));

            final OrderBookOptions l2AggregatedOptions = new OrderBookOptionsBuilder()
                            .parent(l2CommonOptions)
                            .orderBookType(OrderBookType.AGGREGATED)
                    .build();

            final OrderBook<OrderBookQuote> aggregatedBook = OrderBookFactory.create(l2AggregatedOptions);
            resultBuilder.append(executed(
                    symbol,
                    startTime,
                    endTime,
                    stream,
                    aggregatedBook::update,
                    aggregatedBook.getDescription(),
                    aggregatedBook)
            );

            final OrderBookOptions l2SingledExchangeOptions = new OrderBookOptionsBuilder()
                    .parent(l2CommonOptions)
                    .orderBookType(OrderBookType.SINGLE_EXCHANGE)
                    .build();

            final OrderBook<OrderBookQuote> singleExchangeBook = OrderBookFactory.create(l2SingledExchangeOptions);
            resultBuilder.append(executed(
                    symbol,
                    startTime,
                    endTime,
                    stream,
                    singleExchangeBook::update,
                    singleExchangeBook.getDescription(),
                    singleExchangeBook)
            );

            LOGGER.info("\n %s").with(resultBuilder);

        } catch (final Throwable t) {
            LOGGER.error().append("Failed to test").append(t).commit();
        } finally {
            db.close();
        }
    }