constraints.AssertTrue.message = {item} must be true.
constraints.DecimalMax.message = {item} must be less than {value}.
constraints.DecimalMin.message = {item} must be greater than {value}.
constraints.Digits.message = {item} must be a number. (expected: <number>.<number>)
constraints.Future.message = {item} must be a future value.
constraints.Max.message = {item} must be less than or equal to {value}.

constraints.AssertTrue.message = {item} must be true.
constraints.DecimalMax.message = {item} must be less than {value}.
constraints.DecimalMin.message = {item} must be greater than {value}.
constraints.Digits.message = {item} must be a number. (expected: <number>.<number>)
constraints.Future.message = {item} must be a future value.
constraints.Max.message = {item} must be less than or equal to {value}.

 * amortized since some operations can trigger a hash table resize.
 *
 * <p>This implementation consumes significantly less memory than {@code java.util.LinkedHashSet} or
 * even {@code java.util.HashSet}, and places considerably less load on the garbage collector. Like
 * {@code java.util.LinkedHashSet}, it offers insertion-order iteration, with identical behavior.
 *

 * amortized since some operations can trigger a hash table resize.
 *
 * <p>This implementation consumes significantly less memory than {@code java.util.LinkedHashSet} or
 * even {@code java.util.HashSet}, and places considerably less load on the garbage collector. Like
 * {@code java.util.LinkedHashSet}, it offers insertion-order iteration, with identical behavior.
 *

        assertFalse(CharUtil.isUrlChar('\t')); // tab
        assertFalse(CharUtil.isUrlChar('\n')); // newline
        assertFalse(CharUtil.isUrlChar('\r')); // carriage return
        assertFalse(CharUtil.isUrlChar('<')); // less than
        assertFalse(CharUtil.isUrlChar('>')); // greater than
        assertFalse(CharUtil.isUrlChar('"')); // double quote
        assertFalse(CharUtil.isUrlChar('\\')); // backslash

        {
            "detail": [
                {
                    "type": "less_than_equal",
                    "loc": ["query", "limit"],
                    "msg": "Input should be less than or equal to 100",
                    "input": "150",
                    "ctx": {"le": 100},
                },
                {
                    "type": "greater_than_equal",

   * part of the smeared hash of the element not covered by the hashtable mask, whereas the low bits
   * are the "next" pointer (pointing to the next entry in the bucket chain), which will always be
   * less than or equal to the hashtable mask.
   *
   * <pre>
   * hash  = aaaaaaaa
   * mask  = 00000fff
   * next  = 00000bbb
   * entry = aaaaabbb
   * </pre>
   *

    }
    return tmp;
  }

  private static long random() {
    return randomSource.nextLong();
  }

  // A random value that cannot be 0 and that is unsigned-less-than or equal
  // to the given dividend, so that we don't have half of our divisions being
  // trivial because the divisor is bigger than the dividend.

 *
 * <p>The {@code toString} method is forwarded to the delegate. Although this class does not
 * implement {@link Serializable}, a serializable subclass may be created since this class has a
 * parameter-less constructor.
 *
 * @author Mike Bostock
 * @since 2.0
 */
@GwtCompatible
public abstract class ForwardingObject {

  /** Constructor for use by subclasses. */
  protected ForwardingObject() {}

  /**

        {
            "detail": [
                {
                    "type": "less_than_equal",
                    "loc": ["query", "limit"],
                    "msg": "Input should be less than or equal to 100",
                    "input": "150",
                    "ctx": {"le": 100},
                },
                {
                    "type": "greater_than_equal",