}

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddTooMany() {
    getMultiset().add(e3(), Integer.MAX_VALUE);
    assertThrows(IllegalArgumentException.class, () -> getMultiset().add(e3()));
    assertEquals(Integer.MAX_VALUE, getMultiset().count(e3()));
    assertEquals(Integer.MAX_VALUE, getMultiset().size());
  }

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddAll_emptySet() {

  @Test
  fun bytesThrowsMoreThanIntMaxValue() {
    val body: ResponseBody =
      object : ResponseBody() {
        override fun contentType(): MediaType? = null

        override fun contentLength(): Long = Int.MAX_VALUE + 1L

        override fun source(): BufferedSource = throw AssertionError()
      }
    assertFailsWith<IOException> {
      body.bytes()
    }.also { expected ->
      assertThat(expected.message).isEqualTo(

   * Duplicated from LongMath.
   * binomial(biggestBinomials[k], k) fits in a long, but not
   * binomial(biggestBinomials[k] + 1, k).
   */
  static final int[] biggestBinomials = {
    Integer.MAX_VALUE,
    Integer.MAX_VALUE,
    Integer.MAX_VALUE,
    3810779,
    121977,
    16175,
    4337,
    1733,
    887,
    534,
    361,
    265,
    206,
    169,
    143,
    125,
    111,
    101,

    checkPositionIndexes(fromIndex, toIndex, array.length);
    for (int i = fromIndex; i < toIndex; i++) {
      array[i] ^= Long.MAX_VALUE;
    }
    Arrays.sort(array, fromIndex, toIndex);
    for (int i = fromIndex; i < toIndex; i++) {
      array[i] ^= Long.MAX_VALUE;
    }
  }

  /**
   * Returns dividend / divisor, where the dividend and divisor are treated as unsigned 64-bit
   * quantities.

  /**
   * Returns the number of nanoseconds of the given duration without throwing or overflowing.
   *
   * <p>Instead of throwing {@link ArithmeticException}, this method silently saturates to either
   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing
   * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair.
   */
  static long toNanosSaturated(Duration duration) {

    assertEquals(string, readFully(reader));
    assertFullyRead(reader);

    // reset, skip, mark, then read the rest
    reader.reset();
    assertEquals(5, reader.skip(5));
    reader.mark(Integer.MAX_VALUE);
    assertEquals(string.substring(5), readFully(reader));
    assertFullyRead(reader);

    // reset to the mark and then read the rest
    reader.reset();
    assertEquals(string.substring(5), readFully(reader));

  /**
   * Returns the number of nanoseconds of the given duration without throwing or overflowing.
   *
   * <p>Instead of throwing {@link ArithmeticException}, this method silently saturates to either
   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing
   * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair.
   */

        long largeValue = Long.MAX_VALUE - 1000;

        docList.addContentSize(largeValue);
        assertEquals(largeValue, docList.getContentSize());

        docList.addProcessingTime(largeValue);
        assertEquals(largeValue, docList.getProcessingTime());

        docList.addContentSize(1000);
        assertEquals(Long.MAX_VALUE, docList.getContentSize());

    assertThat(readAscii(gunzippedIn, Int.MAX_VALUE)).isEqualTo("one (gzipped)")
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)
    val response2 =
      getResponse(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )
    assertThat(readAscii(response2.body.byteStream(), Int.MAX_VALUE)).isEqualTo("two (identity)")

                Properties props = new Properties();
                props.setProperty(FessEnv.TIME_ADJUST_TIME_MILLIS, String.valueOf(Long.MAX_VALUE));
                return props;
            }
        };
        assertEquals(Long.valueOf(Long.MAX_VALUE), maxEnv.getTimeAdjustTimeMillisAsLong());
    }

    // Test prepareGeneratedDefaultMap
    public void xtest_prepareGeneratedDefaultMap() {