Assert

java.lang.Object
- de.qfs.lib.assertions.Assert

@QFNotify
public abstract class Assert
extends java.lang.Object

Constructor Summary

Constructors
Constructor and Description

Assert()

Constructors
Constructor and Description
`Assert()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean`	`deepEqual(java.lang.Object act, java.lang.Object exp)`
`static boolean`	`deepEqual(java.lang.Object act, java.lang.Object exp, java.lang.String msg)` ### .deepEqual(actual, expected, [message]) Asserts that `actual` is deeply equal to `expected`.
`static boolean`	`deepInclude(java.lang.Object haystack, java.lang.Object needle)`
`static boolean`	`deepInclude(java.lang.Object haystack, java.lang.Object needle, java.lang.String message)` ### .deepInclude(haystack, needle, [message]) Asserts that `haystack` includes `needle`.
`static boolean`	`deepNestedInclude(java.lang.Object haystack, java.lang.Object needle)`
`static boolean`	`deepNestedInclude(java.lang.Object haystack, java.lang.Object needle, java.lang.String message)` ### .deepNestedInclude(haystack, needle, [message]) Asserts that 'haystack' includes 'needle'.
`static boolean`	`deepNestedPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val)`
`static boolean`	`deepNestedPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val, java.lang.String msg)` ### .deepNestedPropertyVal(object, property, value, [message]) Asserts that `object` has a property named by `property` with a value given by `value`.
`static boolean`	`deepOwnInclude(java.lang.Object haystack, java.lang.Object needle)`
`static boolean`	`deepOwnInclude(java.lang.Object haystack, java.lang.Object needle, java.lang.String message)` ### .deepOwnInclude(haystack, needle, [message]) Asserts that 'haystack' includes 'needle'.
`static boolean`	`deepOwnPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object value)`
`static boolean`	`deepOwnPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object value, java.lang.String msg)` ### .deepOwnPropertyVal(object, property, value, [message]) Asserts that `object` has a direct property named by `property` and a value equal to the provided `value`.
`static boolean`	`deepPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val)`
`static boolean`	`deepPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val, java.lang.String msg)` ### .deepPropertyVal(object, property, value, [message]) Asserts that `object` has a direct or inherited property named by `property` with a value given by `value`.
`static boolean`	`empty(java.lang.Object obj)`
`static boolean`	`empty(java.lang.Object obj, java.lang.String msg)`
`static boolean`	`equal(java.lang.Object act, java.lang.Object exp)`
`static boolean`	`equal(java.lang.Object act, java.lang.Object exp, java.lang.String msg)` ### .equal(actual, expected, [message]) Asserts non-strict equality (`==`) of `actual` and `expected`.
`static boolean`	`exists(java.lang.Object val)`
`static boolean`	`exists(java.lang.Object val, java.lang.String msg)` ### .exists Asserts that the target is neither `null` nor `undefined`.
`static boolean`	`fail()` ### .fail([message]) ### .fail(actual, expected, [message], [operator]) Throw a failure.
`static boolean`	`fail(java.lang.Object actual, java.lang.Object expected)`
`static boolean`	`fail(java.lang.Object actual, java.lang.Object expected, java.lang.String message)`
`static boolean`	`fail(java.lang.Object actual, java.lang.Object expected, java.lang.String message, java.lang.String operator)`
`static boolean`	`fail(java.lang.Object actual, java.lang.Object expected, java.lang.String message, java.lang.String operator, java.lang.String ssfi)`
`static boolean`	`fail(java.lang.String message)`
`static boolean`	`include(java.lang.Object haystack, java.lang.Object needle)`
`static boolean`	`include(java.lang.Object haystack, java.lang.Object needle, java.lang.String message)` ### .include(haystack, needle, [message]) Asserts that `haystack` includes `needle`.
`static boolean`	`instanceOf(java.lang.Object val, java.lang.Object type)`
`static boolean`	`instanceOf(java.lang.Object val, java.lang.Object type, java.lang.String msg)` ### .instanceOf(object, constructor, [message]) Asserts that `value` is an instance of `constructor`.
`static boolean`	`isArray(java.lang.Object value)`
`static boolean`	`isArray(java.lang.Object value, java.lang.String message)` ### .isArray(value, [message]) Asserts that `value` is an array.
`static boolean`	`isBoolean(java.lang.Object value)`
`static boolean`	`isBoolean(java.lang.Object value, java.lang.String message)` ### .isBoolean(value, [message]) Asserts that `value` is a boolean.
`static boolean`	`isEmpty(java.lang.Object obj)`
`static boolean`	`isEmpty(java.lang.Object obj, java.lang.String msg)` ### .isEmpty(target) Asserts that the target does not contain any values.
`static boolean`	`isFalse(java.lang.Object val)`
`static boolean`	`isFalse(java.lang.Object val, java.lang.String msg)` ### .isFalse(value, [message]) Asserts that `value` is false.
`static boolean`	`isFunction(java.lang.Object value)`
`static boolean`	`isFunction(java.lang.Object value, java.lang.String message)` ### .isFunction(value, [message]) Asserts that `value` is a function.
`static boolean`	`isList(java.lang.Object value)`
`static boolean`	`isList(java.lang.Object value, java.lang.String message)` ### .isList(value, [message]) Asserts that `value` is a list.
`static boolean`	`isMap(java.lang.Object value)`
`static boolean`	`isMap(java.lang.Object value, java.lang.String message)` ### .isMap(value, [message]) Asserts that `value` is a map.
`static boolean`	`isNotArray(java.lang.Object value)`
`static boolean`	`isNotArray(java.lang.Object value, java.lang.String message)` ### .isNotArray(value, [message]) Asserts that `value` is _not_ an array.
`static boolean`	`isNotBoolean(java.lang.Object value)`
`static boolean`	`isNotBoolean(java.lang.Object value, java.lang.String message)` ### .isNotBoolean(value, [message]) Asserts that `value` is _not_ a boolean.
`static boolean`	`isNotEmpty(java.lang.Object obj)`
`static boolean`	`isNotEmpty(java.lang.Object obj, java.lang.String msg)` ### .isNotEmpty(target) Asserts that the target contains values.
`static boolean`	`isNotFalse(java.lang.Object val)`
`static boolean`	`isNotFalse(java.lang.Object val, java.lang.String msg)` ### .isNotFalse(value, [message]) Asserts that `value` is not false.
`static boolean`	`isNotFunction(java.lang.Object value)`
`static boolean`	`isNotFunction(java.lang.Object value, java.lang.String message)` ### .isNotFunction(value, [message]) Asserts that `value` is _not_ a function.
`static boolean`	`isNotList(java.lang.Object value)`
`static boolean`	`isNotList(java.lang.Object value, java.lang.String message)` ### .isNotList(value, [message]) Asserts that `value` is _not_ a list.
`static boolean`	`isNotMap(java.lang.Object value)`
`static boolean`	`isNotMap(java.lang.Object value, java.lang.String message)` ### .isNotMap(value, [message]) Asserts that `value` is _not_ a map.
`static boolean`	`isNotNull(java.lang.Object val)`
`static boolean`	`isNotNull(java.lang.Object val, java.lang.String msg)` ### .isNotNull(value, [message]) Asserts that `value` is not null.
`static boolean`	`isNotNumber(java.lang.Object value)`
`static boolean`	`isNotNumber(java.lang.Object value, java.lang.String message)` ### .isNotNumber(value, [message]) Asserts that `value` is _not_ a number.
`static boolean`	`isNotObject(boolean value)`
`static boolean`	`isNotObject(boolean value, java.lang.String message)`
`static boolean`	`isNotObject(byte value)`
`static boolean`	`isNotObject(byte value, java.lang.String message)`
`static boolean`	`isNotObject(char value)`
`static boolean`	`isNotObject(char value, java.lang.String message)`
`static boolean`	`isNotObject(double value)`
`static boolean`	`isNotObject(double value, java.lang.String message)`
`static boolean`	`isNotObject(float value)`
`static boolean`	`isNotObject(float value, java.lang.String message)`
`static boolean`	`isNotObject(int value)`
`static boolean`	`isNotObject(int value, java.lang.String message)`
`static boolean`	`isNotObject(long value)`
`static boolean`	`isNotObject(long value, java.lang.String message)`
`static boolean`	`isNotObject(java.lang.Object value)`
`static boolean`	`isNotObject(java.lang.Object value, java.lang.String message)` ### .isNotObject(value, [message]) Asserts that `value` is _not_ an object of type 'Object' (as revealed by `Object.prototype.toString`).
`static boolean`	`isNotObject(short value)`
`static boolean`	`isNotObject(short value, java.lang.String message)`
`static boolean`	`isNotOk(java.lang.Object val)`
`static boolean`	`isNotOk(java.lang.Object val, java.lang.String msg)` ### .isNotOk(object, [message]) Asserts that `object` is falsy.
`static boolean`	`isNotString(java.lang.Object value)`
`static boolean`	`isNotString(java.lang.Object value, java.lang.String message)` ### .isNotString(value, [message]) Asserts that `value` is _not_ a string.
`static boolean`	`isNotTrue(java.lang.Object val)`
`static boolean`	`isNotTrue(java.lang.Object val, java.lang.String msg)` ### .isNotTrue(value, [message]) Asserts that `value` is not true.
`static boolean`	`isNull(java.lang.Object val)`
`static boolean`	`isNull(java.lang.Object val, java.lang.String msg)` ### .isNull(value, [message]) Asserts that `value` is null.
`static boolean`	`isNumber(java.lang.Object value)`
`static boolean`	`isNumber(java.lang.Object value, java.lang.String message)` ### .isNumber(value, [message]) Asserts that `value` is a number.
`static boolean`	`isObject(boolean value)`
`static boolean`	`isObject(boolean value, java.lang.String message)`
`static boolean`	`isObject(byte value)`
`static boolean`	`isObject(byte value, java.lang.String message)`
`static boolean`	`isObject(char value)`
`static boolean`	`isObject(char value, java.lang.String message)`
`static boolean`	`isObject(double value)`
`static boolean`	`isObject(double value, java.lang.String message)`
`static boolean`	`isObject(float value)`
`static boolean`	`isObject(float value, java.lang.String message)`
`static boolean`	`isObject(int value)`
`static boolean`	`isObject(int value, java.lang.String message)`
`static boolean`	`isObject(long value)`
`static boolean`	`isObject(long value, java.lang.String message)`
`static boolean`	`isObject(java.lang.Object value)`
`static boolean`	`isObject(java.lang.Object value, java.lang.String message)` ### .isObject(value, [message]) Asserts that `value` is an object of type 'Object' (as revealed by `Object.prototype.toString`).
`static boolean`	`isObject(short value)`
`static boolean`	`isObject(short value, java.lang.String message)`
`static boolean`	`isOk(java.lang.Object val)`
`static boolean`	`isOk(java.lang.Object val, java.lang.String msg)` ### .isOk(object, [message]) Asserts that `object` is truthy.
`static boolean`	`isString(java.lang.Object value)`
`static boolean`	`isString(java.lang.Object value, java.lang.String message)` ### .isString(value, [message]) Asserts that `value` is a string.
`static boolean`	`isTrue(java.lang.Object val)`
`static boolean`	`isTrue(java.lang.Object val, java.lang.String msg)` ### .isTrue(value, [message]) Asserts that `value` is true.
`static boolean`	`lengthOf(java.lang.Object obj, int len)`
`static boolean`	`lengthOf(java.lang.Object obj, int len, java.lang.String msg)` ### .lengthOf(object, length, [message]) Asserts that `object` has a `length` or `size` with the expected value.
`static boolean`	`match(java.lang.String exp, java.util.regex.Pattern re)`
`static boolean`	`match(java.lang.String exp, java.util.regex.Pattern re, java.lang.String msg)` ### .match(value, regexp, [message]) Asserts that `value` matches the regular expression `regexp`.
`static boolean`	`match(java.lang.String exp, java.lang.String re)`
`static boolean`	`match(java.lang.String exp, java.lang.String re, java.lang.String msg)`
`static boolean`	`nestedInclude(java.lang.Object haystack, java.lang.Object needle)`
`static boolean`	`nestedInclude(java.lang.Object haystack, java.lang.Object needle, java.lang.String message)` ### .nestedInclude(haystack, needle, [message]) Asserts that 'haystack' includes 'needle'.
`static boolean`	`nestedProperty(java.lang.Object obj, java.lang.String prop)`
`static boolean`	`nestedProperty(java.lang.Object obj, java.lang.String prop, java.lang.String msg)` ### .nestedProperty(object, property, [message]) Asserts that `object` has a direct or inherited property named by `property`, which can be a string using dot- and bracket-notation for nested reference.
`static boolean`	`nestedPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val)`
`static boolean`	`nestedPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val, java.lang.String msg)` ### .nestedPropertyVal(object, property, value, [message]) Asserts that `object` has a property named by `property` with value given by `value`.
`static boolean`	`notDeepEqual(java.lang.Object act, java.lang.Object exp)`
`static boolean`	`notDeepEqual(java.lang.Object act, java.lang.Object exp, java.lang.String msg)` ### .notDeepEqual(actual, expected, [message]) Assert that `actual` is not deeply equal to `expected`.
`static boolean`	`notDeepInclude(java.lang.Object haystack, java.lang.Object needle)`
`static boolean`	`notDeepInclude(java.lang.Object haystack, java.lang.Object needle, java.lang.String message)` ### .notDeepInclude(haystack, needle, [message]) Asserts that `haystack` does not include `needle`.
`static boolean`	`notDeepNestedInclude(java.lang.Object haystack, java.lang.Object needle)`
`static boolean`	`notDeepNestedInclude(java.lang.Object haystack, java.lang.Object needle, java.lang.String message)` ### .notDeepNestedInclude(haystack, needle, [message]) Asserts that 'haystack' does not include 'needle'.
`static boolean`	`notDeepNestedPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val)`
`static boolean`	`notDeepNestedPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val, java.lang.String msg)` ### .deepNestedPropertyVal(object, property, value, [message]) Asserts that `object` does _not_ have a property named by `property` with value given by `value`.
`static boolean`	`notDeepOwnInclude(java.lang.Object haystack, java.lang.Object needle)`
`static boolean`	`notDeepOwnInclude(java.lang.Object haystack, java.lang.Object needle, java.lang.String message)` ### .notDeepOwnInclude(haystack, needle, [message]) Asserts that 'haystack' includes 'needle'.
`static boolean`	`notDeepOwnPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object value)`
`static boolean`	`notDeepOwnPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object value, java.lang.String msg)` ### .notDeepOwnPropertyVal(object, property, value, [message]) Asserts that `object` does _not_ have a direct property named by `property` with a value equal to the provided `value`.
`static boolean`	`notDeepPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val)`
`static boolean`	`notDeepPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val, java.lang.String msg)` ### .notDeepPropertyVal(object, property, value, [message]) Asserts that `object` does _not_ have a direct or inherited property named by `property` with value given by `value`.
`static boolean`	`notEmpty(java.lang.Object obj)`
`static boolean`	`notEmpty(java.lang.Object obj, java.lang.String msg)`
`static boolean`	`notEqual(java.lang.Object act, java.lang.Object exp)`
`static boolean`	`notEqual(java.lang.Object act, java.lang.Object exp, java.lang.String msg)` ### .notEqual(actual, expected, [message]) Asserts non-strict inequality (`!
`static boolean`	`notExists(java.lang.Object val)`
`static boolean`	`notExists(java.lang.Object val, java.lang.String msg)` ### .notExists Asserts that the target is either `null` or `undefined`.
`static boolean`	`notInclude(java.lang.Object haystack, java.lang.Object needle)`
`static boolean`	`notInclude(java.lang.Object haystack, java.lang.Object needle, java.lang.String message)` ### .notInclude(haystack, needle, [message]) Asserts that `haystack` does not include `needle`.
`static boolean`	`notInstanceOf(java.lang.Object val, java.lang.Object type)`
`static boolean`	`notInstanceOf(java.lang.Object val, java.lang.Object type, java.lang.String msg)` ### .notInstanceOf(object, constructor, [message]) Asserts `value` is not an instance of `constructor`.
`static boolean`	`notMatch(java.lang.String exp, java.util.regex.Pattern re)`
`static boolean`	`notMatch(java.lang.String exp, java.util.regex.Pattern re, java.lang.String msg)` ### .notMatch(value, regexp, [message]) Asserts that `value` does not match the regular expression `regexp`.
`static boolean`	`notMatch(java.lang.String exp, java.lang.String re)`
`static boolean`	`notMatch(java.lang.String exp, java.lang.String re, java.lang.String msg)`
`static boolean`	`notNestedInclude(java.lang.Object haystack, java.lang.Object needle)`
`static boolean`	`notNestedInclude(java.lang.Object haystack, java.lang.Object needle, java.lang.String message)` ### .notNestedInclude(haystack, needle, [message]) Asserts that 'haystack' does not include 'needle'.
`static boolean`	`notNestedProperty(java.lang.Object obj, java.lang.String prop)`
`static boolean`	`notNestedProperty(java.lang.Object obj, java.lang.String prop, java.lang.String msg)` ### .notNestedProperty(object, property, [message]) Asserts that `object` does _not_ have a property named by `property`, which can be a string using dot- and bracket-notation for nested reference.
`static boolean`	`notNestedPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val)`
`static boolean`	`notNestedPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val, java.lang.String msg)` ### .notNestedPropertyVal(object, property, value, [message]) Asserts that `object` does _not_ have a property named by `property` with value given by `value`.
`static boolean`	`notOk(java.lang.Object val)`
`static boolean`	`notOk(java.lang.Object val, java.lang.String msg)`
`static boolean`	`notOwnInclude(java.lang.Object haystack, java.lang.Object needle)`
`static boolean`	`notOwnInclude(java.lang.Object haystack, java.lang.Object needle, java.lang.String message)` ### .notOwnInclude(haystack, needle, [message]) Asserts that 'haystack' includes 'needle'.
`static boolean`	`notOwnProperty(java.lang.Object obj, java.lang.String prop)`
`static boolean`	`notOwnProperty(java.lang.Object obj, java.lang.String prop, java.lang.String msg)` ### .notOwnProperty(object, property, [message]) Asserts that `object` does _not_ have a direct property named by `property`.
`static boolean`	`notOwnPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object value)`
`static boolean`	`notOwnPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object value, java.lang.String msg)` ### .notOwnPropertyVal(object, property, value, [message]) Asserts that `object` does _not_ have a direct property named by `property` with a value equal to the provided `value`.
`static boolean`	`notProperty(java.lang.Object obj, java.lang.String prop)`
`static boolean`	`notProperty(java.lang.Object obj, java.lang.String prop, java.lang.String msg)` ### .notProperty(object, property, [message]) Asserts that `object` does _not_ have a direct or inherited property named by `property`.
`static boolean`	`notPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val)`
`static boolean`	`notPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val, java.lang.String msg)` ### .notPropertyVal(object, property, value, [message]) Asserts that `object` does _not_ have a direct or inherited property named by `property` with value given by `value`.
`static boolean`	`notStrictEqual(java.lang.Object act, java.lang.Object exp)`
`static boolean`	`notStrictEqual(java.lang.Object act, java.lang.Object exp, java.lang.String msg)` ### .notStrictEqual(actual, expected, [message]) Asserts strict inequality of `actual` and `expected`.
`static boolean`	`notStrictInclude(java.lang.Object haystack, java.lang.Object needle)`
`static boolean`	`notStrictInclude(java.lang.Object haystack, java.lang.Object needle, java.lang.String message)` ### .notStrictInclude(haystack, needle, [message]) Asserts that `haystack` does not include `needle`.
`static boolean`	`notStrictNestedInclude(java.lang.Object haystack, java.lang.Object needle)`
`static boolean`	`notStrictNestedInclude(java.lang.Object haystack, java.lang.Object needle, java.lang.String message)` ### .notStrictNestedInclude(haystack, needle, [message]) Asserts that 'haystack' does not include 'needle'.
`static boolean`	`notStrictNestedPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val)`
`static boolean`	`notStrictNestedPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val, java.lang.String msg)` ### .notStrictNestedPropertyVal(object, property, value, [message]) Asserts that `object` does _not_ have a property named by `property` with value given by `value`.
`static boolean`	`notStrictOwnInclude(java.lang.Object haystack, java.lang.Object needle)`
`static boolean`	`notStrictOwnInclude(java.lang.Object haystack, java.lang.Object needle, java.lang.String message)` ### .notStrictOwnInclude(haystack, needle, [message]) Asserts that 'haystack' includes 'needle'.
`static boolean`	`notStrictOwnPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object value)`
`static boolean`	`notStrictOwnPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object value, java.lang.String msg)` ### .notStrictOwnPropertyVal(object, property, value, [message]) Asserts that `object` does _not_ have a direct property named by `property` with a value equal to the provided `value`.
`static boolean`	`notStrictPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val)`
`static boolean`	`notStrictPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val, java.lang.String msg)` ### .notStrictPropertyVal(object, property, value, [message]) Asserts that `object` does _not_ have a direct or inherited property named by `property` with value given by `value`.
`static boolean`	`notTypeOf(java.lang.Object value, java.lang.Object type)`
`static boolean`	`notTypeOf(java.lang.Object value, java.lang.Object type, java.lang.String message)` ### .notTypeOf(value, name, [message]) Asserts that `value`'s type is _not_ `name`, as determined by `Object.prototype.getTo()String`.
`static boolean`	`ok(java.lang.Object val)`
`static boolean`	`ok(java.lang.Object val, java.lang.String msg)`
`static boolean`	`ownInclude(java.lang.Object haystack, java.lang.Object needle)`
`static boolean`	`ownInclude(java.lang.Object haystack, java.lang.Object needle, java.lang.String message)` ### .ownInclude(haystack, needle, [message]) Asserts that 'haystack' includes 'needle'.
`static boolean`	`ownProperty(java.lang.Object obj, java.lang.String prop)`
`static boolean`	`ownProperty(java.lang.Object obj, java.lang.String prop, java.lang.String msg)` ### .ownProperty(object, property, [message]) Asserts that `object` has a direct property named by `property`.
`static boolean`	`ownPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object value)`
`static boolean`	`ownPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object value, java.lang.String msg)` ### .ownPropertyVal(object, property, value, [message]) Asserts that `object` has a direct property named by `property` and a value equal to the provided `value`.
`static boolean`	`property(java.lang.Object obj, java.lang.String prop)`
`static boolean`	`property(java.lang.Object obj, java.lang.String prop, java.lang.String msg)` ### .property(object, property, [message]) Asserts that `object` has a direct or inherited property named by `property`.
`static boolean`	`propertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val)`
`static boolean`	`propertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val, java.lang.String msg)` ### .propertyVal(object, property, value, [message]) Asserts that `object` has a direct or inherited property named by `property` with a value given by `value`.
`static boolean`	`strictEqual(java.lang.Object act, java.lang.Object exp)`
`static boolean`	`strictEqual(java.lang.Object act, java.lang.Object exp, java.lang.String msg)` ### .strictEqual(actual, expected, [message]) Asserts strict equality of `actual` and `expected`.
`static boolean`	`strictInclude(java.lang.Object haystack, java.lang.Object needle)`
`static boolean`	`strictInclude(java.lang.Object haystack, java.lang.Object needle, java.lang.String message)` ### .strictInclude(haystack, needle, [message]) Asserts that `haystack` includes `needle`.
`static boolean`	`strictNestedInclude(java.lang.Object haystack, java.lang.Object needle)`
`static boolean`	`strictNestedInclude(java.lang.Object haystack, java.lang.Object needle, java.lang.String message)` ### .strictNestedInclude(haystack, needle, [message]) Asserts that 'haystack' includes 'needle'.
`static boolean`	`strictNestedPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val)`
`static boolean`	`strictNestedPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val, java.lang.String msg)` ### .strictNestedPropertyVal(object, property, value, [message]) Asserts that `object` has a property named by `property` with a value given by `value`.
`static boolean`	`strictOwnInclude(java.lang.Object haystack, java.lang.Object needle)`
`static boolean`	`strictOwnInclude(java.lang.Object haystack, java.lang.Object needle, java.lang.String message)` ### .strictOwnInclude(haystack, needle, [message]) Asserts that 'haystack' includes 'needle'.
`static boolean`	`strictOwnPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object value)`
`static boolean`	`strictOwnPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object value, java.lang.String msg)` ### .strictOwnPropertyVal(object, property, value, [message]) Asserts that `object` has a direct property named by `property` and a value equal to the provided `value`.
`static boolean`	`strictPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val)`
`static boolean`	`strictPropertyVal(java.lang.Object obj, java.lang.String prop, java.lang.Object val, java.lang.String msg)` ### .strictPropertyVal(object, property, value, [message]) Asserts that `object` has a direct or inherited property named by `property` with a value given by `value`.
`static boolean`	`test(boolean value, java.lang.String errmsg)`
`static boolean`	`test(java.util.function.BooleanSupplier expression, java.lang.String errmsg)` ### assert(expression, message) Write your own test expressions.
`static boolean`	`typeOf(java.lang.Object value, java.lang.Object type)`
`static boolean`	`typeOf(java.lang.Object value, java.lang.Object type, java.lang.String message)` ### .typeOf(value, name, [message]) Asserts that `value`'s type is `name`, as determined by its class.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Assert
```
public Assert()
```
- Method Detail
  - deepEqual
