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

    assertThat(CacheTesting.accessQueueSize(cache)).isEqualTo(MAX_SIZE);
    assertThat(cache.size()).isEqualTo(MAX_SIZE);
    CacheTesting.processPendingNotifications(cache);

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

    assertThat(CacheTesting.accessQueueSize(cache)).isEqualTo(MAX_SIZE);
    assertThat(cache.size()).isEqualTo(MAX_SIZE);
    CacheTesting.processPendingNotifications(cache);

        value, but a deterministic sequence. This change will make the
        initialize behavior align between v1 and v2.

*   `tf.lite`:

    *   Rename fields `SignatureDef` table in schema to maximize the parity with
        TF SavedModel's Signature concept.
    *   Deprecate Makefile builds. Makefile users need to migrate their builds
        to CMake or Bazel. Please refer to the

  @VisibleForTesting final int maxSize;

  private EvictingQueue(int maxSize) {
    checkArgument(maxSize >= 0, "maxSize (%s) must >= 0", maxSize);
    this.delegate = new ArrayDeque<>(maxSize);
    this.maxSize = maxSize;
  }

  /**
   * Creates and returns a new evicting queue that will hold up to {@code maxSize} elements.
   *

  @VisibleForTesting final int maxSize;

  private EvictingQueue(int maxSize) {
    checkArgument(maxSize >= 0, "maxSize (%s) must >= 0", maxSize);
    this.delegate = new ArrayDeque<>(maxSize);
    this.maxSize = maxSize;
  }

  /**
   * Creates and returns a new evicting queue that will hold up to {@code maxSize} elements.
   *

 * small portion of these would be in use.
 *
 * <p>Prior to this class, one might be tempted to use {@code Map<K, Lock>}, where {@code K}
 * represents the task. This maximizes concurrency by having each unique key mapped to a unique
 * lock, but also maximizes memory footprint. On the other extreme, one could use a single lock for
 * all tasks, which minimizes memory footprint but also minimizes concurrency. Instead of choosing

        this.createdTime = value;
    }

    public Integer getMaxSize() {
        checkSpecifiedProperty("maxSize");
        return maxSize;
    }

    public void setMaxSize(Integer value) {
        registerModifiedProperty("maxSize");
        this.maxSize = value;
    }

    public String getQuery() {
        checkSpecifiedProperty("query");
        return convertEmptyToNull(query);

        } finally {
            out.close();
        }

        // Set maxSize larger than file size
        final byte[] bytes = FileUtil.readBytes(file, 1024);
        assertThat(new String(bytes, "UTF-8"), is(content));
    }

    /**
     * Test readBytes with custom maxSize - file exceeds limit
     *
     * @throws Exception
     */
    @Test(expected = IORuntimeException.class)

        }

        int maxSize = isSmb1 ? MAX_SMB1_MESSAGE_SIZE : MAX_SMB_MESSAGE_SIZE;
        if (size > maxSize) {
            failedValidations.incrementAndGet();
            log.warn("Message size exceeds maximum: {} > {}", size, maxSize);
            throw new SmbException("Message size exceeds maximum: " + size + " > " + maxSize);
        }
    }

    /**

    }

    public void setMaxSize_Equal(Integer maxSize) {
        setMaxSize_Term(maxSize, null);
    }

    public void setMaxSize_Equal(Integer maxSize, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setMaxSize_Term(maxSize, opLambda);
    }

    public void setMaxSize_Term(Integer maxSize) {
        setMaxSize_Term(maxSize, null);
    }