Determine if the input int parameter is greater than min. if yes, the check passes

@param min input must be > min number
@param msg error message after verification failed
@return Validation
195104
public static Validation<Integer> greaterThan(int min, String msg) {
        return SimpleValidation.from((i) -> i > min, format(msg, min));
    }
715467
public static <T extends CharSequence> T checkArgNotNullOrEmptyOrBlank(final T arg, final String msg) {
        if (N.isNullOrEmptyOrBlank(arg)) {
            if (isNullErrorMsg(msg)) {
                throw new IllegalArgumentException(msg);
            } else {
                throw new IllegalArgumentException("'" + msg + "' can not be null or empty or blank");
            }
        }

        return arg;
    }
995974
public Regex range(int min, int max) {
      return re(this.pattern + "{" + Integer.toString(min) + "," + Integer.toString(max) + "}");
   }
1252404
public static <T extends CharSequence> T validateLetter(T value, String errorMsg) throws ValidateException {
		if (false == isLetter(value)) {
			throw new ValidateException(errorMsg);
		}
		return value;
	}
812618
public static <T> T validateNotEmpty(T value, String errorMsg) throws ValidateException {
		if (isEmpty(value)) {
			throw new ValidateException(errorMsg);
		}
		return value;
	}
1200496
public ValidatorBuilderLong<PARENT> range(long min, long max) {

    return range(new Range<>(Long.valueOf(min), Long.valueOf(max)));
  }
257663
protected void validateInteger(int index, String errorKey, String errorMessage) {
		String value = controller.getPara(index);
		if (value != null && (value.startsWith("N") || value.startsWith("n"))) {
			value = "-" + value.substring(1);
		}
		validateIntegerValue(value, errorKey, errorMessage);
	}
894378
protected static ValidationBuilder validateRange(String attributeName, Number min, Number max) {
        return ModelDelegate.validateRange(modelClass(), attributeName, min, max);
    }
757443
private boolean validateMinValue(Object validationObject, Annotation annotate)
    {
        if (checkNullObject(validationObject))
        {
            return true;
        }

        Long minValue = ((Min) annotate).value();
        if (checkvalidDigitTypes(validationObject.getClass()))
        {
            if ((NumberUtils.toLong(toString(validationObject))) < minValue)
            {

                throwValidationException(((Min) annotate).message());
            }
        }

        return true;
    }
918645
protected function validate_int( $var, $min = null, $max = null ) {
		if ( ! is_int( $var ) && ! is_string( $var ) && empty( $var ) ) {
			return new \WP_Error( 400, $this->app->translate( 'Value is required.' ) );
		}
		if ( ! is_int( $var ) && ( ! is_string( $var ) || ! preg_match( '#\A-?\d+\z#', $var ) ) ) {
			return new \WP_Error( 400, $this->app->translate( 'Invalid format.' ) );
		}
		if ( isset( $min ) && $var < $min ) {
			return new \WP_Error( 400, $this->app->translate( 'Outside the range of allowed values.' ) );
		}
		if ( isset( $max ) && $var > $max ) {
			return new \WP_Error( 400, $this->app->translate( 'Outside the range of allowed values.' ) );
		}

		return true;
	}
856590
public static ValidationStatus getInfoMsgLevel(final String msg) {
    if (msg.startsWith("ERROR")) {
      return ValidationStatus.ERROR;
    }
    if (msg.startsWith("WARN")) {
      return ValidationStatus.WARN;
    }
    return ValidationStatus.PASS;
  }
441796
public ValidatorBuilderFloat<PARENT> range(float min, float max) {

    return range(new Range<>(Float.valueOf(min), Float.valueOf(max)));
  }
943041
public void setMin(Double min) {
        String minStr = doubleToNiceStr(min);
        JQMCommon.setAttribute(input, "min", minStr);
        refreshMin(input.getElement().getId(), minStr);
        validateValue();
    }
1305555
protected void validateEqualInteger(Integer i1, Integer i2, String errorKey, String errorMessage) {
		if (i1 == null || i2 == null || (i1.intValue() != i2.intValue())) {
			addError(errorKey, errorMessage);
		}
	}
984972
@Override
	protected void validateComponent(final List<Diagnostic> diags) {
		super.validateComponent(diags);

		List<?> selected = getValue();

		// Only validate max and min if options have been selected
		if (!selected.isEmpty()) {
			int value = selected.size();
			int min = getMinSelect();
			int max = getMaxSelect();

			if (min > 0 && value < min) {
				diags.add(
						createErrorDiagnostic(InternalMessages.DEFAULT_VALIDATION_ERROR_MIN_SELECT,
								this, min));
			}

			if (max > 0 && value > max) {
				diags.add(
						createErrorDiagnostic(InternalMessages.DEFAULT_VALIDATION_ERROR_MAX_SELECT,
								this, max));
			}
		}
	}
1195972
public static <T extends CharSequence> T validateLowerCase(T value, String errorMsg) throws ValidateException {
		if (false == isLowerCase(value)) {
			throw new ValidateException(errorMsg);
		}
		return value;
	}
1147965
public static Double validateNumber(final String context,
			final String input, final long minValue, final long maxValue,
			final boolean allowNull) throws ValidationException {
		return validator.getValidNumber(context, input, minValue, maxValue,
				allowNull);
	}