List<long[]> ordered =
        Arrays.asList(
            new long[] {},
            new long[] {MIN_VALUE},
            new long[] {MIN_VALUE, MIN_VALUE},
            new long[] {MIN_VALUE, 1L},
            new long[] {1L},
            new long[] {1L, MIN_VALUE},
            new long[] {MAX_VALUE, MAX_VALUE - 1L},
            new long[] {MAX_VALUE, MAX_VALUE},

    integralBuilder.addAll(Doubles.asList(0.0, -0.0, Double.MAX_VALUE, -Double.MAX_VALUE));
    // Add small multiples of MIN_VALUE and MIN_NORMAL
    for (int scale = 1; scale <= 4; scale++) {
      for (double d : Doubles.asList(Double.MIN_VALUE, Double.MIN_NORMAL)) {
        fractionalBuilder.add(d * scale).add(-d * scale);
      }
    }

        // The comparator b2 - b1 with MAX_VALUE and MIN_VALUE causes overflow
        List<Integer> executionOrder = PriorityTrackingBooster.getExecutionOrder();
        assertEquals(3, executionOrder.size());
        assertEquals(Integer.valueOf(Integer.MIN_VALUE), executionOrder.get(0));
        assertEquals(Integer.valueOf(Integer.MAX_VALUE), executionOrder.get(1));

   *       Integer.MIN_VALUE}
   *   <li>{@link Math#absExact(int)}, which throws {@link ArithmeticException} when passed {@code
   *       Integer.MIN_VALUE}
   *   <li>this method, {@code IntMath.saturatedAbs(int)}, which returns {@code Integer.MAX_VALUE}
   *       when passed {@code Integer.MIN_VALUE}
   * </ul>
   *

   *     {@link Integer#MAX_VALUE} if it is too large, or {@link Integer#MIN_VALUE} if it is too
   *     small
   */
  public static int saturatedCast(long value) {
    if (value > Integer.MAX_VALUE) {
      return Integer.MAX_VALUE;
    }
    if (value < Integer.MIN_VALUE) {
      return Integer.MIN_VALUE;
    }
    return (int) value;
  }

  /**

   *       Long.MIN_VALUE}
   *   <li>{@link Math#absExact(long)}, which throws {@link ArithmeticException} when passed {@code
   *       Long.MIN_VALUE}
   *   <li>this method, {@code LongMath.saturatedAbs(long)}, which returns {@code Long.MAX_VALUE}
   *       when passed {@code Long.MIN_VALUE}
   * </ul>
   *

  }

  public void testCheckPositive_minInt() {
    assertThrows(
        IllegalArgumentException.class,
        () -> MathPreconditions.checkPositive("int", Integer.MIN_VALUE));
  }

  public void testCheckPositive_positiveInt() {
    MathPreconditions.checkPositive("int", 1);
  }

  public void testCheckPositive_negativeInt() {

        searchRenderData.setAllRecordCount(Long.MIN_VALUE);
        searchRenderData.setCurrentStartRecordNumber(Long.MIN_VALUE);
        searchRenderData.setCurrentEndRecordNumber(Long.MIN_VALUE + 10);
        searchRenderData.setPageSize(Integer.MIN_VALUE);
        searchRenderData.setAllPageCount(Integer.MIN_VALUE);
        searchRenderData.setCurrentPageNumber(Integer.MIN_VALUE);

  }

  public void testCheckPositive_minInt() {
    assertThrows(
        IllegalArgumentException.class,
        () -> MathPreconditions.checkPositive("int", Integer.MIN_VALUE));
  }

  public void testCheckPositive_positiveInt() {
    MathPreconditions.checkPositive("int", 1);
  }

  public void testCheckPositive_negativeInt() {

   *
   * <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.
   */
  @J2ktIncompatible
  @GwtIncompatible // Duration