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

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

  private static final int LEAST = Integer.MIN_VALUE;
  private static final int GREATEST = Integer.MAX_VALUE;

  private static final int[] VALUES = {LEAST, (int) -1, (int) 0, (int) 1, GREATEST};

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

        when(config.getNotifyBufferSize()).thenReturn(Integer.MAX_VALUE);
        Smb2ChangeNotifyRequest req = new Smb2ChangeNotifyRequest(config, testFileId);

        // When
        byte[] buffer = new byte[512];
        req.writeBytesWireFormat(buffer, 0);

        // Then
        int readBufferSize = SMBUtil.readInt4(buffer, 4);
        assertEquals(Integer.MAX_VALUE, readBufferSize);
    }

    @Test

   * <p>The array {@code rest} must not be longer than {@code Integer.MAX_VALUE - 1}.
   */
  // Use (first, rest) so that `of(someDoubleArray)` won't compile (they should use copyOf), which
  // is okay since we have to copy the just-created array anyway.
  public static ImmutableDoubleArray of(double first, double... rest) {
    checkArgument(
        rest.length <= Integer.MAX_VALUE - 1, "the total number of elements must fit in an int");

   *
   * <p>The array {@code rest} must not be longer than {@code Integer.MAX_VALUE - 1}.
   */
  // Use (first, rest) so that `of(someIntArray)` won't compile (they should use copyOf), which is
  // okay since we have to copy the just-created array anyway.
  public static ImmutableIntArray of(int first, int... rest) {
    checkArgument(
        rest.length <= Integer.MAX_VALUE - 1, "the total number of elements must fit in an int");

          // We attempted to retry and got another timeout. Give up.
          return null
        }

        if (retryAfter(userResponse, Integer.MAX_VALUE) == 0) {
          // specifically received an instruction to retry without delay.
          return userResponse.request
        }

        return null
      }

      HTTP_MISDIRECTED_REQUEST -> {

    /**
     * Default constructor.
     */
    public CustomSizeValidator() {
        // Empty constructor
    }

    private int min = 0;
    private int max = Integer.MAX_VALUE;
    private String message;

    @Override
    public void initialize(final CustomSize constraintAnnotation) {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();

  }

  public void testNoForwardingOfDefaultMethod() throws Exception {
    ExecutorService delegate =
        new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, SECONDS, new SynchronousQueue<>()) {
          @Override
          public void close() {
            throw new AssertionError(
                "ForwardingExecutorService should have used the default method"

        LEAST,
        -Double.MAX_VALUE,
        -1.0,
        -0.5,
        -0.1,
        -0.0,
        0.0,
        0.1,
        0.5,
        1.0,
        Double.MAX_VALUE,
        GREATEST,
        Double.MIN_NORMAL,
        -Double.MIN_NORMAL,
        Double.MIN_VALUE,
        -Double.MIN_VALUE,
        Integer.MIN_VALUE,
        Integer.MAX_VALUE,
        Long.MIN_VALUE,
        Long.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());