WaiterThread waiter = new WaiterThread(future);
    waiter.start();
    waiter.awaitWaiting();
    PollingThread poller = new PollingThread(future);
    poller.start();
    PollingThread poller2 = new PollingThread(future);
    poller2.start();
    PollingThread poller3 = new PollingThread(future);
    poller3.start();
    poller.awaitInLoop();
    poller2.awaitInLoop();
    poller3.awaitInLoop();

                return startPosition;
            }

            final String start = request.getParameter("start");
            if (StringUtil.isBlank(start)) {
                startPosition = fessConfig.getPagingSearchPageStartAsInteger();
            } else {
                try {
                    startPosition = Integer.parseInt(start);
                } catch (final NumberFormatException e) {

        final Map<String, String> statusMap = new HashMap<>();
        CrawlingInfoHelper testCrawlingInfoHelper = new CrawlingInfoHelper() {
            private final Map<String, String> infoMap = new HashMap<>();

            @Override
            public void store(String sessionId, boolean running) {
                // Track the final status
                if (!running) {

              }
            },
            directExecutor());

    // Wait for the first task to be started in the background. It will block until we explicitly
    // stop it.
    blockingCallable.waitForStart();

    // Give the second task a chance to (incorrectly) start up while the first task is running.
    assertThat(future2.isDone()).isFalse();

            }
            n = response.dataLength;
            if (n <= 0) {
                return (int) (fp - start > 0L ? fp - start : -1);
            }
            fp += n;
            len -= n;
            response.off += n;
        } while (len > 0 && n == r);

        return (int) (fp - start);
    }

    /**
     * This stream class is unbuffered. Therefore this method will always

                log.info("Failed to send node status request for " + addr, ioe);
                throw new UnknownHostException(addr.toString());
            }
            if (response.received && response.resultCode == 0) {

                /*
                 * For name queries resolved by different sources (e.g. WINS,
                 * BCAST, Node Status) we need to augment the hashcode generated

  }

  private fun logWithTime(message: String) {
    val startNs = startNs
    val timeMs =
      if (startNs == null) {
        // Event occurred before start, for an example an early cancel.
        0L
      } else {
        TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNs)
      }

    logger.invoke("[$timeMs ms] $message")
  }

  @BeforeEach fun setUp() {
    client.start()
  }

  @AfterEach fun tearDown() {
    client.stop()
  }

  @Test fun get() {
    server.enqueue(MockResponse(body = "hello, Jetty HTTP Client"))

    val request =
      client
        .newRequest(server.url("/").toUri())
        .header("Accept", "text/plain")
    val response = request.send()
    assertThat(response.status).isEqualTo(200)

    protected int bufDataStart;

    int dataCount;
    byte subCommand;
    boolean hasMore = true;
    boolean isPrimary = true;
    byte[] txn_buf;

    /* for doNetEnum and doFindFirstNext */
    int status;
    int numEntries;
    FileEntry[] results;

    SmbComTransactionResponse() {
        txn_buf = null;
    }

    @Override
    void reset() {
        super.reset();
        bufDataStart = 0;

        this.totalAvailableEntries = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;

        return bufferIndex - start;
    }

    @Override
    protected int readDataWireFormat(final byte[] buffer, int bufferIndex, final int len) {
        final int start = bufferIndex;
        SmbShareInfo e;

        setUseUnicode(false);

        final SmbShareInfo[] results = new SmbShareInfo[getNumEntries()];