```
public static boolean deepEqual(java.lang.Object act,
                                java.lang.Object exp)
```
  - deepEqual
```
public static boolean deepEqual(java.lang.Object act,
                                java.lang.Object exp,
                                java.lang.String msg)
```
    ### .deepEqual(actual, expected, [message]) Asserts that `actual` is deeply equal to `expected`.
    
    Assert.deepEqual([ tea: 'green' ], [ tea: 'green' ])
    
    Parameters:
    
    {Object} - actual
    
    {Object} - expected
    
    {String} - message
  - deepInclude
```
public static boolean deepInclude(java.lang.Object haystack,
                                  java.lang.Object needle)
```
  - deepInclude
```
public static boolean deepInclude(java.lang.Object haystack,
                                  java.lang.Object needle,
                                  java.lang.String message)
```
    ### .deepInclude(haystack, needle, [message]) Asserts that `haystack` includes `needle`. Can be used to assert the inclusion of a value in an array or a subset of properties in an object. Deep equality is used. def obj1 = [a: 1] def obj2 = [b: 2]
    
    Assert.deepInclude([obj1, obj2], [a: 1])
    
    Assert.deepInclude([foo: obj1, bar: obj2], [foo: [a: 1]])
    
    Assert.deepInclude([foo: obj1, bar: obj2], [foo: [a: 1], bar: [b: 2]])
    
    Parameters:
    
    {Array|String} - haystack
    
    {Object} - needle
    
    {String} - message
  - deepNestedInclude
