Assert if given value is empty
@param value
@param {string} message
@param {string} id
@returns {void}
17779
function isEmpty(value, message, id) {
    if (message === void 0) { message = ''; }
    if (id === void 0) { id = ''; }
    if (this.enabled &&
        ((typeof value === 'string' && value.length === 0) ||
            (typeof value === 'number' && value === 0))) {
        throw LogicException.throw(assertionTypes.IS_EMPTY, value, message, id);
    }
}
1208840
function check(message, ranges, id) {
      /* Check the state at the message's position. */
      var index = ranges && ranges.length
      var length = -1
      var range

      while (--index > length) {
        range = ranges[index]

        /* istanbul ignore if - generated marker. */
        if (!range.position || !range.position.line || !range.position.column) {
          continue
        }

        if (
          range.position.line < message.line ||
          (range.position.line === message.line &&
            range.position.column < message.column)
        ) {
          return range.state === true
        }
      }

      /* The first marker ocurred after the first
       * message, so we check the initial state. */
      if (!id) {
        return initial || reset
      }

      return reset ? enable.indexOf(id) !== -1 : disable.indexOf(id) === -1
    }
174549
def is_empty(value, msg=None, except_=None, inc_zeros=True):
    '''
    
    '''
    if hasattr(value, 'empty'):
        # dataframes must check for .empty
        # since they don't define truth value attr
        # take the negative, since below we're
        # checking for cases where value 'is_null'
        value = not bool(value.empty)
    elif inc_zeros and value in ZEROS:
        # also consider 0, 0.0, 0L as 'empty'
        # will check for the negative below
        value = True
    else:
        pass
    _is_null = is_null(value, except_=False)
    result = bool(_is_null or not value)
    if except_:
        return is_true(result, msg=msg, except_=except_)
    else:
        return bool(result)
617515
public static void checkNotEmpty(@Nullable String value, @NonNull String message) {
        if (value == null) {
            throw new NullPointerException(message);
        } else if (value.length() == 0) {
            throw new IllegalStateException(message);
        }
    }
1088511
public static boolean isEmpty(Object value) {
		return (null == value || (value instanceof String && StrUtil.isEmpty((String) value)));
	}
935737
function isArray(value, message, id) {
    if (message === void 0) { message = ''; }
    if (id === void 0) { id = ''; }
    if (this.enabled && !Array.isArray(value)) {
        throw TypeException.unexpectedType(assertionTypes.IS_ARRAY, value, '<array>', message, id);
    }
}
368345
static public function noContent($value, $message = null, $propertyPath = null)
        {
            if (!empty($value)) {
                $message = $message ?: sprintf(
                    'Value "%s" is not empty, but empty value was expected.',
                    static::stringify($value)
                );

                throw static::createException($value, $message, static::VALUE_NOT_EMPTY, $propertyPath);
            }
        }
39068
function isNotSymbol(value, message, id) {
    if (message === void 0) { message = ''; }
    if (id === void 0) { id = ''; }
    if (this.enabled && typeof value === 'symbol') {
        throw TypeException.expectedType(assertionTypes.IS_NOT_SYMBOL, value, '<symbol>', message, id);
    }
}
6539
function isEmpty(value) {
	if (Array.isArray(value)) {
		// If first item in array is undefined, we assume there are no parameters
		// This happens as a result of using the rest operator in a mixin
		return value.length === 0 || value[0] === undefined;
	}

	return value === undefined;
}
493710
private void assertNotNull(Object value, String message) throws IllegalArgumentException {
        if (value == null) {
            throw new IllegalArgumentException(message);
        }
    }
49879
function isValueEmpty(value) {
  if (_.isUndefined(value)) {
    return true;
  }
  var canUseIsEmpty = _.isString(value) || _.isArray(value) || (_.isObject(value) && !_.isDate(value)) || false;
  if (canUseIsEmpty) {
    return _.isEmpty(value);
  }
  return (_.isNumber(value) || _.isBoolean(value) || _.isDate(value)) ? false : true;
}
336934
def is_not_empty(self, value, strict=False):
        """"""
        value = stringify(value)
        if value is not None:
            return
        self.shout('Value %r is empty', strict, value)
180294
def _validate(cls, message):
        
        valid = False
        if(('name' in message and 'value' in message) or
                ('id' in message and 'data' in message)):
            valid = True
        return valid
983992
public void setMessage(String message) {
        requireArgument(message != null && !message.isEmpty(), "Message cannot be null or empty.");
        this.message = message;
    }
810917
static public function notEmpty($value, $message = null, $propertyPath = null)
        {
            if (empty($value)) {
                $message = $message ?: sprintf(
                    'Value "%s" is empty, but non empty value was expected.',
                    static::stringify($value)
                );

                throw static::createException($value, $message, static::VALUE_EMPTY, $propertyPath);
            }
        }
1024629
public function assertIsStringAndNonEmpty($value, $message='%s must be a string and not empty', $exception='Asserts')
    {
        if (is_string($value) === false || strlen($value) < 1) {
            $this->throwException($exception, $message, $value);
        }
    }
562939
public static void assertNull(Object object, String message) {
		if (imp != null && object != null) {
			imp.assertFailed(message);
		}
	}