private File docRoot;

    private Server server;

    private boolean tempDocRoot = false;

    public CrawlerWebServer(final int port) {
        this(port, createDocRoot(3));
        tempDocRoot = true;
    }

    public CrawlerWebServer(final int port, final File docRoot) {
        this.port = port;
        this.docRoot = docRoot;

        server = new Server(port);

        ArtifactResolutionRequest request = new ArtifactResolutionRequest()
                .setResolveRoot(false)
                .setResolveTransitively(true)
                .setCollectionFilter(collectionScopeFilter)
                .setResolutionFilter(resolutionScopeFilter)
                .setLocalRepository(session.getLocalRepository())

        byte[] machineId = new byte[32];
        mockRandom.nextBytes(machineId);

        lenient().when(mockConfig.getDefaultDomain()).thenReturn("TESTDOMAIN");
        lenient().when(mockConfig.isUseUnicode()).thenReturn(true);
        lenient().when(mockConfig.getOemEncoding()).thenReturn("UTF-8");
        lenient().when(mockConfig.getRandom()).thenReturn(mockRandom);

		// Init and run test on Erasure backend.
		{serverType: "Erasure", signer: signerV4},
		// Init and run test on ErasureSet backend.
		{serverType: "ErasureSet", signer: signerV4},
	}
	testCases := []*TestSuiteIAM{}
	for _, bt := range baseTestCases {
		testCases = append(testCases,
			newTestSuiteIAM(bt, false),
			newTestSuiteIAM(bt, true),
		)
	}
	return testCases

            } catch (final Exception e) {}
        }
    }

    @Override
    public String getIndexingTarget(final String input) {
        // always return true
        return Constants.TRUE;
    }

    @Override
    public String getConfigId() {
        return ConfigType.DATA.getConfigId(getId());
    }

    public Map<String, String> getHandlerParameterMap() {

                    return "^FESS_ENV_.*";

                // Crawler hotthread properties - actual keys
                case "crawler.hotthread.ignore_idle_threads":
                    return "true";
                case "crawler.hotthread.interval":
                    return "500ms";
                case "crawler.hotthread.snapshots":
                    return "10";

	w.reuseBlocks = true // We are not sharing results, so reuse buffers.
	defer w.Close()
	out, err := w.stream()
	if err != nil {
		return err
	}
	defer xioutil.SafeClose(out)
	var objsReturned int

	objReturned := func(metadata []byte) {
		if opts.Limit <= 0 {
			return
		}
		if m, _, _ := isIndexedMetaV2(metadata); m != nil && !m.AllHidden(true) {
			objsReturned++
		}
	}

   *
   * @return this
   * @throws IllegalStateException if the service is not {@link State#NEW}
   * @since 15.0
   */
  @CanIgnoreReturnValue
  Service startAsync();

  /** Returns {@code true} if this service is {@linkplain State#RUNNING running}. */
  boolean isRunning();

  /** Returns the lifecycle state of the service. */
  State state();

  /**

                    .boost(fessConfig.getQueryBoostFuzzyTitleAsDecimal().floatValue())
                    .prefixLength(fessConfig.getQueryBoostFuzzyTitlePrefixLengthAsInteger())
                    .transpositions(Constants.TRUE.equalsIgnoreCase(fessConfig.getQueryBoostFuzzyTitleTranspositions()))
                    .fuzziness(Fuzziness.build(fessConfig.getQueryBoostFuzzyTitleFuzziness()))

     *
     * @param path the path to check
     * @return true if the path is a web crawling path, false otherwise
     */
    protected boolean isWebCrawlingPath(final String path) {
        if (path.startsWith("http:") || path.startsWith("https:")) {
            return true;
        }

        return false;
    }

    /**