The input string must be more than or equal to size. if yes, the check passes

@param size string size
@param msg  error message after verification failed
@return Validation
433306
public static Validation<String> moreThan(int size, String msg) {
        return notEmpty().and(SimpleValidation.from((s) -> s.length() >= size, format(msg, size)));
    }
1195972
public static <T extends CharSequence> T validateLowerCase(T value, String errorMsg) throws ValidateException {
		if (false == isLowerCase(value)) {
			throw new ValidateException(errorMsg);
		}
		return value;
	}
1120572
public static <E> Matcher<Iterable<E>> hasSize(final int size) {
        checkArgument(size >= 0, "Size cannot be negative");

        return new IsIterableWithSize(size);
    }
195104
public static Validation<Integer> greaterThan(int min, String msg) {
        return SimpleValidation.from((i) -> i > min, format(msg, min));
    }
349464
public void addErrorMsgs(final Set<String> msgs) {
    if (msgs != null) {
      this._errorMsgs.addAll(msgs);
      if (!msgs.isEmpty()) {
        this._status = ValidationStatus.ERROR;
      }
    }
  }
284802
function(size) {
		if (typeof(size) !== 'string') {
			return size;
		}
		
		var muls = {
				t: 1099511627776,
				g: 1073741824,
				m: 1048576,
				k: 1024
			},
			mul;

		size = /^([0-9]+)([mgk]?)$/.exec(size.toLowerCase().replace(/[^0-9mkg]/g, ''));
		mul = size[2];
		size = +size[1];
		
		if (muls.hasOwnProperty(mul)) {
			size *= muls[mul];
		}
		return size;
	}
669674
public void error (String msg, Object... args) {
    error(format(msg, args), getCause(args));
  }
451954
public BatcherBuilder sizeBound(int size) {
        checkState(this.maxSize == UNSET_INT, "Max size already set to %s", this.maxSize);
        checkArgument(size > 0, "Required to have a size bound greater than 0");
        this.maxSize = size;
        return this;
    }
1090789
public static void error(String msg, Object... args) {
		String tag = generateTag();
		if (!"".equals(tag)) {
			if (args.length > 0) {
				Log.e(tag, String.format(msg, args));
			} else {
				Log.e(tag, msg);

			}
		}
	}
62783
function isValidSize(size) {
  return isArray(size) && size.length === 2 && isInteger(size[0]) && isInteger(size[1]);
}
842610
public CollectionAssert hasSizeLessThanOrEqualTo(int size) {
		isNotNull();
		int actualSize = size(this.actual);
		if (!(actualSize <= size)) {
			failWithMessage("The size <%s> is not less or equal to <%s>", actualSize,
					size);
		}
		return this;
	}
65180
public static void check(boolean isValid, String message, Object... args) {
    if (!isValid) {
      String[] argStrings = new String[args.length];
      for (int i = 0; i < args.length; i += 1) {
        argStrings[i] = String.valueOf(args[i]);
      }
      throw new ValidationException(
          String.format(String.valueOf(message), (Object[]) argStrings));
    }
  }
1350143
def validate(self, size):
        
        msg = 'scale and array size must match, ' \
              'but were scale: {self.scale.n_bands},  array size: {size}'

        if size != len(self.scale):
            raise ValueError(msg.format(**locals()))
727458
static Map<String, Object> sizePayload(final Object min, final Object max) {
		if (min == null || max == null) {
			return null;
		}
		Map<String, Object> payload = new LinkedHashMap<>();
		payload.put("min", min);
		payload.put("max", max);
		payload.put("message", MSG_PREFIX + VALIDATORS.get(Size.class));
		return payload;
	}
868600
public static <T> T validateEmpty(T value, String errorMsg) throws ValidateException {
		if (isNotEmpty(value)) {
			throw new ValidateException(errorMsg);
		}
		return value;
	}
1194830
public CmsMessageContainer validateWithMessage() {

        if (m_parsingFailed) {
            return Messages.get().container(Messages.ERR_SERIALDATE_INVALID_VALUE_0);
        }
        if (!isStartSet()) {
            return Messages.get().container(Messages.ERR_SERIALDATE_START_MISSING_0);
        }
        if (!isEndValid()) {
            return Messages.get().container(Messages.ERR_SERIALDATE_END_BEFORE_START_0);
        }
        String key = validatePattern();
        if (null != key) {
            return Messages.get().container(key);
        }
        key = validateDuration();
        if (null != key) {
            return Messages.get().container(key);
        }
        if (hasTooManyEvents()) {
            return Messages.get().container(
                Messages.ERR_SERIALDATE_TOO_MANY_EVENTS_1,
                Integer.valueOf(CmsSerialDateUtil.getMaxEvents()));
        }
        return null;
    }
875607
public static <T extends CharSequence> T validatePlateNumber(T value, String errorMsg) throws ValidateException {
		if (false == isPlateNumber(value)) {
			throw new ValidateException(errorMsg);
		}
		return value;
	}