final int windowSize = fessConfig.getRankFusionWindowSizeAsInteger();
        if (maxPageSize * 2 < windowSize) {
            logger.warn("rank.fusion.window_size is lower than paging.search.page.max.size. "
                    + "The window size should be 2x more than the page size. ({} * 2 <= {})", maxPageSize, windowSize);
            this.windowSize = 2 * maxPageSize;
        } else {
            this.windowSize = windowSize;
        }

            return builder.recordStats().build(identityLoader());
          }
        });
  }

  private CacheBuilderFactory cacheFactory() {
    // This is trickier than expected. We plan to put 15 values in each of these (WARMUP_MIN to
    // WARMUP_MAX), but the tests assume no values get evicted. Even with a maximumSize of 100, one

       * would be resurrected by virtue of us having a strong reference to it), we should pretty
       * much just shut down and make sure we don't keep it alive any longer than necessary.
       */
      return null;
    }
    try {
      return finalizableReferenceClass.getMethod("finalizeReferent");
    } catch (NoSuchMethodException e) {
      throw new AssertionError(e);
    }

    if "!MINOR!" LSS "8" (
      set META_SIZE=-XX:PermSize=64M -XX:MaxPermSize=256M
    )

    set MEM_OPTS=!META_SIZE!
 )

rem We use the value of the JAVA_OPTS environment variable if defined, rather than the config.
set _JAVA_OPTS=%JAVA_OPTS%
if "%_JAVA_OPTS%"=="" set _JAVA_OPTS=%CFG_OPTS%

set DEBUG_OPTS=

rem Loop through the arguments, building remaining args in args variable
set args=
:argsloop

   * identical in function to {@code toArray()}."
   *
   * <p>For maximum effect, the collection under test should be created from an element array of a
   * type other than {@code Object[]}.
   */
  public void testToArray_isPlainObjectArray() {
    Object[] array = collection.toArray();
    assertEquals(Object[].class, array.getClass());
  }

  public void testToArray_emptyArray() {

    return backingMap.get(element);
  }

  // Optional Operations - Modification Operations

  /**
   * {@inheritDoc}
   *
   * @throws IllegalArgumentException if the call would result in more than {@link
   *     Integer#MAX_VALUE} occurrences of {@code element} in this multiset.
   */
  @CanIgnoreReturnValue
  @Override
  public final int add(@ParametricNullness E element, int occurrences) {

    return (Collector) ONLY_ELEMENT;
  }

  /**
   * This atrocity is here to let us report several of the elements in the stream if there were more
   * than one, not just two.
   */
  private static final class ToOptionalState {
    static final int MAX_EXTRAS = 4;

    @CheckForNull Object element;
    List<Object> extras;

    ToOptionalState() {

    long signifFloor = twiceSignifFloor >> 1;
    signifFloor &= SIGNIFICAND_MASK; // remove the implied bit

    /*
     * We round up if either the fractional part of signif is strictly greater than 0.5 (which is
     * true if the 0.5 bit is set and any lower bit is set), or if the fractional part of signif is
     * >= 0.5 and signifFloor is odd (which is true if both the 0.5 bit and the 1 bit are set).
     */

          return UnmodifiableEntry.transformEntries(super.iterator());
        }

        @Override
        public Object[] toArray() {
          /*
           * standardToArray returns `@Nullable Object[]` rather than `Object[]` but only because it
           * can be used with collections that may contain null. This collection is a collection of
           * non-null Entry objects (Entry objects that might contain null values but are not

			trimLen:  2,
			expected: []int{1, 2, 3},
		},
		{
			name:     "Trim entire slice",
			input:    []int{1, 2, 3},
			trimLen:  3,
			expected: []int{},
		},
		{
			name:     "Trim length greater than slice length",
			input:    []int{1, 2, 3},
			trimLen:  5,
			expected: []int{},
		},
		{
			name:     "Zero trim length",
			input:    []int{1, 2, 3},
			trimLen:  0,
			expected: []int{1, 2, 3},