Asserts that an array is empty.
@param {Array} actual The array to test.
@param {String} message (Optional) The message to display if the assertion fails.
@method isEmpty
@static
427412
function (actual, message) {
        YUITest.Assert._increment();
        if (actual.length > 0){
            YUITest.Assert.fail(YUITest.Assert._formatMessage(message, "Array should be empty."));
        }
    }
615538
protected function assertLessThanOrEqual($expected, $actual, $message = '')
    {
        \PHPUnit\Framework\Assert::assertLessThanOrEqual($expected, $actual, $message);
    }
384917
function internalAssert(condition, message) {
  if (!condition) {
    throw new AssertionError({
      message,
      actual: false,
      expected: true,
      operator: '=='
    });
  }
}
472878
protected function assertGreaterThan($expected, $actual, $message = '')
    {
        \PHPUnit\Framework\Assert::assertGreaterThan($expected, $actual, $message);
    }
502143
public <T> T[] notEmpty(final T[] array, final String message) {
        if (array == null) {
            failNull(message);
        }
        if (array.length == 0) {
            fail(message);
        }
        return array;
    }
194656
function isEmpty(obj) {
  if (isTrueEmpty(obj)) return true;
  if (exports.isRegExp(obj)) {
    return false;
  } else if (exports.isDate(obj)) {
    return false;
  } else if (exports.isError(obj)) {
    return false;
  } else if (exports.isArray(obj)) {
    return obj.length === 0;
  } else if (exports.isString(obj)) {
    return obj.length === 0;
  } else if (exports.isNumber(obj)) {
    return obj === 0;
  } else if (exports.isBoolean(obj)) {
    return !obj;
  } else if (exports.isObject(obj)) {
    for (const key in obj) {
      return false && key; // only for eslint
    }
    return true;
  }
  return false;
}
1010183
function isEmpty(obj) {
    if (!isExisty(obj) || _isEmptyString(obj)) {
        return true;
    }

    if (isArray(obj) || isArguments(obj)) {
        return obj.length === 0;
    }

    if (isObject(obj) && !isFunction(obj)) {
        return !_hasOwnProperty(obj);
    }

    return true;
}
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;
}
429606
function assert(actual, expected, message) {
  if (toString.call(expected) === '[object RegExp]' && expected.test(actual)) {
    return;
  } else if (eql(actual, expected)) {
    return;
  }

  var pad = Array(5).join(' ');
  var msg = message + '\n\n'
    + pad + 'Actual:   ' + inspect(actual) + '\n'
    + pad + 'Expected: ' + inspect(expected) + '\n';

  return new AssertionError(msg, {
    actual: actual,
    expected: expected,
    showDiff: assert.showDiff
  });
}
1316953
public static void assertFalse(boolean condition, String message, Object... args) {
		verify(!condition, message, args);
	}
848962
public static function assertStringIsNotEmpty($actual, string $message = '')
    {
        AssertHelper::assertMethodDependency(__CLASS__, __TRAIT__, 'assertStringIsNotEmpty', ['assertThat', 'assertNotEmpty']);
        self::assertThat($actual, new IsType('string'), $message);
        self::assertNotEmpty($actual, $message);
    }
566588
function isEmpty(str) {
            if (null === str || typeof str === 'undefined') {
                return true;
            }

            if (typeof str === 'string') {
                return (0 === str.length);
            }

            if (typeof str === 'object' && Array.isArray(str)) {
                return (0 === str.length);
            }

            return false;
        }
392433
public static boolean isEmpty(Object array) {
		if (null == array) {
			return true;
		} else if (isArray(array)) {
			return 0 == Array.getLength(array);
		}
		throw new UtilException("Object to provide is not a Array !");
	}
90210
public static void assertNull(String message, Object o) {
        if (o == null) {
            pass(message);
        } else {
            fail(message, "'" + o + "' is not null");
        }
    }
72541
function (actual, message) {
        YUITest.Assert._increment();
        if (typeof actual != "boolean"){
            throw new YUITest.UnexpectedValue(YUITest.Assert._formatMessage(message, "Value should be a Boolean."), actual);
        }
    }
943691
public static function assertArrayHasKeyValuePair(
        $expectedKey, $expectedValue, $actual, $message='') {
          Assert::assertThat(
            $actual,
            new ArrayHasKeyValuePair($expectedKey, $expectedValue),
            $message);
    }
361673
public static function assertNotSameStrings($expected, $actual, string $message = '')
    {
        self::assertStringsIdentity($actual, $message, __FUNCTION__, new LogicalNot(new SameStringsConstraint($expected)));
    }