```
public static boolean deepNestedInclude(java.lang.Object haystack,
                                        java.lang.Object needle)
```
  - deepNestedInclude
```
public static boolean deepNestedInclude(java.lang.Object haystack,
                                        java.lang.Object needle,
                                        java.lang.String message)
```
    ### .deepNestedInclude(haystack, needle, [message]) Asserts that 'haystack' includes 'needle'. Can be used to assert the inclusion of a subset of properties in an object while checking for deep equality. Enables the use of dot- and bracket-notation for referencing nested properties. '[]' and '.' in property names can be escaped using double backslashes.
    
    Assert.deepNestedInclude([a: [b: [[x: 1]]]], ['a.b[0]': [x: 1]])
    
    Assert.deepNestedInclude(['.a': ['[b]': [x: 1]]], ['\\.a.\\[b\\]': [x: 1]])
    
    Parameters:
    
    {Object} - haystack
    
    {Object} - needle
    
    {String} - message
  - deepNestedPropertyVal
```
public static boolean deepNestedPropertyVal(java.lang.Object obj,
                                            java.lang.String prop,
                                            java.lang.Object val)
```
  - deepNestedPropertyVal
```
public static boolean deepNestedPropertyVal(java.lang.Object obj,
                                            java.lang.String prop,
                                            java.lang.Object val,
                                            java.lang.String msg)
```
    ### .deepNestedPropertyVal(object, property, value, [message]) Asserts that `object` has a property named by `property` with a value given by `value`. `property` can use dot- and bracket-notation for nested reference. Uses a deep equality check.
    
    Assert.deepNestedPropertyVal([ tea: [ green: [ matcha: 'yum' ] ] ], 'tea.green', [ matcha: 'yum' ])
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {Object} - value
    
    {String} - message
  - deepOwnInclude
```
public static boolean deepOwnInclude(java.lang.Object haystack,
                                     java.lang.Object needle)
```
  - deepOwnInclude
```
public static boolean deepOwnInclude(java.lang.Object haystack,
                                     java.lang.Object needle,
                                     java.lang.String message)
```
    ### .deepOwnInclude(haystack, needle, [message]) Asserts that 'haystack' includes 'needle'. Can be used to assert the inclusion of a subset of properties in an object while ignoring inherited properties and checking for deep equality. Assert.deepOwnInclude([a: [b: 2]], [a: [b: 2]])
    
    Parameters:
    
    {Object} - haystack
    
    {Object} - needle
    
    {String} - message
  - deepOwnPropertyVal
```
public static boolean deepOwnPropertyVal(java.lang.Object obj,
                                         java.lang.String prop,
                                         java.lang.Object value)
```
  - deepOwnPropertyVal
```
public static boolean deepOwnPropertyVal(java.lang.Object obj,
                                         java.lang.String prop,
                                         java.lang.Object value,
                                         java.lang.String msg)
```
    ### .deepOwnPropertyVal(object, property, value, [message]) Asserts that `object` has a direct property named by `property` and a value equal to the provided `value`. Uses a deep equality check. Inherited properties aren't checked.
    
    Assert.deepOwnPropertyVal([ tea: [ green: 'matcha' ] ], 'tea', [ green: 'matcha' ])
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {Object} - value
    
    {String} - message
  - deepPropertyVal
```
public static boolean deepPropertyVal(java.lang.Object obj,
                                      java.lang.String prop,
                                      java.lang.Object val)
```
  - deepPropertyVal
```
public static boolean deepPropertyVal(java.lang.Object obj,
                                      java.lang.String prop,
                                      java.lang.Object val,
                                      java.lang.String msg)
```
    ### .deepPropertyVal(object, property, value, [message]) Asserts that `object` has a direct or inherited property named by `property` with a value given by `value`. Uses a deep equality check.
    
    Assert.deepPropertyVal([ tea: [ green: 'matcha' ] ], 'tea', [ green: 'matcha' ])
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {Object} - value
    
    {String} - message
  - empty
```
public static boolean empty(java.lang.Object obj)
```
  - empty
```
public static boolean empty(java.lang.Object obj,
                            java.lang.String msg)
```
  - equal
```
public static boolean equal(java.lang.Object act,
                            java.lang.Object exp)
```
  - equal
```
public static boolean equal(java.lang.Object act,
                            java.lang.Object exp,
                            java.lang.String msg)
```
    ### .equal(actual, expected, [message]) Asserts non-strict equality (`==`) of `actual` and `expected`.
    
    Assert.equal(["bla"],["bla"], 'uses .equals()')
    
    Parameters:
    
    {Object} - actual
    
    {Object} - expected
    
    {String} - message
  - exists
```
public static boolean exists(java.lang.Object val)
```
  - exists
```
public static boolean exists(java.lang.Object val,
                             java.lang.String msg)
```
    ### .exists Asserts that the target is neither `null` nor `undefined`. def foo = 'hi'
    
    Assert.exists(foo, 'foo is neither `null` nor `undefined`')
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - fail
```
public static boolean fail()
```
    ### .fail([message]) ### .fail(actual, expected, [message], [operator]) Throw a failure.
    
    Assert.fail()
    
    Assert.fail("custom error message")
    
    Assert.fail(1, 2)
    
    Assert.fail(1, 2, "custom error message")
    
    Assert.fail(1, 2, "custom error message", ">")
    
    Assert.fail(1, 2, null, ">")
    
    Parameters:
    
    {Object} - actual
    
    {Object} - expected
    
    {String} - message
    
    {String} - operator
  - fail
