* infinite {@code double} values are considered infinitely far away. For example, 2^2000 is not
   * representable as a double, but {@code roundToDouble(BigDecimal.valueOf(2).pow(2000), HALF_UP)}
   * will return {@code Double.MAX_VALUE}, not {@code Double.POSITIVE_INFINITY}.
   *
   * <p>For the case of {@link RoundingMode#HALF_EVEN}, this implementation uses the IEEE 754

    }
  }

  /**
   * Always returns {@code Integer.MAX_VALUE} because a {@code MonitorBasedPriorityBlockingQueue} is
   * not capacity constrained.
   *
   * @return {@code Integer.MAX_VALUE}
   */
  @CanIgnoreReturnValue // pushed down from class to method
  @Override
  public int remainingCapacity() {
    return Integer.MAX_VALUE;
  }

  /**

  }

  public void testGreaterThan() {
    Range<Integer> range = Range.greaterThan(5);
    assertFalse(range.contains(5));
    assertTrue(range.contains(6));
    assertTrue(range.contains(Integer.MAX_VALUE));
    assertTrue(range.hasLowerBound());
    assertEquals(5, (int) range.lowerEndpoint());
    assertEquals(OPEN, range.lowerBoundType());
    assertUnboundedAbove(range);
    assertFalse(range.isEmpty());

        }

    val b2: Int
      get() = absoluteDelta shr 7 and 0x7f

    val b3: Int
      get() = absoluteDelta and 0x7f

    companion object {
      const val MAX_VALUE = 0x3FFFF
    }
  }

  data class External(
    override val rangeStart: Int,
    val mappedTo: ByteString,
  ) : MappedRange

  private static final char[] ARRAY234 = {(char) 2, (char) 3, (char) 4};

  private static final char LEAST = Character.MIN_VALUE;
  private static final char GREATEST = Character.MAX_VALUE;

  private static final char[] VALUES = {LEAST, 'a', '\u00e0', '\udcaa', GREATEST};

  // We need to test that our method behaves like the JDK method.
  @SuppressWarnings("InlineMeInliner")

   * @return the same value cast to {@code char} if it is in the range of the {@code char} type,
   *     {@link Character#MAX_VALUE} if it is too large, or {@link Character#MIN_VALUE} if it is too
   *     small
   */
  public static char saturatedCast(long value) {
    if (value > Character.MAX_VALUE) {
      return Character.MAX_VALUE;
    }
    if (value < Character.MIN_VALUE) {
      return Character.MIN_VALUE;
    }

    }
    println()
    val sortedSuites =
      ianaSuites.suites.sortedBy { ianaSuite ->
        val index = orderBy.indexOfFirst { it.matches(ianaSuite) }
        if (index == -1) Integer.MAX_VALUE else index
      }
    for (suiteId in sortedSuites) {
      print(suiteId.name)
      for (client in clients) {
        print("\t")
        val index = client.enabled.indexOfFirst { it.matches(suiteId) }

        // Test very large timeout
        generator.setCommandTimeout(Long.MAX_VALUE);
        assertTrue(true);

        // Test destroy timeout
        generator.setCommandDestroyTimeout(0L);
        assertTrue(true);

        generator.setCommandDestroyTimeout(-1L);
        assertTrue(true);

        generator.setCommandDestroyTimeout(Long.MAX_VALUE);
        assertTrue(true);
    }

    Iterables.addAll(queue, elements);
    return queue;
  }

  // LinkedBlockingDeque

  /**
   * Creates an empty {@code LinkedBlockingDeque} with a capacity of {@link Integer#MAX_VALUE}.
   *
   * @since 12.0
   */
  @J2ktIncompatible
  @GwtIncompatible // LinkedBlockingDeque
  public static <E> LinkedBlockingDeque<E> newLinkedBlockingDeque() {
    return new LinkedBlockingDeque<>();

   * infinite {@code double} values are considered infinitely far away. For example, 2^2000 is not
   * representable as a double, but {@code roundToDouble(BigDecimal.valueOf(2).pow(2000), HALF_UP)}
   * will return {@code Double.MAX_VALUE}, not {@code Double.POSITIVE_INFINITY}.
   *
   * <p>For the case of {@link RoundingMode#HALF_EVEN}, this implementation uses the IEEE 754