@SuppressWarnings("unchecked")
            final List<String> existingFields = (List<String>) kindsObj;
            concatValues(existingFields, Stream.of(kinds).map(Kind::toString).toArray(count -> new String[count]));
            map.put(FieldNames.KINDS, existingFields);
        } else {
            map.put(FieldNames.KINDS, Stream.of(kinds).map(Kind::toString).toArray());
        }

     * 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;

      return File.createTempFile(
          /* prefix= */ prefix,
          /* suffix= */ null,
          /* directory= */ null /* defaults to java.io.tmpdir */);
    }

    /** Maximum loop count when creating temp directories. */
    private static final int TEMP_DIR_ATTEMPTS = 10000;
  }

  private static final class ThrowingCreator extends TempFileCreator {
    private static final String MESSAGE =

     * block, and reference field assignment is atomic, this may save reacquiring the lock when
     * another thread or the worker task has cleared the count and set the state.
     *
     * <p>When {@link #executor} is a directExecutor(), the value written to
     * {@code workerRunningState} will be available synchronously, and behaviour will be
     * deterministic.
     */

     * block, and reference field assignment is atomic, this may save reacquiring the lock when
     * another thread or the worker task has cleared the count and set the state.
     *
     * <p>When {@link #executor} is a directExecutor(), the value written to
     * {@code workerRunningState} will be available synchronously, and behaviour will be
     * deterministic.
     */

        regA(builder);
        return builder;
    }

    protected ValueCountAggregationBuilder regCountA(String name, String field) {
        ValueCountAggregationBuilder builder = AggregationBuilders.count(name).field(field);
        regA(builder);
        return builder;
    }

    protected TermsAggregationBuilder regTermsA(String name, String field) {

        RuntimeException ex = assertThrows(RuntimeException.class, trace::release);
        assertTrue(ex.getMessage() != null && ex.getMessage().contains("Usage count dropped below zero"));
    }

    @Test
    @DisplayName("getTreeId(): no tree returns -1")
    void getTreeId_noTree_returnsMinusOne() {
        // Arrange
        CIFSContext ctx = mock(CIFSContext.class);

   * methods: {@link SortedMultiset#clear}, {@link SortedMultiset#comparator}, {@link
   * SortedMultiset#contains}, {@link SortedMultiset#containsAll}, {@link SortedMultiset#count},
   * {@link SortedMultiset#firstEntry} {@link SortedMultiset#headMultiset}, {@link
   * SortedMultiset#isEmpty}, {@link SortedMultiset#lastEntry}, {@link SortedMultiset#subMultiset},

                .setSize(sizeForUpdate)
                .setPreference(Constants.SEARCH_PREFERENCE_LOCAL)).execute().actionGet(fessConfig.getIndexScrollSearchTimeout());

        int count = 0;
        String scrollId = response.getScrollId();
        try {
            while (scrollId != null) {
                final SearchHits searchHits = response.getHits();

        // Test decrement below zero
        assertEquals(-1L, crawlerContext.decrementAndGetAccessCount());
        assertEquals(-1L, crawlerContext.getAccessCount());
    }

    /**
     * Test concurrent access count operations
     */
    public void test_accessCount_concurrent() throws Exception {
        final int threadCount = 100;
        final int operationsPerThread = 1000;