```
public static boolean fail(java.lang.Object actual,
                           java.lang.Object expected)
```
  - fail
```
public static boolean fail(java.lang.Object actual,
                           java.lang.Object expected,
                           java.lang.String message)
```
  - fail
```
public static boolean fail(java.lang.Object actual,
                           java.lang.Object expected,
                           java.lang.String message,
                           java.lang.String operator)
```
  - fail
```
public static boolean fail(java.lang.Object actual,
                           java.lang.Object expected,
                           java.lang.String message,
                           java.lang.String operator,
                           java.lang.String ssfi)
```
  - fail
```
public static boolean fail(java.lang.String message)
```
  - include
```
public static boolean include(java.lang.Object haystack,
                              java.lang.Object needle)
```
  - include
```
public static boolean include(java.lang.Object haystack,
                              java.lang.Object needle,
                              java.lang.String message)
```
    ### .include(haystack, needle, [message]) Asserts that `haystack` includes `needle`. Can be used to assert the inclusion of a value in an array, a substring in a string, or a subset of properties in an object. Object equality (equals) is used. When asserting the inclusion of a value in an array, the array is searched for an element that's strictly equal to the given value. When asserting a subset of properties in an object, the object is searched for the given property keys, checking that each one is present and strictly equal to the given property value.
    
    Assert.include([1,2,3], 2, 'array contains value')
    
    Assert.include('foobar', 'foo', 'string contains substring')
    
    Assert.include([ foo: 'bar', hello: 'universe' ], [ foo: 'bar' ], 'object contains property') def obj1 = [a: 1] def obj2 = [b: 2]
    
    Assert.include([obj1, obj2], obj1)
    
    Assert.include([foo: obj1, bar: obj2], [foo: obj1])
    
    Assert.include([foo: obj1, bar: obj2], [foo: obj1, bar: obj2])
    
    Parameters:
    
    {Array|String} - haystack
    
    {Object} - needle
    
    {String} - message
  - instanceOf
```
public static boolean instanceOf(java.lang.Object val,
                                 java.lang.Object type)
```
  - instanceOf
```
public static boolean instanceOf(java.lang.Object val,
                                 java.lang.Object type,
                                 java.lang.String msg)
```
    ### .instanceOf(object, constructor, [message]) Asserts that `value` is an instance of `constructor`. class Tea { def Tea(def kind) {} } def chai = new Tea('chai')
    
    Assert.instanceOf(chai, Tea, 'chai is an instance of tea')
    
    Parameters:
    
    {Object} - object
    
    {Constructor} - constructor
    
    {String} - message
  - isArray
```
public static boolean isArray(java.lang.Object value)
```
  - isArray
```
public static boolean isArray(java.lang.Object value,
                              java.lang.String message)
```
    ### .isArray(value, [message]) Asserts that `value` is an array. def menu = [ 'green', 'chai', 'oolong' ]
    
    Assert.isArray(menu as String[], 'what kind of tea do we want?')
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - isBoolean
```
public static boolean isBoolean(java.lang.Object value)
```
  - isBoolean
```
public static boolean isBoolean(java.lang.Object value,
                                java.lang.String message)
```
    ### .isBoolean(value, [message]) Asserts that `value` is a boolean. def teaReady = true def teaServed = false
    
    Assert.isBoolean(teaReady, 'is the tea ready')
    
    Assert.isBoolean(teaServed, 'has tea been served')
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - isEmpty
```
public static boolean isEmpty(java.lang.Object obj)
```
  - isEmpty
```
public static boolean isEmpty(java.lang.Object obj,
                              java.lang.String msg)
```
    ### .isEmpty(target) Asserts that the target does not contain any values. For arrays and strings, it checks the `length` property. For `Map` and `Set` instances, it checks the `size` property. For non-function objects, it gets the count of own enumerable string keys.
    
    Assert.isEmpty([])
    
    Assert.isEmpty('')
    
    Assert.isEmpty(new HashMap())
    
    Assert.isEmpty([:])
    
    Parameters:
    
    {Object|Array|String|Map|Set} - target
    
    {String} - message _optional_
  - isFalse
```
public static boolean isFalse(java.lang.Object val)
```
  - isFalse
```
public static boolean isFalse(java.lang.Object val,
                              java.lang.String msg)
```
    ### .isFalse(value, [message]) Asserts that `value` is false. def teaServed = false
    
    Assert.isFalse(teaServed, 'no tea yet? hmm...')
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - isFunction
```
public static boolean isFunction(java.lang.Object value)
```
  - isFunction
```
public static boolean isFunction(java.lang.Object value,
                                 java.lang.String message)
```
    ### .isFunction(value, [message]) Asserts that `value` is a function. def serveTea() { return 'cup of tea' }
    
    Assert.isFunction(this.&serveTea, 'great, we can have tea now')
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - isList
```
public static boolean isList(java.lang.Object value)
```
  - isList
```
public static boolean isList(java.lang.Object value,
                             java.lang.String message)
```
    ### .isList(value, [message]) Asserts that `value` is a list. def menu = [ "green", "chai", "chai" ]
    
    Assert.isList(menu, "what kind of tea do we want?")
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - isMap
```
public static boolean isMap(java.lang.Object value)
```
  - isMap
```
public static boolean isMap(java.lang.Object value,
                            java.lang.String message)
```
    ### .isMap(value, [message]) Asserts that `value` is a map. def menu = ["green":1, "chai":2, "black":3 ]
    
    Assert.isMap(menu, "what kind of tea do we want?")
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - isNotArray
```
public static boolean isNotArray(java.lang.Object value)
```
  - isNotArray
```
public static boolean isNotArray(java.lang.Object value,
                                 java.lang.String message)
```
    ### .isNotArray(value, [message]) Asserts that `value` is _not_ an array. def menu = 'green|chai|oolong'
    
    Assert.isNotArray(menu, 'what kind of tea do we want?')
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - isNotBoolean
```
public static boolean isNotBoolean(java.lang.Object value)
```
  - isNotBoolean
```
public static boolean isNotBoolean(java.lang.Object value,
                                   java.lang.String message)
```
    ### .isNotBoolean(value, [message]) Asserts that `value` is _not_ a boolean. def teaReady = 'yep' def teaServed = 'nope'
    
    Assert.isNotBoolean(teaReady, 'is the tea ready')
    
    Assert.isNotBoolean(teaServed, 'has tea been served')
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - isNotEmpty
```
public static boolean isNotEmpty(java.lang.Object obj)
```
  - isNotEmpty
```
public static boolean isNotEmpty(java.lang.Object obj,
                                 java.lang.String msg)
```
    ### .isNotEmpty(target) Asserts that the target contains values. For arrays and strings, it checks the `length` property. For `Map` and `Set` instances, it checks the `size` property. For non-function objects, it gets the count of own enumerable string keys.
    
    Assert.isNotEmpty([1, 2])
    
    Assert.isNotEmpty('34')
    
    Assert.isNotEmpty(Set.of(5, 6))
    
    Assert.isNotEmpty([ key: 7 ])
    
    Parameters:
    
    {Object|Array|String|Map|Set} - target
    
    {String} - message _optional_
  - isNotFalse
```
public static boolean isNotFalse(java.lang.Object val)
```
  - isNotFalse
```
public static boolean isNotFalse(java.lang.Object val,
                                 java.lang.String msg)
```
    ### .isNotFalse(value, [message]) Asserts that `value` is not false. def tea = 'tasty chai'
    
    Assert.isNotFalse(tea, 'great, time for tea!')
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - isNotFunction
```
public static boolean isNotFunction(java.lang.Object value)
```
  - isNotFunction
```
public static boolean isNotFunction(java.lang.Object value,
                                    java.lang.String message)
```
    ### .isNotFunction(value, [message]) Asserts that `value` is _not_ a function. def serveTea = [ 'heat', 'pour', 'sip' ]
    
    Assert.isNotFunction(serveTea, 'great, we have listed the steps')
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - isNotList
```
public static boolean isNotList(java.lang.Object value)
```
  - isNotList
```
public static boolean isNotList(java.lang.Object value,
                                java.lang.String message)
```
    ### .isNotList(value, [message]) Asserts that `value` is _not_ a list. def menu = "green|chai|oolong"
    
    Assert.isNotList(menu, "what kind of tea do we want?")
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - isNotMap
```
public static boolean isNotMap(java.lang.Object value)
```
  - isNotMap
```
public static boolean isNotMap(java.lang.Object value,
                               java.lang.String message)
```
    ### .isNotMap(value, [message]) Asserts that `value` is _not_ a map. def menu = "green|chai|oolong"
    
    Assert.isNotMap(menu, "what kind of tea do we want?")
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - isNotNull
```
public static boolean isNotNull(java.lang.Object val)
```
  - isNotNull
```
public static boolean isNotNull(java.lang.Object val,
                                java.lang.String msg)
```
    ### .isNotNull(value, [message]) Asserts that `value` is not null. def tea = 'tasty chai'
    
    Assert.isNotNull(tea, 'great, time for tea!')
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - isNotNumber
```
public static boolean isNotNumber(java.lang.Object value)
```
  - isNotNumber
```
public static boolean isNotNumber(java.lang.Object value,
                                  java.lang.String message)
```
    ### .isNotNumber(value, [message]) Asserts that `value` is _not_ a number. def cups = '2 cups please'
    
    Assert.isNotNumber(cups, 'how many cups')
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - isNotObject
```
public static boolean isNotObject(boolean value)
```
  - isNotObject
```
public static boolean isNotObject(boolean value,
                                  java.lang.String message)
```
  - isNotObject
```
public static boolean isNotObject(byte value)
```
  - isNotObject
```
public static boolean isNotObject(byte value,
                                  java.lang.String message)
```
  - isNotObject
```
public static boolean isNotObject(char value)
```
  - isNotObject
```
public static boolean isNotObject(char value,
                                  java.lang.String message)
```
  - isNotObject
```
public static boolean isNotObject(double value)
```
  - isNotObject
```
public static boolean isNotObject(double value,
                                  java.lang.String message)
```
  - isNotObject
```
public static boolean isNotObject(float value)
```
  - isNotObject
```
public static boolean isNotObject(float value,
                                  java.lang.String message)
```
  - isNotObject
```
public static boolean isNotObject(int value)
```
  - isNotObject
```
public static boolean isNotObject(int value,
                                  java.lang.String message)
```
  - isNotObject
