/**
 * Returns this as a non-negative integer, or 0 if it is negative, or [Int.MAX_VALUE] if it is too
 * large, or [defaultValue] if it cannot be parsed.
 */
internal fun String?.toNonNegativeInt(defaultValue: Int): Int {
  try {
    val value = this?.toLong() ?: return defaultValue
    return when {
      value > Int.MAX_VALUE -> Int.MAX_VALUE
      value < 0 -> 0
      else -> value.toInt()
    }

        this.certificatePinner = certificatePinner
      }

    /**
     * Sets the default timeout for complete calls. A value of 0 means no timeout, otherwise values
     * must be between 1 and [Integer.MAX_VALUE] when converted to milliseconds.
     *
     * The call timeout spans the entire call: resolving DNS, connecting, writing the request body,

          .isAtLeast(0);
    }

    // and some crazy values (this used to be capped to Integer.MAX_VALUE, now it can go bigger
    assertEquals(3327428144502L, BloomFilter.optimalNumOfBits(Integer.MAX_VALUE, Double.MIN_VALUE));
    IllegalArgumentException expected =
        assertThrows(
            IllegalArgumentException.class,
            () -> {

  fun timeDurationTruncatedToMaxValue() {
    val cacheControl =
      CacheControl
        .Builder()
        .maxAge(365 * 100, TimeUnit.DAYS) // Longer than Integer.MAX_VALUE seconds.
        .build()
    assertThat(cacheControl.maxAgeSeconds).isEqualTo(Int.MAX_VALUE)
  }

  @Test
  @Throws(Exception::class)
  fun secondsMustBeNonNegative() {
    val builder = CacheControl.Builder()

    assertThat(readFully(reader)).isEqualTo(string);
    assertFullyRead(reader);

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

    // reset to the mark and then read the rest
    reader.reset();

    return (long) z;
  }

  private static final double MIN_LONG_AS_DOUBLE = -0x1p63;
  /*
   * We cannot store Long.MAX_VALUE as a double without losing precision. Instead, we store
   * Long.MAX_VALUE + 1 == -Long.MIN_VALUE, and then offset all comparisons by 1.
   */
  private static final double MAX_LONG_AS_DOUBLE_PLUS_ONE = 0x1p63;

  /**

   *     {@code value} cast to {@code byte} otherwise
   */
  public static byte saturatedCast(long value) {
    if (value > toUnsignedInt(MAX_VALUE)) {
      return MAX_VALUE; // -1
    }
    if (value < 0) {
      return (byte) 0;
    }
    return (byte) value;
  }

  /**

        assertEquals(maxAccessCount, webFsIndexHelper.maxAccessCount);
    }

    @Test
    public void test_setMaxAccessCount_withMaxValue() {
        webFsIndexHelper.setMaxAccessCount(Long.MAX_VALUE);
        assertEquals(Long.MAX_VALUE, webFsIndexHelper.maxAccessCount);
    }

    @Test
    public void test_setMaxAccessCount_withZero() {
        webFsIndexHelper.setMaxAccessCount(0L);

  /*
   * Cache the size for efficiency. Using a long lets us avoid the need for
   * overflow checking and ensures that size() will function correctly even if
   * the multiset had once been larger than Integer.MAX_VALUE.
   */
  private transient long size;

  /** Standard constructor. */
  protected AbstractMapBasedMultiset(Map<E, Count> backingMap) {
    checkArgument(backingMap.isEmpty());
    this.backingMap = backingMap;

  public void testIndexOf_specialValues() {
    ImmutableDoubleArray iia =
        ImmutableDoubleArray.of(-0.0, 0.0, Double.MAX_VALUE, Double.POSITIVE_INFINITY, Double.NaN);
    assertThat(iia.indexOf(-0.0)).isEqualTo(0);
    assertThat(iia.indexOf(0.0)).isEqualTo(1);
    assertThat(iia.indexOf(Double.MAX_VALUE)).isEqualTo(2);
    assertThat(iia.indexOf(Double.POSITIVE_INFINITY)).isEqualTo(3);
    assertThat(iia.indexOf(Double.NaN)).isEqualTo(4);