// implementation, it _may_ require iteration over the entire collection (e.g., a
    // FilteredCollection), which we want to avoid.
    if (values instanceof List || values instanceof ImmutableCollection) {
      return uniqueIndex(
          values.iterator(),
          keyFunction,
          ImmutableMap.builderWithExpectedSize(((Collection<?>) values).size()));
    }

    // implementation, it _may_ require iteration over the entire collection (e.g., a
    // FilteredCollection), which we want to avoid.
    if (values instanceof List || values instanceof ImmutableCollection) {
      return uniqueIndex(
          values.iterator(),
          keyFunction,
          ImmutableMap.builderWithExpectedSize(((Collection<?>) values).size()));
    }

                request.path = dunc;
                request.flags2 |= SmbConstants.FLAGS2_RESOLVE_PATHS_IN_DFS;
            }
        } else if (tree.inDomainDfs && !(request instanceof NtTransQuerySecurityDesc) && !(request instanceof SmbComClose)
                && !(request instanceof SmbComFindClose2)) {
            throw new SmbException(NtStatus.NT_STATUS_NOT_FOUND, false);
        } else if (request != null) {

            } else if (info instanceof FileStandardInfo) {
                this.size = info.getSize();
                this.sizeExpiration = currentTime + cacheTimeout;
            }

            // Optimization: Try to get both basic and standard info efficiently
            if (info instanceof FileBasicInfo && this.sizeExpiration < currentTime) {
                try {

  public void testValues() {
    LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder());
    map.put("foo", "bar");
    map.put("baz", "bar");
    map.put("quux", "quux");
    assertThat(map.values() instanceof Set).isFalse();
    assertThat(map.values().removeAll(ImmutableSet.of("bar"))).isTrue();
    assertThat(map).hasSize(1);
  }

  public void testCopyEntry_computing() {

  public void testValues() {
    LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder());
    map.put("foo", "bar");
    map.put("baz", "bar");
    map.put("quux", "quux");
    assertThat(map.values() instanceof Set).isFalse();
    assertThat(map.values().removeAll(ImmutableSet.of("bar"))).isTrue();
    assertThat(map).hasSize(1);
  }

  public void testComputeIfAbsent_removalListener() {

            }
            final Object trackTotalHitsValue = fessConfig.getQueryTrackTotalHitsValue();
            if (trackTotalHitsValue instanceof Boolean) {
                searchRequestBuilder.setTrackTotalHits((Boolean) trackTotalHitsValue);
            } else if (trackTotalHitsValue instanceof Number) {
                searchRequestBuilder.setTrackTotalHitsUpTo(((Number) trackTotalHitsValue).intValue());
            }
        }

        return lockedGetOrLoad(key, hash, loader);
      } catch (ExecutionException ee) {
        Throwable cause = ee.getCause();
        if (cause instanceof Error) {
          throw new ExecutionError((Error) cause);
        } else if (cause instanceof RuntimeException) {
          throw new UncheckedExecutionException(cause);
        }
        throw ee;
      } finally {
        postReadCleanup();

        return lockedGetOrLoad(key, hash, loader);
      } catch (ExecutionException ee) {
        Throwable cause = ee.getCause();
        if (cause instanceof Error) {
          throw new ExecutionError((Error) cause);
        } else if (cause instanceof RuntimeException) {
          throw new UncheckedExecutionException(cause);
        }
        throw ee;
      } finally {
        postReadCleanup();

        if (src.isEmpty()) {
            return tgt;
        }

        MergingList<T> list;
        if (tgt instanceof MergingList) {
            list = (MergingList<T>) tgt;
        } else {
            list = new MergingList<>(computer, src.size() + tgt.size());
            list.mergeAll(tgt, new SourceDominant<T>(true));