CacheBuilder.newBuilder()
            .maximumSize(MAX_SIZE)
            .removalListener(removalListener)
            .build(loader);
    for (int i = 0; i < 2 * MAX_SIZE; i++) {
      cache.getUnchecked(i);
      assertTrue(cache.size() <= MAX_SIZE);
    }

    assertEquals(MAX_SIZE, CacheTesting.accessQueueSize(cache));
    assertEquals(MAX_SIZE, cache.size());
    CacheTesting.processPendingNotifications(cache);

    Preconditions.checkArgument(expectedSize >= 0, "Expected size must be >= 0");

    // Save expectedSize for use in allocArrays()
    this.metadata = Ints.constrainToRange(expectedSize, 1, CompactHashing.MAX_SIZE);
  }

  /** Returns whether arrays need to be allocated. */
  boolean needsAllocArrays() {
    return table == null;
  }

  /** Handle lazy allocation of arrays. */
  @CanIgnoreReturnValue

    Preconditions.checkArgument(expectedSize >= 0, "Expected size must be >= 0");

    // Save expectedSize for use in allocArrays()
    this.metadata = Ints.constrainToRange(expectedSize, 1, CompactHashing.MAX_SIZE);
  }

  /** Returns whether arrays need to be allocated. */
  boolean needsAllocArrays() {
    return table == null;
  }

  /** Handle lazy allocation of arrays. */
  @CanIgnoreReturnValue

    Preconditions.checkArgument(expectedSize >= 0, "Expected size must be >= 0");

    // Save expectedSize for use in allocArrays()
    this.metadata = Ints.constrainToRange(expectedSize, 1, CompactHashing.MAX_SIZE);
  }

  /** Returns whether arrays need to be allocated. */
  boolean needsAllocArrays() {
    return table == null;
  }

  /** Handle lazy allocation of arrays. */
  @CanIgnoreReturnValue

            false, false, "Long", 0, 0, null, null, false, null, null, null, null, null, false);
    protected final ColumnInfo _columnMaxSize = cci("maxSize", "maxSize", null, null, Integer.class, "maxSize", null, false, false, false,
            "Integer", 0, 0, null, null, false, null, null, null, null, null, false);

        }
    }

    static class TestSubSearcher extends RankFusionSearcher {

        private int mainSize;
        private int inSize;
        private int outSize;

        TestSubSearcher(int mainSize, int inSize, int outSize) {
            this.mainSize = mainSize;
            this.inSize = inSize;
            this.outSize = outSize;
        }

        @Override

        }
        return super.sink(file, mustCreate)
      }
    }

  /** The maximum number of bytes that this cache should use to store its data. */
  @get:Synchronized @set:Synchronized
  var maxSize: Long = maxSize
    set(value) {
      field = value
      if (initialized) {
        cleanupQueue.schedule(cleanupTask) // Trim the existing store if necessary.
      }
    }

  /*

  constructor(directory: File, maxSize: Long) : this(
    FileSystem.SYSTEM,
    directory.toOkioPath(),
    maxSize,
  )

  internal val cache =
    DiskLruCache(
      fileSystem = fileSystem,
      directory = directory,
      appVersion = VERSION,
      valueCount = ENTRY_COUNT,
      maxSize = maxSize,
      taskRunner = taskRunner,
    )

  }

  public void testUnion_maxSize_saturated() {
    assertThat(union(setSize(Integer.MAX_VALUE), setSize(1)).maxSize())
        .isEqualTo(Integer.MAX_VALUE);
    assertThat(union(setSize(1), setSize(Integer.MAX_VALUE)).maxSize())
        .isEqualTo(Integer.MAX_VALUE);
  }

  public void testIntersection_minSize() {
    assertMinSize(intersection(emptySet(), emptySet()), 0);

   *
   * <p><b>{@code Stream} equivalent:</b> {@link Stream#limit} (same).
   *
   * @param maxSize the maximum number of elements in the returned fluent iterable
   * @throws IllegalArgumentException if {@code size} is negative
   */
  public final FluentIterable<E> limit(int maxSize) {
    return from(Iterables.limit(getDelegate(), maxSize));
  }

  /**
   * Determines whether this fluent iterable is empty.
   *