servletOutputStream = new ServletOutputStream() {
            @Override
            public void write(int b) throws IOException {
                outputStream.write(b);
            }

            @Override
            public boolean isReady() {
                return true;
            }

            @Override
            public void setWriteListener(WriteListener listener) {
            }

            private static final long serialVersionUID = 1L;

            @Override
            public String getIndexConfigIndex() {
                return "fess_config";
            }

            @Override
            public Integer getCoordinatorPollIntervalAsInteger() {
                return 60;
            }

            @Override
            public Integer getCoordinatorHeartbeatTtlAsInteger() {

  protected ForwardingSortedMap() {}

  @Override
  protected abstract SortedMap<K, V> delegate();

  @Override
  public @Nullable Comparator<? super K> comparator() {
    return delegate().comparator();
  }

  @Override
  @ParametricNullness
  public K firstKey() {
    return delegate().firstKey();
  }

  @Override
  public SortedMap<K, V> headMap(@ParametricNullness K toKey) {

    val body: ResponseBody =
      object : ResponseBody() {
        override fun contentType(): MediaType? = null

        override fun contentLength(): Long = 5

        override fun source(): BufferedSource {
          val source = Buffer().writeUtf8("hello")
          return object : ForwardingSource(source) {
            override fun close() {
              closed = true
              super.close()
            }

        @Override
        public String getId() {
            return null;
        }

        @Override
        public Long getVersionNo() {
            return null;
        }

        @Override
        public Map<String, Object> toSource() {
            return null;
        }

        @Override
        public String getEventType() {
            return null;

      return inline.submit(Iterables.get(tasks, 0)).get(timeout, unit);
    }

    @Override
    public boolean isShutdown() {
      lastMethodCalled = "isShutdown";
      return false;
    }

    @Override
    public boolean isTerminated() {
      lastMethodCalled = "isTerminated";
      return false;
    }

    @Override
    public void shutdown() {
      lastMethodCalled = "shutdown";
    }

  private final File path;

  public UnixDomainSocketFactory(File path) {
    this.path = path;
  }

  @Override public Socket createSocket() throws IOException {
    UnixSocketChannel channel = UnixSocketChannel.open();
    return new TunnelingUnixSocket(path, channel);
  }

  @Override public Socket createSocket(String host, int port) throws IOException {
    Socket result = createSocket();

    try {

        super(config);
    }

    @Override
    protected int writeParameterWordsWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    protected int writeBytesWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    protected int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {

        @Override
        public LoginCredential getLoginCredential() {
            return loginCredential;
        }

        @Override
        public void resolveCredential(FessLoginAssist.LoginCredentialResolver resolver) {
            this.lastResolver = resolver;
            this.resolverCalled = true;
        }

        @Override

                new NoOpValueAndCloserConsumer<>(), finishToValueAndCloserExecutor));
  }

  @Override
  <T> T getFinalValue(ClosingFuture<T> closingFuture) throws ExecutionException {
    return finishToValueAndCloser(closingFuture).get();
  }

  @Override
  void assertFinallyFailsWithException(ClosingFuture<?> closingFuture) {
    assertThatFutureFailsWithException(closingFuture.statusFuture());