this.timeoutMillis = timeoutMillis;

        if (failureThreshold < 1) {
            throw new IllegalArgumentException("Failure threshold must be at least 1");
        }
        if (successThreshold < 1) {
            throw new IllegalArgumentException("Success threshold must be at least 1");
        }
        if (timeoutMillis < 0) {
            throw new IllegalArgumentException("Timeout must be non-negative");
        }

     */
    public void addExcludeWord(final String excludeWord) {
        excludeWords.add(excludeWord);
    }

    /**
     * Sets the query frequency threshold.
     * @param queryFreqThreshold The query frequency threshold.
     */
    public void setQueryFreqThreshold(final int queryFreqThreshold) {
        this.queryFreqThreshold = queryFreqThreshold;
    }

    @Override

    private final CrawlerContainer crawlerContainer;

    /** MIME type of the content */
    private String mimeType;

    /** Filename of the content */
    private String filename;

    /** Cache file size threshold in bytes */
    private int cacheFileSize = 1_000_000;

    /** Name of the extractor to use */
    private String extractorName = "tikaExtractor";

    /** Maximum content length allowed */

    }

    @Test
    public void test_TmpFileHasBeenDeletedAfterResponseWasClosed() throws Exception {
        // ## Arrange ##
        CurlRequest req = new MockCurlRequest(Curl.Method.POST, "http://dummy");
        req.threshold(0); // always create tmp file

        // ## Act ##
        long before = countTmpFiles();
        logger.info("Before request. Number of temp files: " + before);
        req.execute(res -> {

    checkState(cache.segments.length == 1);
    segment = cache.segments[0];
    checkState(segment.table.length() == capacity);
    for (int i = 0; i < segment.threshold; i++) {
      cache.put(new Object(), new Object());
    }
    checkState(segment.table.length() == capacity);
  }

  @SuppressWarnings("GuardedBy")
  @Benchmark
  int time(int reps) {
    int dummy = 0;

     */
    @Override
    public int getThreshold() {
        return 0;
    }

    /**
     * <b>Warning</b>: ignored.
     */
    @Override
    public void setThreshold(int threshold) {}

    /**
     * <b>Warning</b>: ignored (always return <code>null</code>).
     */
    @Override
    public Logger getChildLogger(String name) {
        return null;
    }

    @Override

     * Specified failure types will not be logged or counted as errors.
     */
    @Size(max = 1000)
    public String ignoreFailureType;

    /**
     * Threshold for failure count before stopping crawling of a URL.
     * Set to -1 to disable the threshold check.
     */
    @Required
    @Min(-1)
    @Max(10000)
    @ValidateTypeFailure
    public Integer failureCountThreshold;

    /**

        // Minimal sleep to ensure timestamp separation (reduced from 2000ms to 100ms total)
        Thread.sleep(50);
        ZonedDateTime threshold = ZonedDateTime.now();
        Thread.sleep(50);

        // Index new data after threshold
        document = new HashMap<>();
        document.put(field, "検索エンジン");
        suggester.indexer().indexFromDocument(new Map[] { document });

                            responseData.setResponseBody(file, false);
                            if (logger.isDebugEnabled()) {
                                logger.debug("File size exceeds cache threshold, using file reference: file={}, size={}, threshold={}",
                                        file.getAbsolutePath(), file.length(), maxCachedContentSize);
                            }
                        }
                    }

mapreduce.reduce.shuffle.input.buffer.percent=0.9 # Min % buffer in RAM
mapreduce.reduce.shuffle.merge.percent=0.9 # Minimum % merges in RAM
mapreduce.reduce.speculative=false # Disable speculation for reducing
mapreduce.task.io.sort.factor=999 # Threshold before writing to disk
mapreduce.task.sort.spill.percent=0.9 # Minimum % before spilling to disk
```