```
public static boolean isNotObject(long value)
```
  - isNotObject
```
public static boolean isNotObject(long value,
                                  java.lang.String message)
```
  - isNotObject
```
public static boolean isNotObject(java.lang.Object value)
```
  - isNotObject
```
public static boolean isNotObject(java.lang.Object value,
                                  java.lang.String message)
```
    ### .isNotObject(value, [message]) Asserts that `value` is _not_ an object of type 'Object' (as revealed by `Object.prototype.toString`). def selection = 23
    
    Assert.isNotObject(selection, 'selection 23 is not an object')
    
    Assert.isNotObject(null, 'null is not an object')
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - isNotObject
```
public static boolean isNotObject(short value)
```
  - isNotObject
```
public static boolean isNotObject(short value,
                                  java.lang.String message)
```
  - isNotOk
```
public static boolean isNotOk(java.lang.Object val)
```
  - isNotOk
```
public static boolean isNotOk(java.lang.Object val,
                              java.lang.String msg)
```
    ### .isNotOk(object, [message]) Asserts that `object` is falsy.
    
    Assert.isNotOk('', 'this will not fail')
    
    Assert.isNotOk(false, 'this will pass')
    
    Parameters:
    
    {Object} - object to test
    
    {String} - message
  - isNotString
```
public static boolean isNotString(java.lang.Object value)
```
  - isNotString
```
public static boolean isNotString(java.lang.Object value,
                                  java.lang.String message)
```
    ### .isNotString(value, [message]) Asserts that `value` is _not_ a string. def teaOrder = 4
    
    Assert.isNotString(teaOrder, 'order placed')
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - isNotTrue
```
public static boolean isNotTrue(java.lang.Object val)
```
  - isNotTrue
```
public static boolean isNotTrue(java.lang.Object val,
                                java.lang.String msg)
```
    ### .isNotTrue(value, [message]) Asserts that `value` is not true. def tea = 'tasty chai'
    
    Assert.isNotTrue(tea, 'great, time for tea!')
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - isNull
```
public static boolean isNull(java.lang.Object val)
```
  - isNull
```
public static boolean isNull(java.lang.Object val,
                             java.lang.String msg)
```
    ### .isNull(value, [message]) Asserts that `value` is null. def err = null
    
    Assert.isNull(err, 'there was no error')
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - isNumber
```
public static boolean isNumber(java.lang.Object value)
```
  - isNumber
```
public static boolean isNumber(java.lang.Object value,
                               java.lang.String message)
```
    ### .isNumber(value, [message]) Asserts that `value` is a number. def cups = 2
    
    Assert.isNumber(cups, 'how many cups')
    
    Parameters:
    
    {Number} - value
    
    {String} - message
  - isObject
```
public static boolean isObject(boolean value)
```
  - isObject
```
public static boolean isObject(boolean value,
                               java.lang.String message)
```
  - isObject
```
public static boolean isObject(byte value)
```
  - isObject
```
public static boolean isObject(byte value,
                               java.lang.String message)
```
  - isObject
```
public static boolean isObject(char value)
```
  - isObject
```
public static boolean isObject(char value,
                               java.lang.String message)
```
  - isObject
```
public static boolean isObject(double value)
```
  - isObject
```
public static boolean isObject(double value,
                               java.lang.String message)
```
  - isObject
```
public static boolean isObject(float value)
```
  - isObject
```
public static boolean isObject(float value,
                               java.lang.String message)
```
  - isObject
```
public static boolean isObject(int value)
```
  - isObject
```
public static boolean isObject(int value,
                               java.lang.String message)
```
  - isObject
```
public static boolean isObject(long value)
```
  - isObject
```
public static boolean isObject(long value,
                               java.lang.String message)
```
  - isObject
```
public static boolean isObject(java.lang.Object value)
```
  - isObject
```
public static boolean isObject(java.lang.Object value,
                               java.lang.String message)
```
    ### .isObject(value, [message]) Asserts that `value` is an object of type 'Object' (as revealed by `Object.prototype.toString`). _The assertion does not match subclassed objects._ def selection = [ name: 'Chai', serve: 'with spices' ]
    
    Assert.isObject(selection, 'tea selection is an object')
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - isObject
```
public static boolean isObject(short value)
```
  - isObject
```
public static boolean isObject(short value,
                               java.lang.String message)
```
  - isOk
```
public static boolean isOk(java.lang.Object val)
```
  - isOk
```
public static boolean isOk(java.lang.Object val,
                           java.lang.String msg)
```
    ### .isOk(object, [message]) Asserts that `object` is truthy.
    
    Assert.isOk('everything', 'everything is ok')
    
    Assert.isOk(true, 'this will not fail')
    
    Parameters:
    
    {Object} - object to test
    
    {String} - message
  - isString
```
public static boolean isString(java.lang.Object value)
```
  - isString
```
public static boolean isString(java.lang.Object value,
                               java.lang.String message)
```
    ### .isString(value, [message]) Asserts that `value` is a string. def teaOrder = 'chai'
    
    Assert.isString(teaOrder, 'order placed')
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - isTrue
```
public static boolean isTrue(java.lang.Object val)
```
  - isTrue
```
public static boolean isTrue(java.lang.Object val,
                             java.lang.String msg)
```
    ### .isTrue(value, [message]) Asserts that `value` is true. def teaServed = true
    
    Assert.isTrue(teaServed, 'the tea has been served')
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - lengthOf
```
public static boolean lengthOf(java.lang.Object obj,
                               int len)
```
  - lengthOf
```
public static boolean lengthOf(java.lang.Object obj,
                               int len,
                               java.lang.String msg)
```
    ### .lengthOf(object, length, [message]) Asserts that `object` has a `length` or `size` with the expected value.
    
    Assert.lengthOf([1,2,3], 3, 'array has length of 3')
    
    Assert.lengthOf('foobar', 6, 'string has length of 6')
    
    Assert.lengthOf(Set.of(1,2,3), 3, 'set has size of 3')
    
    Assert.lengthOf(['a':1,'b':2,'c':3], 3, 'map has size of 3')
    
    Parameters:
    
    {Object} - object
    
    {Number} - length
    
    {String} - message
  - match
```
public static boolean match(java.lang.String exp,
                            java.util.regex.Pattern re)
```
  - match
```
public static boolean match(java.lang.String exp,
                            java.util.regex.Pattern re,
                            java.lang.String msg)
```
    ### .match(value, regexp, [message]) Asserts that `value` matches the regular expression `regexp`.
    
    Assert.match('foobar', /^foo/, 'regexp matches')
    
    Parameters:
    
    {Object} - value
    
    {RegExp} - regexp
    
    {String} - message
  - match
```
public static boolean match(java.lang.String exp,
                            java.lang.String re)
```
  - match
```
public static boolean match(java.lang.String exp,
                            java.lang.String re,
                            java.lang.String msg)
```
  - nestedInclude
```
public static boolean nestedInclude(java.lang.Object haystack,
                                    java.lang.Object needle)
```
  - nestedInclude
```
public static boolean nestedInclude(java.lang.Object haystack,
                                    java.lang.Object needle,
                                    java.lang.String message)
```
    ### .nestedInclude(haystack, needle, [message]) Asserts that 'haystack' includes 'needle'. Can be used to assert the inclusion of a subset of properties in an object. Enables the use of dot- and bracket-notation for referencing nested properties. '[]' and '.' in property names can be escaped using double backslashes.
    
    Assert.nestedInclude(['.a': ['b': 'x']], ['\\.a.b': 'x'])
    
    Assert.nestedInclude(['a': ['[b]': 'x']], ['a.\\[b\\]': 'x'])
    
    Parameters:
    
    {Object} - haystack
    
    {Object} - needle
    
    {String} - message
  - nestedProperty
```
public static boolean nestedProperty(java.lang.Object obj,
                                     java.lang.String prop)
```
  - nestedProperty
```
public static boolean nestedProperty(java.lang.Object obj,
                                     java.lang.String prop,
                                     java.lang.String msg)
```
    ### .nestedProperty(object, property, [message]) Asserts that `object` has a direct or inherited property named by `property`, which can be a string using dot- and bracket-notation for nested reference.
    
    Assert.nestedProperty([ tea: [ green: 'matcha' ]], 'tea.green')
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {String} - message
  - nestedPropertyVal
```
public static boolean nestedPropertyVal(java.lang.Object obj,
                                        java.lang.String prop,
                                        java.lang.Object val)
```
  - nestedPropertyVal
```
public static boolean nestedPropertyVal(java.lang.Object obj,
                                        java.lang.String prop,
                                        java.lang.Object val,
                                        java.lang.String msg)
```
    ### .nestedPropertyVal(object, property, value, [message]) Asserts that `object` has a property named by `property` with value given by `value`. `property` can use dot- and bracket-notation for nested reference. Object equality (equals) is used.
    
    Assert.nestedPropertyVal([ tea: [ green: 'matcha' ]], 'tea.green', 'matcha')
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {Object} - value
    
    {String} - message
  - notDeepEqual
```
public static boolean notDeepEqual(java.lang.Object act,
                                   java.lang.Object exp)
```
  - notDeepEqual
```
public static boolean notDeepEqual(java.lang.Object act,
                                   java.lang.Object exp,
                                   java.lang.String msg)
```
    ### .notDeepEqual(actual, expected, [message]) Assert that `actual` is not deeply equal to `expected`.
    
    Assert.notDeepEqual([ tea: 'green' ], [ tea: 'jasmine' ])
    
    Parameters:
    
    {Object} - actual
    
    {Object} - expected
    
    {String} - message
  - notDeepInclude
```
public static boolean notDeepInclude(java.lang.Object haystack,
                                     java.lang.Object needle)
```
  - notDeepInclude
```
public static boolean notDeepInclude(java.lang.Object haystack,
                                     java.lang.Object needle,
                                     java.lang.String message)
```
    ### .notDeepInclude(haystack, needle, [message]) Asserts that `haystack` does not include `needle`. Can be used to assert the absence of a value in an array or a subset of properties in an object. Deep equality is used. def obj1 = [a: 1] def obj2 = [b: 2]
    
    Assert.notDeepInclude([obj1, obj2], [a: 9])
    
    Assert.notDeepInclude([foo: obj1, bar: obj2], [foo: [a: 9]])
    
    Assert.notDeepInclude([foo: obj1, bar: obj2], [foo: [a: 1], bar: [b: 9]])
    
    Parameters:
    
    {Array|String} - haystack
    
    {Object} - needle
    
    {String} - message
  - notDeepNestedInclude
```
public static boolean notDeepNestedInclude(java.lang.Object haystack,
                                           java.lang.Object needle)
```
  - notDeepNestedInclude
