final BytesStreamOutput tmp = new BytesStreamOutput();
        for (int i = 0; i < entries / 2; i++) {
            tmp.writeVInt(i);
        }
        for (int i = 0; i < entries / 2; i++) {
            tmp.writeVInt(Integer.MAX_VALUE - i);
        }
        BytesReference pagedBytes = tmp.bytes();
        if (pagedBytes instanceof PagedBytesReference == false) {

    # o cursorSelectFetchSize: (NotRequired - Default null)
    #  The fetch size of JDBC parameter for cursor select.
    #  For example, specify Integer.MIN_VALUE to enable fetch of MySQL.
    #
    #; cursorSelectFetchSize = Integer.MIN_VALUE
    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    // The number of bytes in the input.
    private long b = 0;

    // The final 64-bit chunk includes the last 0 through 7 bytes of m followed by null bytes
    // and ending with a byte encoding the positive integer b mod 256.
    private long finalM = 0;

    SipHasher(int c, int d, long k0, long k1) {
      super(CHUNK_SIZE);
      this.c = c;
      this.d = d;
      this.v0 ^= k0;
      this.v1 ^= k1;

      return subclass;
    }
    // class Base<A, B> {}
    // class Sub<X, Y> extends Base<X, Y> {}
    // Base<String, Integer>.subtype(Sub.class):

    // Sub<X, Y>.getSupertype(Base.class) => Base<X, Y>
    // => X=String, Y=Integer
    // => Sub<X, Y>=Sub<String, Integer>
    TypeToken<?> genericSubtype = toGenericType(subclass);
    @SuppressWarnings({"rawtypes", "unchecked"}) // subclass isn't <? extends T>

 */
@GwtCompatible
@NullUnmarked
public class DoubleMathTest extends TestCase {

  private static final BigDecimal MAX_INT_AS_BIG_DECIMAL = BigDecimal.valueOf(Integer.MAX_VALUE);
  private static final BigDecimal MIN_INT_AS_BIG_DECIMAL = BigDecimal.valueOf(Integer.MIN_VALUE);

  private static final BigDecimal MAX_LONG_AS_BIG_DECIMAL = BigDecimal.valueOf(Long.MAX_VALUE);

                "item_id"
            ],
            "msg": "value is not a valid integer",
            "type": "type_error.integer"
        }
    ]
}
```

以下のテキスト版を取得します:

```
Validation errors:
Field: ('path', 'item_id'), Error: Input should be a valid integer, unable to parse string as an integer
```

### `HTTPException`エラーハンドラのオーバーライド { #override-the-httpexception-error-handler }

{
    "properties": {
      "urlExpr": {
        "type": "keyword"
      },
      "boostExpr": {
        "type": "keyword"
      },
      "sortOrder": {
        "type": "integer"
      },
      "createdBy": {
        "type": "keyword"
      },
      "createdTime": {
        "type": "long"
      },
      "updatedBy": {
        "type": "keyword"
      },
      "updatedTime": {
        "type": "long"
      }

     */
    public static void appendHex(final StringBuilder buf, final int i) {
        buf.append(Integer.toHexString(i >> 24 & 0xff));
        buf.append(Integer.toHexString(i >> 16 & 0xff));
        buf.append(Integer.toHexString(i >> 8 & 0xff));
        buf.append(Integer.toHexString(i & 0xff));
    }

    /**
     * Converts an underscore-separated string to camel case.
     * <p>

      exponent[i] = randomExponent();
      factorial[i] = RANDOM_SOURCE.nextInt(50);
      binomial[i] = RANDOM_SOURCE.nextInt(factorial[i] + 1);
      positive[i] = randomPositiveBigInteger(Integer.SIZE - 1).intValue();
      nonnegative[i] = randomNonNegativeBigInteger(Integer.SIZE - 1).intValue();
      ints[i] = RANDOM_SOURCE.nextInt();
    }
  }

  @Benchmark
  int pow(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {

 *
 * @author Mike Bostock
 */
@GwtCompatible
@NullMarked
public class AbstractMapEntryTest extends TestCase {
  private static final @Nullable String NK = null;
  private static final @Nullable Integer NV = null;

  private static <K extends @Nullable Object, V extends @Nullable Object> Entry<K, V> entry(
      K key, V value) {
    return new AbstractMapEntry<K, V>() {
      @Override
      public K getKey() {