requireNonNull(thread);
        if (nameFormat != null) {
          // requireNonNull is safe because we create `count` if (and only if) we have a nameFormat.
          thread.setName(format(nameFormat, requireNonNull(count).getAndIncrement()));
        }
        if (daemon != null) {
          thread.setDaemon(daemon);
        }
        if (priority != null) {

indexer.unprocessed.document.size=1000
# Whether to enable click count tracking in the indexer.
indexer.click.count.enabled=true
# Whether to enable favorite count tracking in the indexer.
indexer.favorite.count.enabled=true
# Commit margin time (ms) for webfs in the indexer.
indexer.webfs.commit.margin.time=5000
# Maximum number of empty lists for webfs in the indexer.
indexer.webfs.max.empty.list.count=3600
# Update interval (ms) for webfs in the indexer.

    AtomicInteger count = new AtomicInteger();
    Exception e = new IllegalStateException("exception to trigger failure on first load()");
    CacheLoader<Integer, String> failOnceFunction =
        new CacheLoader<Integer, String>() {

          @Override
          public String load(Integer key) throws Exception {
            if (count.getAndIncrement() == 0) {
              throw e;

    // Context type
    /** Context ID for RDMA transform capabilities */
    public static final int CONTEXT_ID = Smb2Constants.SMB2_RDMA_TRANSFORM_CAPABILITIES;

    // Transform count and reserved fields
    private int transformCount = 1; // Number of transforms (always 1 for SMBDirect)
    private int reserved1 = 0;
    private int reserved2 = 0;

    // SMB_DIRECT_RDMA_TRANSFORM_V1

    }
    var count = 0
    while (!data.exhausted()) {
      assertFailsWith<ProtocolException> {
        clientReader.processNextFrame()
      }.also { expected ->
        assertThat(expected.message!!)
          .matches(Regex("Code \\d+ is reserved and may not be used."))
      }
      count++
    }
    assertThat(count).isEqualTo(1988)
  }

            fileCache.put(path, new WeakReference<>(file));
        }
    }

    /**
     * Evict oldest leases based on LRU
     *
     * @param count number of leases to evict
     */
    private void evictOldestLeases(int count) {
        if (count <= 0 || leases.isEmpty()) {
            return;
        }

        // Find oldest leases by last access time
        leases.entrySet()

    if (entries.size() >= 1) {
      a = Multisets.immutableEntry(entries.get(0), sortedMultiset.count(entries.get(0)));
      if (entries.size() >= 3) {
        b = Multisets.immutableEntry(entries.get(1), sortedMultiset.count(entries.get(1)));
        c = Multisets.immutableEntry(entries.get(2), sortedMultiset.count(entries.get(2)));
      }
    }
  }

  boolean tooHigh(@ParametricNullness T t) {
    if (!hasUpperBound()) {
      return false;
    }
    // The cast is safe because of the hasUpperBound() check.
    T ubound = uncheckedCastNullableTToT(getUpperEndpoint());
    int cmp = comparator.compare(t, ubound);
    return cmp > 0 | (cmp == 0 & getUpperBoundType() == OPEN);
  }

  boolean contains(@ParametricNullness T t) {
    return !tooLow(t) && !tooHigh(t);
  }

        }

        if (states.count(RUNNING) == numberOfServices) {
          // This means that the manager is currently healthy. N.B. If other threads call isHealthy
          // they are not guaranteed to get 'true', because any service could fail right now.
          enqueueHealthyEvent();
        } else if (states.count(TERMINATED) + states.count(FAILED) == numberOfServices) {
          enqueueStoppedEvent();

        }

        if (states.count(RUNNING) == numberOfServices) {
          // This means that the manager is currently healthy. N.B. If other threads call isHealthy
          // they are not guaranteed to get 'true', because any service could fail right now.
          enqueueHealthyEvent();
        } else if (states.count(TERMINATED) + states.count(FAILED) == numberOfServices) {
          enqueueStoppedEvent();