```
public static boolean notDeepNestedInclude(java.lang.Object haystack,
                                           java.lang.Object needle,
                                           java.lang.String message)
```
    ### .notDeepNestedInclude(haystack, needle, [message]) Asserts that 'haystack' does not include 'needle'. Can be used to assert the absence of a subset of properties in an object while checking for deep equality. Enables the use of dot- and bracket-notation for referencing nested properties. '[]' and '.' in property names can be escaped using double backslashes.
    
    Assert.notDeepNestedInclude([a: [b: [[x: 1]]]], ['a.b[0]': [y: 1]])
    
    Assert.notDeepNestedInclude(['.a': ['[b]': [x: 1]]], ['\\.a.\\[b\\]': [y: 2]])
    
    Parameters:
    
    {Object} - haystack
    
    {Object} - needle
    
    {String} - message
  - notDeepNestedPropertyVal
```
public static boolean notDeepNestedPropertyVal(java.lang.Object obj,
                                               java.lang.String prop,
                                               java.lang.Object val)
```
  - notDeepNestedPropertyVal
```
public static boolean notDeepNestedPropertyVal(java.lang.Object obj,
                                               java.lang.String prop,
                                               java.lang.Object val,
                                               java.lang.String msg)
```
    ### .deepNestedPropertyVal(object, property, value, [message]) Asserts that `object` does _not_ have a property named by `property` with value given by `value`. `property` can use dot- and bracket-notation for nested reference. Uses a deep equality check.
    
    Assert.notDeepNestedPropertyVal([ tea: [ green: [ matcha: 'yum' ] ] ], 'tea.green', [ oolong: 'yum' ])
    
    Assert.notDeepNestedPropertyVal([ tea: [ green: [ matcha: 'yum' ] ] ], 'tea.green', [ matcha: 'yuck' ])
    
    Assert.notDeepNestedPropertyVal([ tea: [ green: [ matcha: 'yum' ] ] ], 'tea.black', [ matcha: 'yum' ])
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {Object} - value
    
    {String} - message
  - notDeepOwnInclude
```
public static boolean notDeepOwnInclude(java.lang.Object haystack,
                                        java.lang.Object needle)
```
  - notDeepOwnInclude
```
public static boolean notDeepOwnInclude(java.lang.Object haystack,
                                        java.lang.Object needle,
                                        java.lang.String message)
```
    ### .notDeepOwnInclude(haystack, needle, [message]) Asserts that 'haystack' includes 'needle'. Can be used to assert the absence of a subset of properties in an object while ignoring inherited properties and checking for deep equality. Assert.notDeepOwnInclude([a: [b: 2]], [a: [c: 3]])
    
    Parameters:
    
    {Object} - haystack
    
    {Object} - needle
    
    {String} - message
  - notDeepOwnPropertyVal
```
public static boolean notDeepOwnPropertyVal(java.lang.Object obj,
                                            java.lang.String prop,
                                            java.lang.Object value)
```
  - notDeepOwnPropertyVal
```
public static boolean notDeepOwnPropertyVal(java.lang.Object obj,
                                            java.lang.String prop,
                                            java.lang.Object value,
                                            java.lang.String msg)
```
    ### .notDeepOwnPropertyVal(object, property, value, [message]) Asserts that `object` does _not_ have a direct property named by `property` with a value equal to the provided `value`. Uses a deep equality check. Inherited properties aren't checked.
    
    Assert.notDeepOwnPropertyVal([ tea: [ green: 'matcha' ] ], 'tea', [ black: 'matcha' ])
    
    Assert.notDeepOwnPropertyVal([ tea: [ green: 'matcha' ] ], 'tea', [ green: 'oolong' ])
    
    Assert.notDeepOwnPropertyVal([ tea: [ green: 'matcha' ] ], 'coffee', [ green: 'matcha' ])
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {Object} - value
    
    {String} - message
  - notDeepPropertyVal
```
public static boolean notDeepPropertyVal(java.lang.Object obj,
                                         java.lang.String prop,
                                         java.lang.Object val)
```
  - notDeepPropertyVal
```
public static boolean notDeepPropertyVal(java.lang.Object obj,
                                         java.lang.String prop,
                                         java.lang.Object val,
                                         java.lang.String msg)
```
    ### .notDeepPropertyVal(object, property, value, [message]) Asserts that `object` does _not_ have a direct or inherited property named by `property` with value given by `value`. Uses a deep equality check.
    
    Assert.notDeepPropertyVal([ tea: [ green: 'matcha' ] ], 'tea', [ black: 'matcha' ])
    
    Assert.notDeepPropertyVal([ tea: [ green: 'matcha' ] ], 'tea', [ green: 'oolong' ])
    
    Assert.notDeepPropertyVal([ tea: [ green: 'matcha' ] ], 'coffee', [ green: 'matcha' ])
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {Object} - value
    
    {String} - message
  - notEmpty
```
public static boolean notEmpty(java.lang.Object obj)
```
  - notEmpty
```
public static boolean notEmpty(java.lang.Object obj,
                               java.lang.String msg)
```
  - notEqual
```
public static boolean notEqual(java.lang.Object act,
                               java.lang.Object exp)
```
  - notEqual
```
public static boolean notEqual(java.lang.Object act,
                               java.lang.Object exp,
                               java.lang.String msg)
```
    ### .notEqual(actual, expected, [message]) Asserts non-strict inequality (`!=`) of `actual` and `expected`.
    
    Assert.notEqual(3, 4, 'these numbers are not equal')
    
    Parameters:
    
    {Object} - actual
    
    {Object} - expected
    
    {String} - message
  - notExists
```
public static boolean notExists(java.lang.Object val)
```
  - notExists
```
public static boolean notExists(java.lang.Object val,
                                java.lang.String msg)
```
    ### .notExists Asserts that the target is either `null` or `undefined`. def bar = null def baz
    
    Assert.notExists(bar)
    
    Assert.notExists(baz, 'baz is either null or undefined')
    
    Parameters:
    
    {Object} - value
    
    {String} - message
  - notInclude
```
public static boolean notInclude(java.lang.Object haystack,
                                 java.lang.Object needle)
```
  - notInclude
```
public static boolean notInclude(java.lang.Object haystack,
                                 java.lang.Object needle,
                                 java.lang.String message)
```
    ### .notInclude(haystack, needle, [message]) Asserts that `haystack` does not include `needle`. Can be used to assert the absence of a value in an array, a substring in a string, or a subset of properties in an object. Object equality (equals) is used. When asserting the absence of a value in an array, the array is searched to confirm the absence of an element that's strictly equal to the given value. When asserting a subset of properties in an object, the object is searched to confirm that at least one of the given property keys is either not present or not strictly equal to the given property value.
    
    Assert.notInclude([1,2,3], 4, "array doesn't contain value")
    
    Assert.notInclude('foobar', 'baz', "string doesn't contain substring")
    
    Assert.notInclude([ foo: 'bar', hello: 'universe' ], [ foo: 'baz' ], "object doesn't contain property") def obj1 = [a: 1] def obj2 = [b: 2]
    
    Assert.notInclude([obj1, obj2], [a: 2])
    
    Assert.notInclude([foo: obj1, bar: obj2], [foo: [a: 2]])
    
    Parameters:
    
    {Array|String} - haystack
    
    {Object} - needle
    
    {String} - message
  - notInstanceOf
```
public static boolean notInstanceOf(java.lang.Object val,
                                    java.lang.Object type)
```
  - notInstanceOf
```
public static boolean notInstanceOf(java.lang.Object val,
                                    java.lang.Object type,
                                    java.lang.String msg)
```
    ### .notInstanceOf(object, constructor, [message]) Asserts `value` is not an instance of `constructor`. class Tea { def Tea(def kind) {} } def chai = new String('chai')
    
    Assert.notInstanceOf(chai, Tea, 'chai is not an instance of tea')
    
    Parameters:
    
    {Object} - object
    
    {Constructor} - constructor
    
    {String} - message
  - notMatch
```
public static boolean notMatch(java.lang.String exp,
                               java.util.regex.Pattern re)
```
  - notMatch
```
public static boolean notMatch(java.lang.String exp,
                               java.util.regex.Pattern re,
                               java.lang.String msg)
```
    ### .notMatch(value, regexp, [message]) Asserts that `value` does not match the regular expression `regexp`.
    
    Assert.notMatch('foobar', /^bar/, 'regexp does not match')
    
    Parameters:
    
    {Object} - value
    
    {RegExp} - regexp
    
    {String} - message
  - notMatch
```
public static boolean notMatch(java.lang.String exp,
                               java.lang.String re)
```
  - notMatch
```
public static boolean notMatch(java.lang.String exp,
                               java.lang.String re,
                               java.lang.String msg)
```
  - notNestedInclude
```
public static boolean notNestedInclude(java.lang.Object haystack,
                                       java.lang.Object needle)
```
  - notNestedInclude
```
public static boolean notNestedInclude(java.lang.Object haystack,
                                       java.lang.Object needle,
                                       java.lang.String message)
```
    ### .notNestedInclude(haystack, needle, [message]) Asserts that 'haystack' does not include 'needle'. Can be used to assert the absence of a subset of properties in an object. Enables the use of dot- and bracket-notation for referencing nested properties. '[]' and '.' in property names can be escaped using double backslashes.
    
    Assert.notNestedInclude(['.a': ['b': 'x']], ['\\.a.b': 'y'])
    
    Assert.notNestedInclude(['a': ['[b]': 'x']], ['a.\\[b\\]': 'y'])
    
    Parameters:
    
    {Object} - haystack
    
    {Object} - needle
    
    {String} - message
  - notNestedProperty
```
public static boolean notNestedProperty(java.lang.Object obj,
                                        java.lang.String prop)
```
  - notNestedProperty
```
public static boolean notNestedProperty(java.lang.Object obj,
                                        java.lang.String prop,
                                        java.lang.String msg)
```
    ### .notNestedProperty(object, property, [message]) Asserts that `object` does _not_ have a property named by `property`, which can be a string using dot- and bracket-notation for nested reference. The property cannot exist on the object nor anywhere in its prototype chain.
    
    Assert.notNestedProperty([ tea: [ green: 'matcha' ]], 'tea.oolong')
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {String} - message
  - notNestedPropertyVal
```
public static boolean notNestedPropertyVal(java.lang.Object obj,
                                           java.lang.String prop,
                                           java.lang.Object val)
```
  - notNestedPropertyVal
