int maxSize,
      Receiver<ReferenceEntry<Integer, Integer>> operation) {
    checkNotNull(operation);
    if (hasLocalCache(cache)) {
      warmUp(cache, 0, 2 * maxSize);

      LocalCache<Integer, Integer> cchm = toLocalCache(cache);
      Segment<?, ?> segment = cchm.segments[0];
      drainRecencyQueue(segment);
      assertEquals(maxSize, accessQueueSize(cache));

    private List<Integer> pageNumberList;

    private int pageSize;

    private int currentPageNumber;

    public String id;

    public String term;

    public String query;

    public String maxSize;

    public String boost;

    public String createdBy;

    public String createdTime;

    public String versionNo;

    public void clear() {
        allRecordCount = 0;

    original.add("one");
    original.add("two");
    original.add("three");

    EvictingQueue<String> copy = SerializableTester.reserialize(original);
    assertEquals(copy.maxSize, original.maxSize);
    assertEquals("one", copy.remove());
    assertEquals("two", copy.remove());
    assertEquals("three", copy.remove());
    assertTrue(copy.isEmpty());
  }

      int maxSize,
      Receiver<ReferenceEntry<Integer, Integer>> operation) {
    checkNotNull(operation);
    if (hasLocalCache(cache)) {
      warmUp(cache, 0, 2 * maxSize);

      LocalCache<Integer, Integer> cchm = toLocalCache(cache);
      Segment<?, ?> segment = cchm.segments[0];
      drainRecencyQueue(segment);
      assertEquals(maxSize, accessQueueSize(cache));

            new MessageDigestHashFunction(algorithmName, bytes, algorithmName).hashBytes(input));
      }
      try {
        int maxSize = digest.getDigestLength();
        new MessageDigestHashFunction(algorithmName, maxSize + 1, algorithmName);
        fail();
      } catch (IllegalArgumentException expected) {
      }
    } catch (NoSuchAlgorithmException nsae) {

        }
        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.
      }
    }

  /*

            "type" : "float"
          },
          "createdBy" : {
            "type" : "keyword"
          },
          "createdTime" : {
            "type" : "long"
          },
          "maxSize" : {
            "type" : "integer"
          },
          "query" : {
            "type" : "keyword"
          },
          "term" : {
            "type" : "keyword"
          },
          "updatedBy" : {

    original.add("one");
    original.add("two");
    original.add("three");

    EvictingQueue<String> copy = SerializableTester.reserialize(original);
    assertEquals(copy.maxSize, original.maxSize);
    assertEquals("one", copy.remove());
    assertEquals("two", copy.remove());
    assertEquals("three", copy.remove());
    assertTrue(copy.isEmpty());
  }

                                    <tr>
                                        <th><la:message key="labels.key_match_size"/></th>
                                        <td>${f:h(maxSize)}<la:hidden property="maxSize"/></td>
                                    </tr>
                                    <tr>
                                        <th><la:message key="labels.key_match_boost"/></th>

class CacheResponse(cacheDirectory: File) {
  private val client: OkHttpClient =
    OkHttpClient.Builder()
      .cache(
        Cache(
          directory = cacheDirectory,
          // 1 MiB.
          maxSize = 10L * 1024L * 1024L,
        ),
      )
      .build()

  fun run() {
    val request =
      Request.Builder()
        .url("http://publicobject.com/helloworld.txt")
        .build()