}

    private TestOutputStore.Reader getReader() {
        Thread thread = Thread.currentThread();
        TestOutputStore.Reader reader = readers.get(thread);
        if (reader == null) {
            reader = outputStore.reader();
            readers.put(thread, reader);
        }
        return reader;
    }

    @Override
    public void close() throws IOException {

        // Use a single reader thread, and make it a daemon thread so that it does not block process shutdown
        // In most cases, we try to cleanly shut down all threads. However, in this case it is difficult to disconnect a thread blocked trying to read from the
        // process' stdin, so use a daemon thread instead.
        executor = Executors.newSingleThreadExecutor(r -> {
            Thread thread = new Thread(r);

  }

  /**
   * Causes this thread to call the named method, and asserts that this thread becomes blocked on
   * the lock-like object. The lock-like object must have a method equivalent to {@link
   * java.util.concurrent.locks.ReentrantLock#hasQueuedThread(Thread)}.
   */
  public void callAndAssertBlocks(String methodName, Object... arguments) throws Exception {

        def actor = factory.createBlockingActor(target)
        def testThread = Thread.currentThread()

        when:
        actor.dispatch(new MethodInvocation(TargetObject.class.getMethod('doStuff', String.class), ['param'] as Object[]))

        then:
        1 * target.doStuff('param') >> {
            assert Thread.currentThread() == testThread
        }
    }

   * state: BLOCKED, WAITING, or TIMED_WAITING.
   */
  void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
    long startTime = System.nanoTime();
    for (; ; ) {
      Thread.State s = thread.getState();
      if (s == Thread.State.BLOCKED || s == Thread.State.WAITING || s == Thread.State.TIMED_WAITING)
        return;

        return processRequest(uri, true);
    }

    /*
     * (non-Javadoc)
     *
     * @see org.codelibs.fess.crawler.client.CrawlerClient#doHead(java.lang.String)
     */
    @Override
    public ResponseData doHead(final String url) {
        try {
            final ResponseData responseData = processRequest(url, false);
            responseData.setMethod(Constants.HEAD_METHOD);

    }
  }

  /** Wait for the given thread to reach the {@link State#TIMED_WAITING} thread state. */
  void awaitTimedWaiting(Thread thread) {
    while (true) {
      switch (thread.getState()) {
        case BLOCKED:
        case NEW:
        case RUNNABLE:
        case WAITING:
          Thread.yield();
          break;
        case TIMED_WAITING:
          return;

     * thread to run as if it were executing an isolated task.
     *
     * Does not release worker lease.
     */
    void runAsIsolatedTask();

    /**
     * Returns {@code true} when this registry grants multiple threads access to projects (but no more than one thread per given project)

            LOGGER.debug("thread {}: dispatching {}", Thread.currentThread().getId(), message);
        }
        lock.lock();
        try {
            if (dispatching) {
                // Safety check: dispatching a message should not cause the thread to dispatch another message (eg should not do any logging)
                throw new IllegalStateException("This thread is already dispatching a message.");
            }

        Thread t = this.thread;
        if ( t != null && Thread.currentThread() != t ) {
            this.thread = null;
            try {
                log.debug("Interrupting transport thread");
                t.interrupt();
                log.debug("Joining transport thread");
                t.join(timeout);