```
public static boolean notNestedPropertyVal(java.lang.Object obj,
                                           java.lang.String prop,
                                           java.lang.Object val,
                                           java.lang.String msg)
```
    ### .notNestedPropertyVal(object, property, value, [message]) Asserts that `object` does _not_ have a property named by `property` with value given by `value`. `property` can use dot- and bracket-notation for nested reference. Uses a strict equality check (===).
    
    Assert.notNestedPropertyVal([ tea: [ green: 'matcha' ]], 'tea.green', 'konacha')
    
    Assert.notNestedPropertyVal([ tea: [ green: 'matcha' ]], 'coffee.green', 'matcha')
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {Object} - value
    
    {String} - message
  - notOk
```
public static boolean notOk(java.lang.Object val)
```
  - notOk
```
public static boolean notOk(java.lang.Object val,
                            java.lang.String msg)
```
  - notOwnInclude
```
public static boolean notOwnInclude(java.lang.Object haystack,
                                    java.lang.Object needle)
```
  - notOwnInclude
```
public static boolean notOwnInclude(java.lang.Object haystack,
                                    java.lang.Object needle,
                                    java.lang.String message)
```
    ### .notOwnInclude(haystack, needle, [message]) Asserts that 'haystack' includes 'needle'. Can be used to assert the absence of a subset of properties in an object while ignoring inherited properties.
    
    Assert.notOwnInclude([ a: 1 ], [ b: 2 ])
    
    Parameters:
    
    {Object} - haystack
    
    {Object} - needle
    
    {String} - message
  - notOwnProperty
```
public static boolean notOwnProperty(java.lang.Object obj,
                                     java.lang.String prop)
```
  - notOwnProperty
```
public static boolean notOwnProperty(java.lang.Object obj,
                                     java.lang.String prop,
                                     java.lang.String msg)
```
    ### .notOwnProperty(object, property, [message]) Asserts that `object` does _not_ have a direct property named by `property`. Inherited properties aren't checked.
    
    Assert.notOwnProperty([ tea: [ green: 'matcha' ]], 'coffee')
    
    Assert.notOwnProperty([], 'toString')
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {String} - message
  - notOwnPropertyVal
```
public static boolean notOwnPropertyVal(java.lang.Object obj,
                                        java.lang.String prop,
                                        java.lang.Object value)
```
  - notOwnPropertyVal
```
public static boolean notOwnPropertyVal(java.lang.Object obj,
                                        java.lang.String prop,
                                        java.lang.Object value,
                                        java.lang.String msg)
```
    ### .notOwnPropertyVal(object, property, value, [message]) Asserts that `object` does _not_ have a direct property named by `property` with a value equal to the provided `value`. Object equality (equals) is used. Inherited properties aren't checked.
    
    Assert.notOwnPropertyVal([ tea: 'is better'], 'tea', 'is worse')
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {Object} - value
    
    {String} - message
  - notProperty
```
public static boolean notProperty(java.lang.Object obj,
                                  java.lang.String prop)
```
  - notProperty
```
public static boolean notProperty(java.lang.Object obj,
                                  java.lang.String prop,
                                  java.lang.String msg)
```
    ### .notProperty(object, property, [message]) Asserts that `object` does _not_ have a direct or inherited property named by `property`.
    
    Assert.notProperty([ tea: [ green: 'matcha' ]], 'coffee')
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {String} - message
  - notPropertyVal
```
public static boolean notPropertyVal(java.lang.Object obj,
                                     java.lang.String prop,
                                     java.lang.Object val)
```
  - notPropertyVal
```
public static boolean notPropertyVal(java.lang.Object obj,
                                     java.lang.String prop,
                                     java.lang.Object val,
                                     java.lang.String msg)
```
    ### .notPropertyVal(object, property, value, [message]) Asserts that `object` does _not_ have a direct or inherited property named by `property` with value given by `value`. Object equality (equals) is used.
    
    Assert.notPropertyVal([ tea: 'is good' ], 'tea', 'is bad')
    
    Assert.notPropertyVal([ tea: 'is good' ], 'coffee', 'is good')
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {Object} - value
    
    {String} - message
  - notStrictEqual
```
public static boolean notStrictEqual(java.lang.Object act,
                                     java.lang.Object exp)
```
  - notStrictEqual
```
public static boolean notStrictEqual(java.lang.Object act,
                                     java.lang.Object exp,
                                     java.lang.String msg)
```
    ### .notStrictEqual(actual, expected, [message]) Asserts strict inequality of `actual` and `expected`.
    
    Assert.notStrictEqual(3, '3', 'no coercion for strict equality')
    
    Parameters:
    
    {Object} - actual
    
    {Object} - expected
    
    {String} - message
  - notStrictInclude
```
public static boolean notStrictInclude(java.lang.Object haystack,
                                       java.lang.Object needle)
```
  - notStrictInclude
```
public static boolean notStrictInclude(java.lang.Object haystack,
                                       java.lang.Object needle,
                                       java.lang.String message)
```
    ### .notStrictInclude(haystack, needle, [message]) Asserts that `haystack` does not include `needle`. Can be used to assert the absence of a value in an array or a subset of properties in an object. Strict equality is used. def obj1 = [a: 1] def obj2 = [b: 2]
    
    Assert.notStrictInclude([obj1, obj2], [a: 9])
    
    Assert.notStrictInclude([foo: obj1, bar: obj2], [foo: [a: 9]])
    
    Assert.notStrictInclude([foo: obj1, bar: obj2], [foo: [a: 1], bar: [b: 9]])
    
    Parameters:
    
    {Array|String} - haystack
    
    {Object} - needle
    
    {String} - message
  - notStrictNestedInclude
```
public static boolean notStrictNestedInclude(java.lang.Object haystack,
                                             java.lang.Object needle)
```
  - notStrictNestedInclude
```
public static boolean notStrictNestedInclude(java.lang.Object haystack,
                                             java.lang.Object needle,
                                             java.lang.String message)
```
    ### .notStrictNestedInclude(haystack, needle, [message]) Asserts that 'haystack' does not include 'needle'. Can be used to assert the absence of a subset of properties in an object while checking for strict equality. Enables the use of dot- and bracket-notation for referencing nested properties. '[]' and '.' in property names can be escaped using double backslashes.
    
    Assert.notStrictNestedInclude([a: [b: [[x: 1]]]], ['a.b[0]': [y: 1]])
    
    Assert.notStrictNestedInclude(['.a': ['[b]': [x: 1]]], ['\\.a.\\[b\\]': [y: 2]])
    
    Parameters:
    
    {Object} - haystack
    
    {Object} - needle
    
    {String} - message
  - notStrictNestedPropertyVal
```
public static boolean notStrictNestedPropertyVal(java.lang.Object obj,
                                                 java.lang.String prop,
                                                 java.lang.Object val)
```
  - notStrictNestedPropertyVal
```
public static boolean notStrictNestedPropertyVal(java.lang.Object obj,
                                                 java.lang.String prop,
                                                 java.lang.Object val,
                                                 java.lang.String msg)
```
    ### .notStrictNestedPropertyVal(object, property, value, [message]) Asserts that `object` does _not_ have a property named by `property` with value given by `value`. `property` can use dot- and bracket-notation for nested reference. Uses a deep equality check.
    
    Assert.notStrictNestedPropertyVal([ tea: [ green: [ matcha: 'yum' ] ] ], 'tea.green', [ oolong: 'yum' ])
    
    Assert.notStrictNestedPropertyVal([ tea: [ green: [ matcha: 'yum' ] ] ], 'tea.green', [ matcha: 'yuck' ])
    
    Assert.notStrictNestedPropertyVal([ tea: [ green: [ matcha: 'yum' ] ] ], 'tea.black', [ matcha: 'yum' ])
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {Object} - value
    
    {String} - message
  - notStrictOwnInclude
```
public static boolean notStrictOwnInclude(java.lang.Object haystack,
                                          java.lang.Object needle)
```
  - notStrictOwnInclude
```
public static boolean notStrictOwnInclude(java.lang.Object haystack,
                                          java.lang.Object needle,
                                          java.lang.String message)
```
    ### .notStrictOwnInclude(haystack, needle, [message]) Asserts that 'haystack' includes 'needle'. Can be used to assert the absence of a subset of properties in an object while ignoring inherited properties and checking for strict equality. Assert.notStrictOwnInclude([a: [b: 2]], [a: [c: 3]])
    
    Parameters:
    
    {Object} - haystack
    
    {Object} - needle
    
    {String} - message
  - notStrictOwnPropertyVal
```
public static boolean notStrictOwnPropertyVal(java.lang.Object obj,
                                              java.lang.String prop,
                                              java.lang.Object value)
```
  - notStrictOwnPropertyVal
```
public static boolean notStrictOwnPropertyVal(java.lang.Object obj,
                                              java.lang.String prop,
                                              java.lang.Object value,
                                              java.lang.String msg)
```
    ### .notStrictOwnPropertyVal(object, property, value, [message]) Asserts that `object` does _not_ have a direct property named by `property` with a value equal to the provided `value`. Uses a strict equality check. Inherited properties aren't checked.
    
    Assert.notStrictOwnPropertyVal([ tea: [ green: 'matcha' ] ], 'tea', [ black: 'matcha' ])
    
    Assert.notStrictOwnPropertyVal([ tea: [ green: 'matcha' ] ], 'tea', [ green: 'oolong' ])
    
    Assert.notStrictOwnPropertyVal([ tea: [ green: 'matcha' ] ], 'coffee', [ green: 'matcha' ])
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {Object} - value
    
    {String} - message
  - notStrictPropertyVal
```
public static boolean notStrictPropertyVal(java.lang.Object obj,
                                           java.lang.String prop,
                                           java.lang.Object val)
```
  - notStrictPropertyVal
```
public static boolean notStrictPropertyVal(java.lang.Object obj,
                                           java.lang.String prop,
                                           java.lang.Object val,
                                           java.lang.String msg)
```
    ### .notStrictPropertyVal(object, property, value, [message]) Asserts that `object` does _not_ have a direct or inherited property named by `property` with value given by `value`. Uses a strict equality check.
    
    Assert.notStrictPropertyVal([ tea: [ green: 'matcha' ] ], 'tea', [ black: 'matcha' ])
    
    Assert.notStrictPropertyVal([ tea: [ green: 'matcha' ] ], 'tea', [ green: 'oolong' ])
    
    Assert.notStrictPropertyVal([ tea: [ green: 'matcha' ] ], 'coffee', [ green: 'matcha' ])
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {Object} - value
    
    {String} - message
  - notTypeOf
```
public static boolean notTypeOf(java.lang.Object value,
                                java.lang.Object type)
```
  - notTypeOf
```
public static boolean notTypeOf(java.lang.Object value,
                                java.lang.Object type,
                                java.lang.String message)
```
    ### .notTypeOf(value, name, [message]) Asserts that `value`'s type is _not_ `name`, as determined by `Object.prototype.getTo()String`.
    
    Assert.notTypeOf('tea', 'number', 'strings are not numbers')
    
    Parameters:
    
    {Object} - value
    
    {String} - typeof name
    
    {String} - message
  - ok
