}
      }
    }

  internal fun kickCoordinator(taskQueue: TaskQueue) {
    assertLockHeld()

    if (taskQueue.activeTask == null) {
      if (taskQueue.futureTasks.isNotEmpty()) {
        readyQueues.addIfAbsent(taskQueue)
      } else {
        readyQueues.remove(taskQueue)
      }
    }

    if (coordinatorWaiting) {
      backend.coordinatorNotify(this@TaskRunner)

        }

        in 8..9 -> {
          id = source.readUtf8LineStrict().takeIf { it.isNotEmpty() }
        }

        in 10..12 -> {
          id = null // 'id' on a line of its own.
        }

        in 13..14 -> {
          type = source.readUtf8LineStrict().takeIf { it.isNotEmpty() }
        }

        in 15..17 -> {
          type = null // 'event' on a line of its own
        }

            final String resourceName = params != null ? params.get(ExtractData.RESOURCE_NAME_KEY) : null;

            String value = null;
            if (StringUtil.isNotEmpty(url)) {
                value = url;
            } else if (StringUtil.isNotEmpty(resourceName)) {
                value = resourceName;
            }

            if (value != null) {

            append(", ")
          }
          append(name)
          append(':')
          append(if (isSensitiveHeader(name)) "██" else value)
        }
        append(']')
      }
      if (tags.isNotEmpty()) {
        append(", tags=")
        append(tags)
      }
      append('}')
    }

  open class Builder {
    internal var url: HttpUrl? = null
    internal var method: String

    protected Client createClient() {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        final String[] hosts =
                split(address, ",").get(stream -> stream.map(String::trim).filter(StringUtil::isNotEmpty).toArray(n -> new String[n]));
        final Builder builder = Settings.builder()
                .putList("http.hosts", hosts)
                .put("processors", fessConfig.getCrawlerHttpProcessors())

  internal val acceptEncoding =
    algorithms
      .map {
        it.encoding
      }.joinToString(separator = ", ")

  override fun intercept(chain: Interceptor.Chain): Response =
    if (algorithms.isNotEmpty() && chain.request().header("Accept-Encoding") == null) {
      val request =
        chain
          .request()
          .newBuilder()
          .header("Accept-Encoding", acceptEncoding)
          .build()

     */
    protected String[] parsePath(final String path) {
        if (StringUtil.isNotEmpty(path)) {
            final String[] values = path.split("/", 2);
            if (values.length == 2) {
                return values;
            }
            if (values.length == 1 && StringUtil.isNotEmpty(values[0])) {
                return new String[] { values[0], StringUtil.EMPTY };
            }
        }

     */
    public static PathInfo convertToItem(final String id) {
        final String value = decodeId(id);
        final String[] values = split(value, "/").get(stream -> stream.filter(StringUtil::isNotEmpty).toArray(n -> new String[n]));
        if (values.length == 0) {
            // invalid?
            return new PathInfo(StringUtil.EMPTY, StringUtil.EMPTY);
        }
        if (values.length == 1) {

    URL url = makeJarUrlWithName("To test unescaped spaces in jar file name.jar");
    URLClassLoader classloader = new URLClassLoader(new URL[] {url}, null);
    assertThat(ClassPath.from(classloader).getTopLevelClasses()).isNotEmpty();
  }

  @AndroidIncompatible // ClassPath is documented as not supporting Android

  public void testScan_classPathCycle() throws IOException {

        final CurlRequest curlRequest = ComponentUtil.getCurlHelper().request(httpMethod, path);

        final String contentType = request.getHeader("Content-Type");
        if (StringUtil.isNotEmpty(contentType)) {
            curlRequest.header("Content-Type", contentType);
        }

        request.getParameterMap().entrySet().stream().forEach(entry -> {
            if (entry.getValue().length > 1) {