```
public static boolean ok(java.lang.Object val)
```
  - ok
```
public static boolean ok(java.lang.Object val,
                         java.lang.String msg)
```
  - ownInclude
```
public static boolean ownInclude(java.lang.Object haystack,
                                 java.lang.Object needle)
```
  - ownInclude
```
public static boolean ownInclude(java.lang.Object haystack,
                                 java.lang.Object needle,
                                 java.lang.String message)
```
    ### .ownInclude(haystack, needle, [message]) Asserts that 'haystack' includes 'needle'. Can be used to assert the inclusion of a subset of properties in an object while ignoring inherited properties.
    
    Assert.ownInclude([ a: 1 ], [ a: 1 ])
    
    Parameters:
    
    {Object} - haystack
    
    {Object} - needle
    
    {String} - message
  - ownProperty
```
public static boolean ownProperty(java.lang.Object obj,
                                  java.lang.String prop)
```
  - ownProperty
```
public static boolean ownProperty(java.lang.Object obj,
                                  java.lang.String prop,
                                  java.lang.String msg)
```
    ### .ownProperty(object, property, [message]) Asserts that `object` has a direct property named by `property`. Inherited properties aren't checked.
    
    Assert.ownProperty([ tea: [ green: 'matcha' ]], 'tea')
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {String} - message
  - ownPropertyVal
```
public static boolean ownPropertyVal(java.lang.Object obj,
                                     java.lang.String prop,
                                     java.lang.Object value)
```
  - ownPropertyVal
```
public static boolean ownPropertyVal(java.lang.Object obj,
                                     java.lang.String prop,
                                     java.lang.Object value,
                                     java.lang.String msg)
```
    ### .ownPropertyVal(object, property, value, [message]) Asserts that `object` has a direct property named by `property` and a value equal to the provided `value`. Object equality (equals) is used. Inherited properties aren't checked.
    
    Assert.ownPropertyVal([ coffee: 'is good'], 'coffee', 'is good')
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {Object} - value
    
    {String} - message
  - property
```
public static boolean property(java.lang.Object obj,
                               java.lang.String prop)
```
  - property
```
public static boolean property(java.lang.Object obj,
                               java.lang.String prop,
                               java.lang.String msg)
```
    ### .property(object, property, [message]) Asserts that `object` has a direct or inherited property named by `property`.
    
    Assert.property([ tea: [ green: 'matcha' ]], 'tea')
    
    Assert.property([ tea: [ green: 'matcha' ]], 'toString')
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {String} - message
  - propertyVal
```
public static boolean propertyVal(java.lang.Object obj,
                                  java.lang.String prop,
                                  java.lang.Object val)
```
  - propertyVal
```
public static boolean propertyVal(java.lang.Object obj,
                                  java.lang.String prop,
                                  java.lang.Object val,
                                  java.lang.String msg)
```
    ### .propertyVal(object, property, value, [message]) Asserts that `object` has a direct or inherited property named by `property` with a value given by `value`. Object equality (equals) is used.
    
    Assert.propertyVal([ tea: 'is good' ], 'tea', 'is good')
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {Object} - value
    
    {String} - message
  - strictEqual
```
public static boolean strictEqual(java.lang.Object act,
                                  java.lang.Object exp)
```
  - strictEqual
```
public static boolean strictEqual(java.lang.Object act,
                                  java.lang.Object exp,
                                  java.lang.String msg)
```
    ### .strictEqual(actual, expected, [message]) Asserts strict equality of `actual` and `expected`.
    
    Assert.strictEqual(true, true, 'these booleans are strictly equal')
    
    Parameters:
    
    {Object} - actual
    
    {Object} - expected
    
    {String} - message
  - strictInclude
```
public static boolean strictInclude(java.lang.Object haystack,
                                    java.lang.Object needle)
```
  - strictInclude
```
public static boolean strictInclude(java.lang.Object haystack,
                                    java.lang.Object needle,
                                    java.lang.String message)
```
    ### .strictInclude(haystack, needle, [message]) Asserts that `haystack` includes `needle`. Can be used to assert the inclusion of a value in an array or a subset of properties in an object. Strict equality is used. def obj1 = [a: 1] def obj2 = [b: 2]
    
    Assert.strictInclude([obj1, obj2], obj1)
    
    Assert.strictInclude([foo: obj1, bar: obj2], [foo: obj1])
    
    Assert.strictInclude([foo: obj1, bar: obj2], [foo: obj1, bar: obj2])
    
    Parameters:
    
    {Array|String} - haystack
    
    {Object} - needle
    
    {String} - message
  - strictNestedInclude
```
public static boolean strictNestedInclude(java.lang.Object haystack,
                                          java.lang.Object needle)
```
  - strictNestedInclude
```
public static boolean strictNestedInclude(java.lang.Object haystack,
                                          java.lang.Object needle,
                                          java.lang.String message)
```
    ### .strictNestedInclude(haystack, needle, [message]) Asserts that 'haystack' includes 'needle'. Can be used to assert the inclusion of a subset of properties in an object while checking for strict equality. Enables the use of dot- and bracket-notation for referencing nested properties. '[]' and '.' in property names can be escaped using double backslashes. def obj = [x: 1]
    
    Assert.strictNestedInclude([a: [b: [obj]]], ['a.b[0]': obj])
    
    Assert.strictNestedInclude(['.a': ['[b]': obj]], ['\\.a.\\[b\\]': obj])
    
    Parameters:
    
    {Object} - haystack
    
    {Object} - needle
    
    {String} - message
  - strictNestedPropertyVal
```
public static boolean strictNestedPropertyVal(java.lang.Object obj,
                                              java.lang.String prop,
                                              java.lang.Object val)
```
  - strictNestedPropertyVal
```
public static boolean strictNestedPropertyVal(java.lang.Object obj,
                                              java.lang.String prop,
                                              java.lang.Object val,
                                              java.lang.String msg)
```
    ### .strictNestedPropertyVal(object, property, value, [message]) Asserts that `object` has a property named by `property` with a value given by `value`. `property` can use dot- and bracket-notation for nested reference. Uses a strict equality check. def obj = [ matcha: 'yum' ]
    
    Assert.strictNestedPropertyVal([ tea: [ green: obj ] ], 'tea.green', obj)
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {Object} - value
    
    {String} - message
  - strictOwnInclude
```
public static boolean strictOwnInclude(java.lang.Object haystack,
                                       java.lang.Object needle)
```
  - strictOwnInclude
```
public static boolean strictOwnInclude(java.lang.Object haystack,
                                       java.lang.Object needle,
                                       java.lang.String message)
```
    ### .strictOwnInclude(haystack, needle, [message]) Asserts that 'haystack' includes 'needle'. Can be used to assert the inclusion of a subset of properties in an object while ignoring inherited properties and checking for strict equality. def obj = [b: 2] Assert.strictOwnInclude([a: obj], [a: obj])
    
    Parameters:
    
    {Object} - haystack
    
    {Object} - needle
    
    {String} - message
  - strictOwnPropertyVal
```
public static boolean strictOwnPropertyVal(java.lang.Object obj,
                                           java.lang.String prop,
                                           java.lang.Object value)
```
  - strictOwnPropertyVal
```
public static boolean strictOwnPropertyVal(java.lang.Object obj,
                                           java.lang.String prop,
                                           java.lang.Object value,
                                           java.lang.String msg)
```
    ### .strictOwnPropertyVal(object, property, value, [message]) Asserts that `object` has a direct property named by `property` and a value equal to the provided `value`. Uses a strict equality check. Inherited properties aren't checked. def prop = [ green: 'matcha' ]
    
    Assert.strictOwnPropertyVal([ tea: prop ], 'tea', prop)
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {Object} - value
    
    {String} - message
  - strictPropertyVal
```
public static boolean strictPropertyVal(java.lang.Object obj,
                                        java.lang.String prop,
                                        java.lang.Object val)
```
  - strictPropertyVal
```
public static boolean strictPropertyVal(java.lang.Object obj,
                                        java.lang.String prop,
                                        java.lang.Object val,
                                        java.lang.String msg)
```
    ### .strictPropertyVal(object, property, value, [message]) Asserts that `object` has a direct or inherited property named by `property` with a value given by `value`. Uses a strict equality check. def obj = new Object() { def prop = "bla" }
    
    Assert.strictPropertyVal(obj, 'prop', obj.prop)
    
    Parameters:
    
    {Object} - object
    
    {String} - property
    
    {Object} - value
    
    {String} - message
  - test
```
public static boolean test(boolean value,
                           java.lang.String errmsg)
```
  - test
```
public static boolean test(java.util.function.BooleanSupplier expression,
                           java.lang.String errmsg)
```
    ### assert(expression, message) Write your own test expressions.
    
    Assert.test('foo' !== 'bar', 'foo is not bar')
    
    Assert.test({true}, 'Closures can return true')
    
    Parameters:
    
    {BooleanSupplier} - expression to test for truthiness
    
    {String} - message to display on error
  - typeOf
```
public static boolean typeOf(java.lang.Object value,
                             java.lang.Object type)
```
  - typeOf
```
public static boolean typeOf(java.lang.Object value,
                             java.lang.Object type,
                             java.lang.String message)
```
    ### .typeOf(value, name, [message]) Asserts that `value`'s type is `name`, as determined by its class.
    
    Assert.typeOf([ tea: 'chai' ], 'Object', 'we have an object')
    
    Assert.typeOf('tea', 'String', 'we have a string')
    
    Parameters:
    
    {Object} - value
    
    {String} - name
    
    {String} - message

Class Assert

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Assert

Method Detail

deepEqual

deepEqual

deepInclude

deepInclude

deepNestedInclude

deepNestedInclude

deepNestedPropertyVal

deepNestedPropertyVal

deepOwnInclude

deepOwnInclude

deepOwnPropertyVal

deepOwnPropertyVal

deepPropertyVal

deepPropertyVal

empty

empty

equal

equal

exists

exists

fail

fail

fail

fail

fail

fail

include

include

instanceOf

instanceOf

isArray

isArray

isBoolean

isBoolean

isEmpty

isEmpty

isFalse

isFalse

isFunction

isFunction

isList

isList

isMap

isMap

isNotArray

isNotArray

isNotBoolean

isNotBoolean

isNotEmpty

isNotEmpty

isNotFalse

isNotFalse

isNotFunction

isNotFunction

isNotList

isNotList

isNotMap

isNotMap

isNotNull

isNotNull

isNotNumber

isNotNumber

isNotObject

isNotObject

isNotObject

isNotObject

isNotObject

isNotObject

isNotObject

isNotObject

isNotObject

isNotObject

isNotObject