Assert (P2J - Progress 4GL to Java Conversion and Runtime)

java.lang.Object
- com.goldencode.p2j.oo.lang.BaseObject
- - com.goldencode.p2j.oo.core.AbstractAssert
  - - com.goldencode.p2j.oo.core.Assert

All Implemented Interfaces:

_BaseObject_
```
public class Assert
extends AbstractAssert
```
Business logic (initially converted to Java from the 4GL source code in OpenEdge/Core/Assert.cls).

Field Summary
- Fields inherited from class com.goldencode.p2j.oo.core.AbstractAssert
  DEFAULT_ARGUMENT_NAME

Constructor Summary

Constructors
Constructor and Description

Assert()

Constructors
Constructor and Description
`Assert()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`__core_Assert_constructor__()` The "default" constructor.
`static void`	`__core_Assert_constructor__static__()` The static constructor
`void`	`__core_Assert_execute__()` Initialize this procedure
`private static void`	`call(java.lang.String legacyName, Body body)` Implementation helper for all test methods in this very class.
`static void`	`isAvailable(handle argument)` Check that the buffer argument is available
`static void`	`isAvailable(handle argument, character name)` Check that the buffer argument is available
`static void`	`isDecimal(character argument)` Check that the character argument can be parsed to a decimal value
`static void`	`isDecimal(character argument, character name)` Check that the character argument can be parsed to a decimal value
`private static void`	`isDecimalImpl(character argument, java.lang.String name)` Check that the character argument can be parsed to a decimal value
`static void`	`isEmpty(character argument)` Check that the argument is empty
`static void`	`isEmpty(character argument, character name)` Check that the argument is empty
`static void`	`isEmpty(handle argument)` Check that the argument is empty
`static void`	`isEmpty(handle argument, character name)` Check that the argument is empty
`static void`	`isEmpty(longchar argument)` Check that the argument is empty
`static void`	`isEmpty(longchar argument, character name)` Check that the argument is empty
`static void`	`isEmpty(memptr argument)` Check that the argument is empty
`static void`	`isEmpty(memptr argument, character name)` Check that the argument is empty
`private static void`	`isEmptyImpl(handle argument, java.lang.String name)` Check that a handle is empty (not available)
`private static void`	`isEmptyImpl(memptr argument, java.lang.String name)` Check that the argument is empty (size is zero)
`private static void`	`isEmptyImpl(Text argument, java.lang.String name)` Check that the argument is empty (contains no characters).
`static void`	`isFalse(logical argument)` Check that the logical argument is false
`static void`	`isFalse(logical argument, character name)` Check that the logical argument is false
`static void`	`isIn(character argument, longchar list, character name)` Check that a character value is in the list
`static void`	`isIn(character argument, longchar list, character delimiter, character name)` Check that a character value is in the list
`private static void`	`isInImpl(character argument, longchar list, character delimiter, character name)` Check that a character value is in the list
`static void`	`isInt64(character argument)` Check that the character argument can be parsed to an int64 value
`static void`	`isInt64(character argument, character name)` Check that the character argument can be parsed to an int64 value
`private static void`	`isInt64Impl(character argument, java.lang.String name)` Check that the character argument can be parsed to an int64 value
`static void`	`isInteger(character argument)` Check that the character argument can be parsed to an integer value
`static void`	`isInteger(character argument, character name)` Check that the character argument can be parsed to an integer value
`private static void`	`isIntegerImpl(character argument, java.lang.String name)` Check that the character argument can be parsed to an integer value
`static void`	`isLogical(character argument)` Check that the character argument can be parsed to a logical value
`static void`	`isLogical(character argument, character name)` Check that the character argument can be parsed to a logical value
`static void`	`isLogical(character argument, character mask, character name)` Asserts value can be parsed to a logical value with mask
`private static void`	`isLogicalImpl(character argument, character mask, java.lang.String name)` Check that the character argument can be parsed to a logical value
`private static void`	`isLogicalImpl(character argument, java.lang.String name)` Check that the character argument can be parsed to a logical value
`static void`	`isNegative(decimal argument)` Check that the numeric argument is strictly negative
`static void`	`isNegative(decimal argument, character name)` Check that the numeric argument is strictly negative
`static void`	`isNegative(int64 argument)` Check that the numeric argument is strictly negative
`static void`	`isNegative(int64 argument, character name)` Check that the numeric argument is strictly negative
`static void`	`isNegative(integer argument)` Check that the numeric argument is strictly negative
`static void`	`isNegative(integer argument, character name)` Check that the numeric argument is strictly negative
`private static void`	`isNegativeImpl(NumberType argument, java.lang.String name)` Check that the numeric argument is strictly negative
`static void`	`isNull(character argument)` Check that the argument is unknown
`static void`	`isNull(character[] argument)` Check that the argument is unknown
`static void`	`isNull(character[] argument, character name)` Check that the argument is unknown
`static void`	`isNull(character argument, character name)` Check that the argument is unknown
`static void`	`isNull(date argument)` Check that the argument is unknown
`static void`	`isNull(date[] argument)` Check that the argument is unknown
`static void`	`isNull(date[] argument, character name)` Check that the argument is unknown
`static void`	`isNull(date argument, character name)` Check that the argument is unknown
`static void`	`isNull(datetime argument)` Check that the argument is unknown
`static void`	`isNull(datetime[] argument)` Check that the argument is unknown
`static void`	`isNull(datetime[] argument, character name)` Check that the argument is unknown
`static void`	`isNull(datetime argument, character name)` Check that the argument is unknown
`static void`	`isNull(datetimetz argument)` Check that the argument is unknown
`static void`	`isNull(datetimetz[] argument)` Check that the argument is unknown
`static void`	`isNull(datetimetz[] argument, character name)` Check that the argument is unknown
`static void`	`isNull(datetimetz argument, character name)` Check that the argument is unknown
`static void`	`isNull(decimal argument)` Check that the argument is unknown
`static void`	`isNull(decimal[] argument)` Check that the argument is unknown
`static void`	`isNull(decimal[] argument, character name)` Check that the argument is unknown
`static void`	`isNull(decimal argument, character name)` Check that the argument is unknown
`static void`	`isNull(handle argument)` Check that the argument is unknown
`static void`	`isNull(handle[] argument)` Check that the argument is unknown
`static void`	`isNull(handle[] argument, character name)` Check that the argument is unknown
`static void`	`isNull(handle argument, character name)` Check that the argument is unknown
`static void`	`isNull(int64 argument)` Check that the argument is unknown
`static void`	`isNull(int64[] argument)` Check that the argument is unknown
`static void`	`isNull(int64[] argument, character name)` Check that the argument is unknown
`static void`	`isNull(int64 argument, character name)` Check that the argument is unknown
`static void`	`isNull(integer argument)` Check that the argument is unknown
`static void`	`isNull(integer[] argument)` Check that the argument is unknown
`static void`	`isNull(integer[] argument, character name)` Check that the argument is unknown
`static void`	`isNull(integer argument, character name)` Check that the argument is unknown
`static void`	`isNull(logical argument)` Check that the argument is unknown
`static void`	`isNull(logical[] argument)` Check that the argument is unknown
`static void`	`isNull(logical[] argument, character name)` Check that the argument is unknown
`static void`	`isNull(logical argument, character name)` Check that the argument is unknown
`static void`	`isNull(longchar argument)` Check that the argument is unknown
`static void`	`isNull(longchar[] argument)` Check that the argument is unknown
`static void`	`isNull(longchar[] argument, character name)` Check that the argument is unknown
`static void`	`isNull(longchar argument, character name)` Check that the argument is unknown
`static void`	`isNull(raw argument)` Check that the argument is unknown
`static void`	`isNull(raw[] argument)` Check that the argument is unknown
`static void`	`isNull(raw[] argument, character name)` Check that the argument is unknown
`static void`	`isNull(raw argument, character name)` Check that the argument is unknown
`private static void`	`isNullImpl(BaseDataType argument, java.lang.String name)` Check that the argument is unknown
`static void`	`isPositive(decimal argument)` Check that the numeric argument is strictly positive
`static void`	`isPositive(decimal argument, character name)` Check that the numeric argument is strictly positive
`static void`	`isPositive(int64 argument)` Check that the numeric argument is strictly positive
`static void`	`isPositive(int64 argument, character name)` Check that the numeric argument is strictly positive
`static void`	`isPositive(integer argument)` Check that the numeric argument is strictly positive
`static void`	`isPositive(integer argument, character name)` Check that the numeric argument is strictly positive
`static void`	`isPositiveImpl(NumberType argument, java.lang.String name)` Check that the numeric argument is strictly positive
`static void`	`isTrue(logical argument)` Check that the logical argument is true
`static void`	`isTrue(logical argument, character name)` Check that the logical argument is true
`static void`	`isUnknown_(character argument)` Check that the argument is unknown
`static void`	`isUnknown_(character[] argument)` Check that the argument is unknown
`static void`	`isUnknown_(character[] argument, character name)` Check that the argument is unknown
`static void`	`isUnknown_(character argument, character name)` Check that the argument is unknown
`static void`	`isUnknown_(date argument)` Check that the argument is unknown
`static void`	`isUnknown_(date[] argument)` Check that the argument is unknown
`static void`	`isUnknown_(date[] argument, character name)` Check that the argument is unknown
`static void`	`isUnknown_(date argument, character name)` Check that the argument is unknown
`static void`	`isUnknown_(datetime argument)` Check that the argument is unknown
`static void`	`isUnknown_(datetime[] argument)` Check that the argument is unknown
`static void`	`isUnknown_(datetime[] argument, character name)` Check that the argument is unknown
`static void`	`isUnknown_(datetime argument, character name)` Check that the argument is unknown
`static void`	`isUnknown_(datetimetz argument)` Check that the argument is unknown
`static void`	`isUnknown_(datetimetz[] argument)` Check that the argument is unknown
`static void`	`isUnknown_(datetimetz[] argument, character name)` Check that the argument is unknown
`static void`	`isUnknown_(datetimetz argument, character name)` Check that the argument is unknown
`static void`	`isUnknown_(decimal argument)` Check that the argument is unknown
`static void`	`isUnknown_(decimal[] argument)` Check that the argument is unknown
`static void`	`isUnknown_(decimal[] argument, character name)` Check that the argument is unknown
`static void`	`isUnknown_(decimal argument, character name)` Check that the argument is unknown
`static void`	`isUnknown_(handle argument)` Check that the argument is unknown
`static void`	`isUnknown_(handle[] argument)` Check that the argument is unknown
`static void`	`isUnknown_(handle[] argument, character name)` Check that the argument is unknown
`static void`	`isUnknown_(handle argument, character name)` Check that the argument is unknown
`static void`	`isUnknown_(int64 argument)` Check that the argument is unknown
`static void`	`isUnknown_(int64[] argument)` Check that the argument is unknown
`static void`	`isUnknown_(int64[] argument, character name)` Check that the argument is unknown
`static void`	`isUnknown_(int64 argument, character name)` Check that the argument is unknown
`static void`	`isUnknown_(integer argument)` Check that the argument is unknown
`static void`	`isUnknown_(integer[] argument)` Check that the argument is unknown
`static void`	`isUnknown_(integer[] argument, character name)` Check that the argument is unknown
`static void`	`isUnknown_(integer argument, character name)` Check that the argument is unknown
`static void`	`isUnknown_(logical argument)` Check that the argument is unknown
`static void`	`isUnknown_(logical[] argument)` Check that the argument is unknown
`static void`	`isUnknown_(logical[] argument, character name)` Check that the argument is unknown
`static void`	`isUnknown_(logical argument, character name)` Check that the argument is unknown
`static void`	`isUnknown_(longchar argument)` Check that the argument is unknown
`static void`	`isUnknown_(longchar[] argument)` Check that the argument is unknown
`static void`	`isUnknown_(longchar[] argument, character name)` Check that the argument is unknown
`static void`	`isUnknown_(longchar argument, character name)` Check that the argument is unknown
`static void`	`isUnknown_(raw argument)` Check that the argument is unknown
`static void`	`isUnknown_(raw[] argument)` Check that the argument is unknown
`static void`	`isUnknown_(raw[] argument, character name)` Check that the argument is unknown
`static void`	`isUnknown_(raw argument, character name)` Check that the argument is unknown
`static void`	`isZero(decimal argument)` Check that the numeric argument is zero
`static void`	`isZero(decimal argument, character name)` Check that the numeric argument is zero
`static void`	`isZero(int64 argument)` Check that the numeric argument is zero
`static void`	`isZero(int64 argument, character name)` Check that the numeric argument is zero
`static void`	`isZero(integer argument)` Check that the numeric argument is zero
`static void`	`isZero(integer argument, character name)` Check that the numeric argument is zero
`private static void`	`isZeroImpl(NumberType argument, java.lang.String name)` Check that the numeric argument is zero
`static void`	`isZeroOrNegative(decimal argument)` Check that the numeric argument is zero or negative
`static void`	`isZeroOrNegative(decimal argument, character name)` Check that the numeric argument is zero or negative
`static void`	`isZeroOrNegative(int64 argument)` Check that the numeric argument is zero or negative
`static void`	`isZeroOrNegative(int64 argument, character name)` Check that the numeric argument is zero or negative
`static void`	`isZeroOrNegative(integer argument)` Check that the numeric argument is zero or negative
`static void`	`isZeroOrNegative(integer argument, character name)` Check that the numeric argument is zero or negative
`private static void`	`isZeroOrNegativeImpl(NumberType argument, java.lang.String name)` Check that the numeric argument is zero or negative
`static void`	`isZeroOrPositive(decimal argument)` Check that the numeric argument is zero or positive
`static void`	`isZeroOrPositive(decimal argument, character name)` Check that the numeric argument is zero or positive
`static void`	`isZeroOrPositive(int64 argument)` Check that the numeric argument is zero or positive
`static void`	`isZeroOrPositive(int64 argument, character name)` Check that the numeric argument is zero or positive
`static void`	`isZeroOrPositive(integer argument)` Check that the numeric argument is zero or positive
`static void`	`isZeroOrPositive(integer argument, character name)` Check that the numeric argument is zero or positive
`static void`	`isZeroOrPositiveImpl(NumberType argument, java.lang.String name)` Check that the numeric argument is zero or positive
`static void`	`legacyEquals(character expected, character actual)` Check that two arguments are equal
`static void`	`legacyEquals(date expected, date actual)` Check that two arguments are equal
`static void`	`legacyEquals(datetime expected, datetime actual)` Check that two arguments are equal
`static void`	`legacyEquals(datetimetz expected, datetimetz actual)` Check that two arguments are equal
`static void`	`legacyEquals(decimal expected, decimal actual)` Check that two arguments are equal
`static void`	`legacyEquals(handle expected, handle actual)` Check that two arguments are equal
`static void`	`legacyEquals(int64 expected, int64 actual)` Check that two arguments are equal
`static void`	`legacyEquals(integer expected, integer actual)` Check that two arguments are equal
`static void`	`legacyEquals(logical expected, logical actual)` Check that two arguments are equal
`static void`	`legacyEquals(longchar expected, longchar actual)` Check that two arguments are equal
`static void`	`legacyEquals(memptr expected, memptr actual)` Check that two arguments are equal
`static void`	`legacyEquals(raw expected, raw actual)` Check that two arguments are equal
`static void`	`legacyEquals(recid expected, recid actual)` Check that two arguments are equal
`static void`	`legacyEquals(rowid expected, rowid actual)` Check that two arguments are equal
`static void`	`nonZero(decimal argument)` Check that the numeric argument is not zero
`static void`	`nonZero(decimal argument, character name)` Check that the numeric argument is not zero
`static void`	`nonZero(int64 argument)` Check that the numeric argument is not zero
`static void`	`nonZero(int64 argument, character name)` Check that the numeric argument is not zero
`static void`	`nonZero(integer argument)` Check that the numeric argument is not zero
`static void`	`nonZero(integer argument, character name)` Check that the numeric argument is not zero
`private static void`	`nonZeroImpl(NumberType argument, java.lang.String name)` Check that the numeric argument is not zero
`static void`	`notAvailable(handle argument)` Check that the buffer argument is not available
`static void`	`notAvailable(handle argument, character name)` Check that the buffer argument is not available
`private static void`	`notAvailableImpl(handle argument, java.lang.String name)` Check that the buffer argument is not available
`static void`	`notEmpty(character argument)` Check that the argument is not empty
`static void`	`notEmpty(character[] argument)` Check that the argument is not empty
`static void`	`notEmpty(character[] argument, character name)` Check that the argument is not empty
`static void`	`notEmpty(character argument, character name)` Check that the argument is not empty
`static void`	`notEmpty(handle argument)` Check that the argument is not empty
`static void`	`notEmpty(handle[] argument)` Check that the argument is not empty
`static void`	`notEmpty(handle[] argument, character name)` Check that the argument is not empty
`static void`	`notEmpty(handle argument, character name)` Check that the argument is not empty
`static void`	`notEmpty(longchar argument)` Check that the argument is not empty
`static void`	`notEmpty(longchar[] argument)` Check that the argument is not empty
`static void`	`notEmpty(longchar[] argument, character name)` Check that the argument is not empty
`static void`	`notEmpty(longchar argument, character name)` Check that the argument is not empty
`static void`	`notEmpty(memptr argument)` Check that the argument is not empty
`static void`	`notEmpty(memptr[] argument)` Check that the argument is not empty
`static void`	`notEmpty(memptr[] argument, character name)` Check that the argument is not empty
`static void`	`notEmpty(memptr argument, character name)` Check that the argument is not empty
`private static void`	`notEmptyImpl(BaseDataType[] argument, java.lang.String name)` Check that the argument is not empty
`static void`	`notEqual(character expected, character actual)` Check that two arguments are not equal
`static void`	`notEqual(date expected, date actual)` Check that two arguments are not equal
`static void`	`notEqual(datetime expected, datetime actual)` Check that two arguments are not equal
`static void`	`notEqual(datetimetz expected, datetimetz actual)` Check that two arguments are not equal
`static void`	`notEqual(decimal expected, decimal actual)` Check that two arguments are not equal
`static void`	`notEqual(handle expected, handle actual)` Check that two arguments are not equal
`static void`	`notEqual(int64 expected, int64 actual)` Check that two arguments are not equal
`static void`	`notEqual(integer expected, integer actual)` Check that two arguments are not equal
`static void`	`notEqual(logical expected, logical actual)` Check that two arguments are not equal
`static void`	`notEqual(longchar expected, longchar actual)` Check that two arguments are not equal
`static void`	`notEqual(memptr expected, memptr actual)` Check that two arguments are not equal
`static void`	`notEqual(raw expected, raw actual)` Check that two arguments are not equal
`static void`	`notEqual(recid expected, recid actual)` Check that two arguments are not equal
`static void`	`notEqual(rowid expected, rowid actual)` Check that two arguments are not equal
`private static void`	`notEqualImpl(BaseDataType expected, BaseDataType actual)` Check that two arguments are not equal
`static void`	`notFalse(logical argument)` Check that the logical argument is not false (is true or unknown)
`static void`	`notFalse(logical argument, character name)` Check that the logical argument is not false (is true or unknown)
`private static void`	`notFalseImpl(logical argument, java.lang.String name)` Check that the logical argument is not false (is true or unknown)
`static void`	`notIn(character argument, longchar list, character name)` Check that a character value is not in the list
`static void`	`notIn(character argument, longchar list, character delimiter, character name)` Check that a character value is not in the list
`private static void`	`notInImpl(Text argument, longchar list, Text delimiter, character name)` Check that a character value is not in the list
`static void`	`notNull(character argument)` Check that the argument is not unknown
`static void`	`notNull(character[] argument)` Check that the argument is not unknown
`static void`	`notNull(character[] argument, character name)` Check that the argument is not unknown
`static void`	`notNull(character argument, character name)` Check that the argument is not unknown
`static void`	`notNull(date argument)` Check that the argument is not unknown
`static void`	`notNull(date[] argument)` Check that the argument is not unknown
`static void`	`notNull(date[] argument, character name)` Check that the argument is not unknown
`static void`	`notNull(date argument, character name)` Check that the argument is not unknown
`static void`	`notNull(datetime argument)` Check that the argument is not unknown
`static void`	`notNull(datetime[] argument)` Check that the argument is not unknown
`static void`	`notNull(datetime[] argument, character name)` Check that the argument is not unknown
`static void`	`notNull(datetime argument, character name)` Check that the argument is not unknown
`static void`	`notNull(datetimetz argument)` Check that the argument is not unknown
`static void`	`notNull(datetimetz[] argument)` Check that the argument is not unknown
`static void`	`notNull(datetimetz[] argument, character name)` Check that the argument is not unknown
`static void`	`notNull(datetimetz argument, character name)` Check that the argument is not unknown
`static void`	`notNull(decimal argument)` Check that the argument is not unknown
`static void`	`notNull(decimal[] argument)` Check that the argument is not unknown
`static void`	`notNull(decimal[] argument, character name)` Check that the argument is not unknown
`static void`	`notNull(decimal argument, character name)` Check that the argument is not unknown
`static void`	`notNull(handle argument)` Check that the argument is not unknown
`static void`	`notNull(handle[] argument)` Check that the argument is not unknown
`static void`	`notNull(handle[] argument, character name)` Check that the argument is not unknown
`static void`	`notNull(handle argument, character name)` Check that the argument is not unknown
`static void`	`notNull(int64 argument)` Check that the argument is not unknown
`static void`	`notNull(int64[] argument)` Check that the argument is not unknown
`static void`	`notNull(int64[] argument, character name)` Check that the argument is not unknown
`static void`	`notNull(int64 argument, character name)` Check that the argument is not unknown
`static void`	`notNull(integer argument)` Check that the argument is not unknown
`static void`	`notNull(integer[] argument)` Check that the argument is not unknown
`static void`	`notNull(integer[] argument, character name)` Check that the argument is not unknown
`static void`	`notNull(integer argument, character name)` Check that the argument is not unknown
`static void`	`notNull(logical argument)` Check that the argument is not unknown
`static void`	`notNull(logical[] argument)` Check that the argument is not unknown
`static void`	`notNull(logical[] argument, character name)` Check that the argument is not unknown
`static void`	`notNull(logical argument, character name)` Check that the argument is not unknown
`static void`	`notNull(longchar argument)` Check that the argument is not unknown
`static void`	`notNull(longchar[] argument)` Check that the argument is not unknown
`static void`	`notNull(longchar[] argument, character name)` Check that the argument is not unknown
`static void`	`notNull(longchar argument, character name)` Check that the argument is not unknown
`static void`	`notNull(raw argument)` Check that the argument is not unknown
`static void`	`notNull(raw[] argument)` Check that the argument is not unknown
`static void`	`notNull(raw[] argument, character name)` Check that the argument is not unknown
`static void`	`notNull(raw argument, character name)` Check that the argument is not unknown
`private static void`	`notNullImpl(handle argument, java.lang.String name)` Check that the argument is not unknown and valid
`static void`	`notNullOrEmpty(character argument)` Check that the argument is neither unknown nor empty
`static void`	`notNullOrEmpty(character[] argument)` Check that the argument is neither unknown nor empty
`static void`	`notNullOrEmpty(character[] argument, character name)` Check that the argument is neither unknown nor empty
`static void`	`notNullOrEmpty(character argument, character name)` Check that the argument is neither unknown nor empty
`static void`	`notNullOrEmpty(longchar argument)` Check that the argument is neither unknown nor empty
`static void`	`notNullOrEmpty(longchar[] argument)` Check that the argument is neither unknown nor empty
`static void`	`notNullOrEmpty(longchar[] argument, character name)` Check that the argument is neither unknown nor empty
`static void`	`notNullOrEmpty(longchar argument, character name)` Check that the argument is neither unknown nor empty
`static void`	`notNullOrEmptyCollection(object<? extends Icollection> argument)` Check that the argument is neither unknown nor empty
`static void`	`notNullOrEmptyCollection(object<? extends Icollection> argument, character name)` Check that the argument is neither unknown nor empty
`private static void`	`notNullOrEmptyImpl(BaseDataType[] argument, java.lang.String name)` Check that the argument is neither unknown nor empty
`static void`	`notNullOrEmptyImpl(BaseDataType argument, java.lang.String name)` Check that the argument is neither unknown nor empty
`static void`	`notNullOrEmptyMap(object<? extends Imap> argument)` Check that the argument is neither unknown nor empty
`static void`	`notNullOrEmptyMap(object<? extends Imap> argument, character name)` Check that the argument is neither unknown nor empty
`static void`	`notNullOrEmptyObject(object<? extends _BaseObject_> argument)` Check that the argument is neither unknown nor empty
`static void`	`notNullOrEmptyObject(object<? extends _BaseObject_> argument, character name)` Check that the argument is neither unknown nor empty
`static void`	`notNullOrEmptyObjectArray(object<? extends _BaseObject_>[] argument)` Check that the argument is neither unknown nor empty
`static void`	`notNullOrEmptyObjectArray(object<? extends _BaseObject_>[] argument, character name)` Check that the argument is neither unknown nor empty
`static void`	`notNullOrZero(decimal argument)` Check that the numeric argument is neither unknown nor zero
`static void`	`notNullOrZero(decimal argument, character name)` Check that the numeric argument is neither unknown nor zero
`static void`	`notNullOrZero(int64 argument)` Check that the numeric argument is neither unknown nor zero
`static void`	`notNullOrZero(int64 argument, character name)` Check that the numeric argument is neither unknown nor zero
`static void`	`notNullOrZero(integer argument)` Check that the numeric argument is neither unknown nor zero
`static void`	`notNullOrZero(integer argument, character name)` Check that the numeric argument is neither unknown nor zero
`private static void`	`notNullOrZeroImpl(NumberType argument, java.lang.String name)` Check that the numeric argument is neither unknown nor zero
`static void`	`notTrue(logical argument)` Check that the logical argument is not true (is false or unknown)
`static void`	`notTrue(logical argument, character name)` Check that the logical argument is not true (is false or unknown)
`private static void`	`notTrueImpl(logical argument, java.lang.String name)` Check that the logical argument is not true (is false or unknown)
`static void`	`notUnknown(character argument)` Check that the argument is not unknown
`static void`	`notUnknown(character[] argument)` Check that the argument is not unknown
`static void`	`notUnknown(character[] argument, character name)` Check that the argument is not unknown
`static void`	`notUnknown(character argument, character name)` Check that the argument is not unknown
`static void`	`notUnknown(date argument)` Check that the argument is not unknown
`static void`	`notUnknown(date[] argument)` Check that the argument is not unknown
`static void`	`notUnknown(date[] argument, character name)` Check that the argument is not unknown
`static void`	`notUnknown(date argument, character name)` Check that the argument is not unknown
`static void`	`notUnknown(datetime argument)` Check that the argument is not unknown
`static void`	`notUnknown(datetime[] argument)` Check that the argument is not unknown
`static void`	`notUnknown(datetime[] argument, character name)` Check that the argument is not unknown
`static void`	`notUnknown(datetime argument, character name)` Check that the argument is not unknown
`static void`	`notUnknown(datetimetz argument)` Check that the argument is not unknown
`static void`	`notUnknown(datetimetz[] argument)` Check that the argument is not unknown
`static void`	`notUnknown(datetimetz[] argument, character name)` Check that the argument is not unknown
`static void`	`notUnknown(datetimetz argument, character name)` Check that the argument is not unknown
`static void`	`notUnknown(decimal argument)` Check that the argument is not unknown
`static void`	`notUnknown(decimal[] argument)` Check that the argument is not unknown
`static void`	`notUnknown(decimal[] argument, character name)` Check that the argument is not unknown
`static void`	`notUnknown(decimal argument, character name)` Check that the argument is not unknown
`static void`	`notUnknown(handle argument)` Check that the argument is not unknown
`static void`	`notUnknown(handle[] argument)` Check that the argument is not unknown
`static void`	`notUnknown(handle[] argument, character name)` Check that the argument is not unknown
`static void`	`notUnknown(handle argument, character name)` Check that the argument is not unknown
`static void`	`notUnknown(int64 argument)` Check that the argument is not unknown
`static void`	`notUnknown(int64[] argument)` Check that the argument is not unknown
`static void`	`notUnknown(int64[] argument, character name)` Check that the argument is not unknown
`static void`	`notUnknown(int64 argument, character name)` Check that the argument is not unknown
`static void`	`notUnknown(integer argument)` Check that the argument is not unknown
`static void`	`notUnknown(integer[] argument)` Check that the argument is not unknown
`static void`	`notUnknown(integer[] argument, character name)` Check that the argument is not unknown
`static void`	`notUnknown(integer argument, character name)` Check that the argument is not unknown
`static void`	`notUnknown(logical argument)` Check that the argument is not unknown
`static void`	`notUnknown(logical[] argument)` Check that the argument is not unknown
`static void`	`notUnknown(logical[] argument, character name)` Check that the argument is not unknown
`static void`	`notUnknown(logical argument, character name)` Check that the argument is not unknown
`static void`	`notUnknown(longchar argument)` Check that the argument is not unknown
`static void`	`notUnknown(longchar[] argument)` Check that the argument is not unknown
`static void`	`notUnknown(longchar[] argument, character name)` Check that the argument is not unknown
`static void`	`notUnknown(longchar argument, character name)` Check that the argument is not unknown
`static void`	`notUnknown(raw argument)` Check that the argument is not unknown
`static void`	`notUnknown(raw[] argument)` Check that the argument is not unknown
`static void`	`notUnknown(raw[] argument, character name)` Check that the argument is not unknown
`static void`	`notUnknown(raw argument, character name)` Check that the argument is not unknown
`static void`	`notUnknownOrEmpty(character argument)` Check that the argument is neither unknown nor empty
`static void`	`notUnknownOrEmpty(character[] argument)` Check that the argument is neither unknown nor empty
`static void`	`notUnknownOrEmpty(character[] argument, character name)` Check that the argument is neither unknown nor empty
`static void`	`notUnknownOrEmpty(character argument, character name)` Check that the argument is neither unknown nor empty
`static void`	`notUnknownOrEmpty(longchar argument)` Check that the argument is neither unknown nor empty
`static void`	`notUnknownOrEmpty(longchar argument, character name)` Check that the argument is neither unknown nor empty
`static void`	`notUnknownOrEmpty(object<? extends _BaseObject_>[] argument, character name)` Check that the argument is neither unknown nor empty
`private static void`	`notUnknownOrEmptyImpl(BaseDataType[] argument, java.lang.String name)` Check that the argument is neither unknown nor empty
`private static void`	`notUnknownOrEmptyImpl(Text argument, java.lang.String name)` Check that the argument is neither unknown nor empty
`static void`	`notUnknownOrEmptyObject(object<? extends _BaseObject_> argument, character name)` Check that the argument is neither unknown nor empty
`static void`	`notZero(decimal argument)` Check that the numeric argument is not zero
`static void`	`notZero(decimal argument, character name)` Check that the numeric argument is not zero
`static void`	`notZero(int64 argument)` Check that the numeric argument is not zero
`static void`	`notZero(int64 argument, character name)` Check that the numeric argument is not zero
`static void`	`notZero(integer argument)` Check that the numeric argument is not zero
`static void`	`notZero(integer argument, character name)` Check that the numeric argument is not zero
`private static void`	`notZeroImpl(NumberType argument, java.lang.String name)` Check that the numeric argument is not zero
`static void`	`raiseError(character message)` Throw AssertionFailedError with the given message
`private static void`	`raiseNonNegative(java.lang.String name)` Raise an ERROR condition as the value is not negative.
`private static void`	`raiseNonPositive(java.lang.String name)` Raise an ERROR condition as the value is not positive.
`private static void`	`raiseNonZero(java.lang.String name)` Raise an ERROR condition as the value is not zero.
`private static void`	`raiseNonZeroOrNegative(java.lang.String name)` Raise an ERROR condition as the value is not zero or negative.
`private static void`	`raiseNonZeroOrPositive(java.lang.String name)` Raise an ERROR condition as the value is not zero or positive.
`private static void`	`raiseZero(java.lang.String name)` Raise an ERROR condition as the value is zero.

Methods inherited from class com.goldencode.p2j.oo.core.AbstractAssert
__core_AbstractAssert_constructor__, __core_AbstractAssert_constructor__static__, __core_AbstractAssert_execute__, call, equalsImpl, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtent, hasDeterminateExtentImpl, isAbstract, isAvailableImpl, isFinal, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isIndeterminateArray, isInterface, isNull, isNull, isNull, isNull, isNullImpl, isNullImpl, isSerializable, isType, isType, isType, isType, isTypeImpl, isUnknown_, isUnknown_, isUnknown_, isUnknown_, isUnknownImpl, isUnknownImpl, legacyEquals, notAbstract, notEmptyImpl, notEqual, notFinal, notInterface, notNull, notNull, notNull, notNull, notNullImpl, notNullImpl, notNullImpl, notNullUnknownOrEmptyImpl, notSerializable, notType, notType, notType, notTypeImpl, notUnknown, notUnknown, notUnknown, notUnknown, notUnknownImpl, notUnknownImpl, notUnknownOrEmptyCollection, notUnknownOrEmptyCollection, notUnknownOrEmptyImpl, notUnknownOrEmptyMap, notUnknownOrEmptyMap, notUnknownOrEmptyObject, notUnknownOrEmptyObject, raiseError, raiseError, raiseErrorForEquals, raiseNotUnknown, raiseUnknown, testClass

Methods inherited from class com.goldencode.p2j.oo.lang.BaseObject
__isValidInternal__, __lang_BaseObject_constructor__, __setValidInternal__, assertNotNull, assertNotNull, getLegacyClass, getNextSibling, getPrevSibling, legacyClone, legacyEquals, toLegacyString

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

Methods inherited from interface com.goldencode.p2j.oo.lang._BaseObject_
isTracked

- Constructor Detail
  - Assert
```
public Assert()
```
- Method Detail
  - __core_Assert_constructor__static__
```
public static void __core_Assert_constructor__static__()
```
    The static constructor
  - isAvailable
```
public static void isAvailable(handle argument)
```
    Check that the buffer argument is available
    
    Parameters:
    
    argument - The argument to check
  - isAvailable
```
public static void isAvailable(handle argument,
                               character name)
```
    Check that the buffer argument is available
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isDecimal
```
public static void isDecimal(character argument)
```
    Check that the character argument can be parsed to a decimal value
    
    Parameters:
    
    argument - The argument to check
  - isDecimal
```
public static void isDecimal(character argument,
                             character name)
```
    Check that the character argument can be parsed to a decimal value
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isEmpty
```
public static void isEmpty(character argument)
```
    Check that the argument is empty
    
    Parameters:
    
    argument - The argument to check
  - isEmpty
```
public static void isEmpty(character argument,
                           character name)
```
    Check that the argument is empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isEmpty
```
public static void isEmpty(handle argument)
```
    Check that the argument is empty
    
    Parameters:
    
    argument - The argument to check
  - isEmpty
```
public static void isEmpty(handle argument,
                           character name)
```
    Check that the argument is empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isEmpty
```
public static void isEmpty(longchar argument)
```
    Check that the argument is empty
    
    Parameters:
    
    argument - The argument to check
  - isEmpty
```
public static void isEmpty(longchar argument,
                           character name)
```
    Check that the argument is empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isEmpty
```
public static void isEmpty(memptr argument)
```
    Check that the argument is empty
    
    Parameters:
    
    argument - The argument to check
  - isEmpty
```
public static void isEmpty(memptr argument,
                           character name)
```
    Check that the argument is empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isFalse
```
public static void isFalse(logical argument)
```
    Check that the logical argument is false
    
    Parameters:
    
    argument - The argument to check
  - isFalse
```
public static void isFalse(logical argument,
                           character name)
```
    Check that the logical argument is false
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isIn
```
public static void isIn(character argument,
                        longchar list,
                        character name)
```
    Check that a character value is in the list
    
    Parameters:
    
    argument - The argument to check
    
    list - The list to look up
    
    name - The name of the argument
  - isIn
```
public static void isIn(character argument,
                        longchar list,
                        character delimiter,
                        character name)
```
    Check that a character value is in the list
    
    Parameters:
    
    argument - The argument to check
    
    list - The list to look up
    
    delimiter - List delimiter
    
    name - The name of the argument
  - isInt64
```
public static void isInt64(character argument)
```
    Check that the character argument can be parsed to an int64 value
    
    Parameters:
    
    argument - The argument to check
  - isInt64
```
public static void isInt64(character argument,
                           character name)
```
    Check that the character argument can be parsed to an int64 value
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isInteger
```
public static void isInteger(character argument)
```
    Check that the character argument can be parsed to an integer value
    
    Parameters:
    
    argument - The argument to check
  - isInteger
```
public static void isInteger(character argument,
                             character name)
```
    Check that the character argument can be parsed to an integer value
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isLogical
```
public static void isLogical(character argument)
```
    Check that the character argument can be parsed to a logical value
    
    Parameters:
    
    argument - The argument to check
  - isLogical
```
public static void isLogical(character argument,
                             character name)
```
    Check that the character argument can be parsed to a logical value
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isLogical
```
public static void isLogical(character argument,
                             character mask,
                             character name)
```
    Asserts value can be parsed to a logical value with mask
    
    Parameters:
    
    argument - The argument to check
    
    mask - The mask
    
    name - The name of the argument
  - isNegative
```
public static void isNegative(decimal argument)
```
    Check that the numeric argument is strictly negative
    
    Parameters:
    
    argument - The argument to check
  - isNegative
```
public static void isNegative(decimal argument,
                              character name)
```
    Check that the numeric argument is strictly negative
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNegative
```
public static void isNegative(int64 argument)
```
    Check that the numeric argument is strictly negative
    
    Parameters:
    
    argument - The argument to check
  - isNegative
```
public static void isNegative(int64 argument,
                              character name)
```
    Check that the numeric argument is strictly negative
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNegative
```
public static void isNegative(integer argument)
```
    Check that the numeric argument is strictly negative
    
    Parameters:
    
    argument - The argument to check
  - isNegative
```
public static void isNegative(integer argument,
                              character name)
```
    Check that the numeric argument is strictly negative
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(character argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(character argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(character[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(character[] argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(date argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(date argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(date[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(date[] argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(datetime argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(datetime argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(datetime[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(datetime[] argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(datetimetz argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(datetimetz argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(datetimetz[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(datetimetz[] argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(decimal argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(decimal argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(decimal[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(decimal[] argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(handle argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(handle argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(handle[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(handle[] argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(int64 argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(int64 argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(int64[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(int64[] argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(integer argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(integer argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(integer[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(integer[] argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(logical argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(logical argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(logical[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(logical[] argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(longchar argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(longchar argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(longchar[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(longchar[] argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(raw argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(raw argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNull
```
public static void isNull(raw[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isNull
```
public static void isNull(raw[] argument,
                          character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isPositive
```
public static void isPositive(decimal argument)
```
    Check that the numeric argument is strictly positive
    
    Parameters:
    
    argument - The argument to check
  - isPositive
```
public static void isPositive(decimal argument,
                              character name)
```
    Check that the numeric argument is strictly positive
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isPositive
```
public static void isPositive(int64 argument)
```
    Check that the numeric argument is strictly positive
    
    Parameters:
    
    argument - The argument to check
  - isPositive
```
public static void isPositive(int64 argument,
                              character name)
```
    Check that the numeric argument is strictly positive
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isPositive
```
public static void isPositive(integer argument)
```
    Check that the numeric argument is strictly positive
    
    Parameters:
    
    argument - The argument to check
  - isPositive
```
public static void isPositive(integer argument,
                              character name)
```
    Check that the numeric argument is strictly positive
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isTrue
```
public static void isTrue(logical argument)
```
    Check that the logical argument is true
    
    Parameters:
    
    argument - The argument to check
  - isTrue
```
public static void isTrue(logical argument,
                          character name)
```
    Check that the logical argument is true
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(character argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(character argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(character[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(character[] argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(date argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(date argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(date[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(date[] argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(datetime argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(datetime argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(datetime[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(datetime[] argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(datetimetz argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(datetimetz argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(datetimetz[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(datetimetz[] argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(decimal argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(decimal argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(decimal[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(decimal[] argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(handle argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(handle argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(handle[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(handle[] argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(int64 argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(int64 argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(int64[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(int64[] argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(integer argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(integer argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(integer[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(integer[] argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(logical argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(logical argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(logical[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(logical[] argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(longchar argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(longchar argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(longchar[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(longchar[] argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(raw argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(raw argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isUnknown_
```
public static void isUnknown_(raw[] argument)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
  - isUnknown_
```
public static void isUnknown_(raw[] argument,
                              character name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isZero
```
public static void isZero(decimal argument)
```
    Check that the numeric argument is zero
    
    Parameters:
    
    argument - The argument to check
  - isZero
```
public static void isZero(decimal argument,
                          character name)
```
    Check that the numeric argument is zero
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isZero
```
public static void isZero(int64 argument)
```
    Check that the numeric argument is zero
    
    Parameters:
    
    argument - The argument to check
  - isZero
```
public static void isZero(int64 argument,
                          character name)
```
    Check that the numeric argument is zero
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isZero
```
public static void isZero(integer argument)
```
    Check that the numeric argument is zero
    
    Parameters:
    
    argument - The argument to check
  - isZero
```
public static void isZero(integer argument,
                          character name)
```
    Check that the numeric argument is zero
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isZeroOrNegative
```
public static void isZeroOrNegative(decimal argument)
```
    Check that the numeric argument is zero or negative
    
    Parameters:
    
    argument - The argument to check
  - isZeroOrNegative
```
public static void isZeroOrNegative(decimal argument,
                                    character name)
```
    Check that the numeric argument is zero or negative
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isZeroOrNegative
```
public static void isZeroOrNegative(int64 argument)
```
    Check that the numeric argument is zero or negative
    
    Parameters:
    
    argument - The argument to check
  - isZeroOrNegative
```
public static void isZeroOrNegative(int64 argument,
                                    character name)
```
    Check that the numeric argument is zero or negative
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isZeroOrNegative
```
public static void isZeroOrNegative(integer argument)
```
    Check that the numeric argument is zero or negative
    
    Parameters:
    
    argument - The argument to check
  - isZeroOrNegative
```
public static void isZeroOrNegative(integer argument,
                                    character name)
```
    Check that the numeric argument is zero or negative
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isZeroOrPositive
```
public static void isZeroOrPositive(decimal argument)
```
    Check that the numeric argument is zero or positive
    
    Parameters:
    
    argument - The argument to check
  - isZeroOrPositive
```
public static void isZeroOrPositive(decimal argument,
                                    character name)
```
    Check that the numeric argument is zero or positive
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isZeroOrPositive
```
public static void isZeroOrPositive(int64 argument)
```
    Check that the numeric argument is zero or positive
    
    Parameters:
    
    argument - The argument to check
  - isZeroOrPositive
```
public static void isZeroOrPositive(int64 argument,
                                    character name)
```
    Check that the numeric argument is zero or positive
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isZeroOrPositive
```
public static void isZeroOrPositive(integer argument)
```
    Check that the numeric argument is zero or positive
    
    Parameters:
    
    argument - The argument to check
  - isZeroOrPositive
```
public static void isZeroOrPositive(integer argument,
                                    character name)
```
    Check that the numeric argument is zero or positive
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - legacyEquals
```
public static void legacyEquals(character expected,
                                character actual)
```
    Check that two arguments are equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - legacyEquals
```
public static void legacyEquals(date expected,
                                date actual)
```
    Check that two arguments are equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - legacyEquals
```
public static void legacyEquals(datetime expected,
                                datetime actual)
```
    Check that two arguments are equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - legacyEquals
```
public static void legacyEquals(datetimetz expected,
                                datetimetz actual)
```
    Check that two arguments are equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - legacyEquals
```
public static void legacyEquals(decimal expected,
                                decimal actual)
```
    Check that two arguments are equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - legacyEquals
```
public static void legacyEquals(handle expected,
                                handle actual)
```
    Check that two arguments are equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - legacyEquals
```
public static void legacyEquals(int64 expected,
                                int64 actual)
```
    Check that two arguments are equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - legacyEquals
```
public static void legacyEquals(integer expected,
                                integer actual)
```
    Check that two arguments are equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - legacyEquals
```
public static void legacyEquals(logical expected,
                                logical actual)
```
    Check that two arguments are equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - legacyEquals
```
public static void legacyEquals(longchar expected,
                                longchar actual)
```
    Check that two arguments are equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - legacyEquals
```
public static void legacyEquals(memptr expected,
                                memptr actual)
```
    Check that two arguments are equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - legacyEquals
```
public static void legacyEquals(raw expected,
                                raw actual)
```
    Check that two arguments are equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - legacyEquals
```
public static void legacyEquals(recid expected,
                                recid actual)
```
    Check that two arguments are equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - legacyEquals
```
public static void legacyEquals(rowid expected,
                                rowid actual)
```
    Check that two arguments are equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - notAvailable
```
public static void notAvailable(handle argument)
```
    Check that the buffer argument is not available
    
    Parameters:
    
    argument - The argument to check
  - notAvailable
```
public static void notAvailable(handle argument,
                                character name)
```
    Check that the buffer argument is not available
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notEmpty
```
public static void notEmpty(character argument)
```
    Check that the argument is not empty
    
    Parameters:
    
    argument - The argument to check
  - notEmpty
```
public static void notEmpty(character argument,
                            character name)
```
    Check that the argument is not empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notEmpty
```
public static void notEmpty(character[] argument)
```
    Check that the argument is not empty
    
    Parameters:
    
    argument - The argument to check
  - notEmpty
```
public static void notEmpty(character[] argument,
                            character name)
```
    Check that the argument is not empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notEmpty
```
public static void notEmpty(handle argument)
```
    Check that the argument is not empty
    
    Parameters:
    
    argument - The argument to check
  - notEmpty
```
public static void notEmpty(handle argument,
                            character name)
```
    Check that the argument is not empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notEmpty
```
public static void notEmpty(handle[] argument)
```
    Check that the argument is not empty
    
    Parameters:
    
    argument - The argument to check
  - notEmpty
```
public static void notEmpty(handle[] argument,
                            character name)
```
    Check that the argument is not empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notEmpty
```
public static void notEmpty(longchar argument)
```
    Check that the argument is not empty
    
    Parameters:
    
    argument - The argument to check
  - notEmpty
```
public static void notEmpty(longchar argument,
                            character name)
```
    Check that the argument is not empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notEmpty
```
public static void notEmpty(longchar[] argument)
```
    Check that the argument is not empty
    
    Parameters:
    
    argument - The argument to check
  - notEmpty
```
public static void notEmpty(longchar[] argument,
                            character name)
```
    Check that the argument is not empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notEmpty
```
public static void notEmpty(memptr argument)
```
    Check that the argument is not empty
    
    Parameters:
    
    argument - The argument to check
  - notEmpty
```
public static void notEmpty(memptr argument,
                            character name)
```
    Check that the argument is not empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notEmpty
```
public static void notEmpty(memptr[] argument)
```
    Check that the argument is not empty
    
    Parameters:
    
    argument - The argument to check
  - notEmpty
```
public static void notEmpty(memptr[] argument,
                            character name)
```
    Check that the argument is not empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notEqual
```
public static void notEqual(character expected,
                            character actual)
```
    Check that two arguments are not equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - notEqual
```
public static void notEqual(date expected,
                            date actual)
```
    Check that two arguments are not equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - notEqual
```
public static void notEqual(datetime expected,
                            datetime actual)
```
    Check that two arguments are not equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - notEqual
```
public static void notEqual(datetimetz expected,
                            datetimetz actual)
```
    Check that two arguments are not equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - notEqual
```
public static void notEqual(decimal expected,
                            decimal actual)
```
    Check that two arguments are not equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - notEqual
```
public static void notEqual(handle expected,
                            handle actual)
```
    Check that two arguments are not equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - notEqual
```
public static void notEqual(int64 expected,
                            int64 actual)
```
    Check that two arguments are not equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - notEqual
```
public static void notEqual(integer expected,
                            integer actual)
```
    Check that two arguments are not equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - notEqual
```
public static void notEqual(logical expected,
                            logical actual)
```
    Check that two arguments are not equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - notEqual
```
public static void notEqual(longchar expected,
                            longchar actual)
```
    Check that two arguments are not equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - notEqual
```
public static void notEqual(memptr expected,
                            memptr actual)
```
    Check that two arguments are not equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - notEqual
```
public static void notEqual(raw expected,
                            raw actual)
```
    Check that two arguments are not equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - notEqual
```
public static void notEqual(recid expected,
                            recid actual)
```
    Check that two arguments are not equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - notEqual
```
public static void notEqual(rowid expected,
                            rowid actual)
```
    Check that two arguments are not equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - notFalse
```
public static void notFalse(logical argument)
```
    Check that the logical argument is not false (is true or unknown)
    
    Parameters:
    
    argument - The argument to check
  - notFalse
```
public static void notFalse(logical argument,
                            character name)
```
    Check that the logical argument is not false (is true or unknown)
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notIn
```
public static void notIn(character argument,
                         longchar list,
                         character name)
```
    Check that a character value is not in the list
    
    Parameters:
    
    argument - The argument to check
    
    list - The list to look up
    
    name - The name of the argument
  - notIn
```
public static void notIn(character argument,
                         longchar list,
                         character delimiter,
                         character name)
```
    Check that a character value is not in the list
    
    Parameters:
    
    argument - The argument to check
    
    list - The list to look up
    
    delimiter - List delimiter
    
    name - The name of the argument
  - notNull
```
public static void notNull(character argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(character argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNull
```
public static void notNull(character[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(character[] argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNull
```
public static void notNull(date argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(date argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNull
```
public static void notNull(date[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(date[] argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNull
```
public static void notNull(datetime argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(datetime argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNull
```
public static void notNull(datetime[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(datetime[] argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNull
```
public static void notNull(datetimetz argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(datetimetz argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNull
```
public static void notNull(datetimetz[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(datetimetz[] argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNull
```
public static void notNull(decimal argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(decimal argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNull
```
public static void notNull(decimal[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(decimal[] argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNull
```
public static void notNull(handle argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(handle argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNull
```
public static void notNull(handle[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(handle[] argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNull
```
public static void notNull(int64 argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(int64 argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNull
```
public static void notNull(int64[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(int64[] argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNull
```
public static void notNull(integer argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(integer argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNull
```
public static void notNull(integer[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(integer[] argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNull
```
public static void notNull(logical argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(logical argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNull
```
public static void notNull(logical[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(logical[] argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNull
```
public static void notNull(longchar argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(longchar argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNull
```
public static void notNull(longchar[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(longchar[] argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNull
```
public static void notNull(raw argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(raw argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNull
```
public static void notNull(raw[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notNull
```
public static void notNull(raw[] argument,
                           character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNullOrEmpty
```
public static void notNullOrEmpty(character argument)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
  - notNullOrEmpty
```
public static void notNullOrEmpty(character argument,
                                  character name)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNullOrEmpty
```
public static void notNullOrEmpty(character[] argument)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
  - notNullOrEmpty
```
public static void notNullOrEmpty(character[] argument,
                                  character name)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNullOrEmpty
```
public static void notNullOrEmpty(longchar argument)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
  - notNullOrEmpty
```
public static void notNullOrEmpty(longchar argument,
                                  character name)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNullOrEmpty
```
public static void notNullOrEmpty(longchar[] argument)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
  - notNullOrEmpty
```
public static void notNullOrEmpty(longchar[] argument,
                                  character name)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNullOrEmptyCollection
```
public static void notNullOrEmptyCollection(object<? extends Icollection> argument)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
  - notNullOrEmptyCollection
```
public static void notNullOrEmptyCollection(object<? extends Icollection> argument,
                                            character name)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNullOrEmptyMap
```
public static void notNullOrEmptyMap(object<? extends Imap> argument)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
  - notNullOrEmptyMap
```
public static void notNullOrEmptyMap(object<? extends Imap> argument,
                                     character name)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNullOrEmptyObject
```
public static void notNullOrEmptyObject(object<? extends _BaseObject_> argument)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
  - notNullOrEmptyObject
```
public static void notNullOrEmptyObject(object<? extends _BaseObject_> argument,
                                        character name)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNullOrEmptyObjectArray
```
public static void notNullOrEmptyObjectArray(object<? extends _BaseObject_>[] argument)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
  - notNullOrEmptyObjectArray
```
public static void notNullOrEmptyObjectArray(object<? extends _BaseObject_>[] argument,
                                             character name)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNullOrZero
```
public static void notNullOrZero(decimal argument)
```
    Check that the numeric argument is neither unknown nor zero
    
    Parameters:
    
    argument - The argument to check
  - notNullOrZero
```
public static void notNullOrZero(decimal argument,
                                 character name)
```
    Check that the numeric argument is neither unknown nor zero
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNullOrZero
```
public static void notNullOrZero(int64 argument)
```
    Check that the numeric argument is neither unknown nor zero
    
    Parameters:
    
    argument - The argument to check
  - notNullOrZero
```
public static void notNullOrZero(int64 argument,
                                 character name)
```
    Check that the numeric argument is neither unknown nor zero
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNullOrZero
```
public static void notNullOrZero(integer argument)
```
    Check that the numeric argument is neither unknown nor zero
    
    Parameters:
    
    argument - The argument to check
  - notNullOrZero
```
public static void notNullOrZero(integer argument,
                                 character name)
```
    Check that the numeric argument is neither unknown nor zero
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notTrue
```
public static void notTrue(logical argument)
```
    Check that the logical argument is not true (is false or unknown)
    
    Parameters:
    
    argument - The argument to check
  - notTrue
```
public static void notTrue(logical argument,
                           character name)
```
    Check that the logical argument is not true (is false or unknown)
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(character argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(character argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(character[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(character[] argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(date argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(date argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(date[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(date[] argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(datetime argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(datetime argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(datetime[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(datetime[] argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(datetimetz argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(datetimetz argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(datetimetz[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(datetimetz[] argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(decimal argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(decimal argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(decimal[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(decimal[] argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(handle argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(handle argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(handle[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(handle[] argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(int64 argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(int64 argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(int64[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(int64[] argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(integer argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(integer argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(integer[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(integer[] argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(logical argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(logical argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(logical[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(logical[] argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(longchar argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(longchar argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(longchar[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(longchar[] argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(raw argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(raw argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknown
```
public static void notUnknown(raw[] argument)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
  - notUnknown
```
public static void notUnknown(raw[] argument,
                              character name)
```
    Check that the argument is not unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknownOrEmpty
```
public static void notUnknownOrEmpty(character argument)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
  - notUnknownOrEmpty
```
public static void notUnknownOrEmpty(character argument,
                                     character name)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknownOrEmpty
```
public static void notUnknownOrEmpty(character[] argument)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
  - notUnknownOrEmpty
```
public static void notUnknownOrEmpty(character[] argument,
                                     character name)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknownOrEmpty
```
public static void notUnknownOrEmpty(longchar argument)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
  - notUnknownOrEmpty
```
public static void notUnknownOrEmpty(longchar argument,
                                     character name)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknownOrEmpty
```
public static void notUnknownOrEmpty(object<? extends _BaseObject_>[] argument,
                                     character name)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknownOrEmptyObject
```
public static void notUnknownOrEmptyObject(object<? extends _BaseObject_> argument,
                                           character name)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notZero
```
public static void notZero(decimal argument)
```
    Check that the numeric argument is not zero
    
    Parameters:
    
    argument - The argument to check
  - notZero
```
public static void notZero(decimal argument,
                           character name)
```
    Check that the numeric argument is not zero
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notZero
```
public static void notZero(int64 argument)
```
    Check that the numeric argument is not zero
    
    Parameters:
    
    argument - The argument to check
  - notZero
```
public static void notZero(int64 argument,
                           character name)
```
    Check that the numeric argument is not zero
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notZero
```
public static void notZero(integer argument)
```
    Check that the numeric argument is not zero
    
    Parameters:
    
    argument - The argument to check
  - notZero
```
public static void notZero(integer argument,
                           character name)
```
    Check that the numeric argument is not zero
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - nonZero
```
public static void nonZero(decimal argument)
```
    Check that the numeric argument is not zero
    
    Parameters:
    
    argument - The argument to check
  - nonZero
```
public static void nonZero(decimal argument,
                           character name)
```
    Check that the numeric argument is not zero
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - nonZero
```
public static void nonZero(int64 argument)
```
    Check that the numeric argument is not zero
    
    Parameters:
    
    argument - The argument to check
  - nonZero
```
public static void nonZero(int64 argument,
                           character name)
```
    Check that the numeric argument is not zero
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - nonZero
```
public static void nonZero(integer argument)
```
    Check that the numeric argument is not zero
    
    Parameters:
    
    argument - The argument to check
  - nonZero
```
public static void nonZero(integer argument,
                           character name)
```
    Check that the numeric argument is not zero
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - raiseError
```
public static void raiseError(character message)
```
    Throw AssertionFailedError with the given message
    
    Parameters:
    
    message - The failure message
  - call
```
private static void call(java.lang.String legacyName,
                         Body body)
```
    Implementation helper for all test methods in this very class.
    
    Parameters:
    
    legacyName - the legacy name of the method
    
    body - the method body
  - isDecimalImpl
```
private static void isDecimalImpl(character argument,
                                  java.lang.String name)
```
    Check that the character argument can be parsed to a decimal value
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isEmptyImpl
```
private static void isEmptyImpl(handle argument,
                                java.lang.String name)
```
    Check that a handle is empty (not available)
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isEmptyImpl
```
private static void isEmptyImpl(memptr argument,
                                java.lang.String name)
```
    Check that the argument is empty (size is zero)
    
    Parameters:
    
    argument - the value to check
    
    name - the argument name to use in the failure message
  - isEmptyImpl
```
private static void isEmptyImpl(Text argument,
                                java.lang.String name)
```
    Check that the argument is empty (contains no characters).
    
    Parameters:
    
    argument - the value to check
    
    name - the argument name to use in the failure message
  - isInImpl
```
private static void isInImpl(character argument,
                             longchar list,
                             character delimiter,
                             character name)
```
    Check that a character value is in the list
    
    Parameters:
    
    argument - The argument to check
    
    list - The list to look up
    
    delimiter - List delimiter
    
    name - The name of the argument
  - isInt64Impl
```
private static void isInt64Impl(character argument,
                                java.lang.String name)
```
    Check that the character argument can be parsed to an int64 value
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isIntegerImpl
```
private static void isIntegerImpl(character argument,
                                  java.lang.String name)
```
    Check that the character argument can be parsed to an integer value
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isLogicalImpl
```
private static void isLogicalImpl(character argument,
                                  character mask,
                                  java.lang.String name)
```
    Check that the character argument can be parsed to a logical value
    
    Parameters:
    
    argument - The argument to check
    
    mask - parse format, e.g. "yes/no", "da/net"
    
    name - The name of the argument
  - isLogicalImpl
```
private static void isLogicalImpl(character argument,
                                  java.lang.String name)
```
    Check that the character argument can be parsed to a logical value
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNegativeImpl
```
private static void isNegativeImpl(NumberType argument,
                                   java.lang.String name)
```
    Check that the numeric argument is strictly negative
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isNullImpl
```
private static void isNullImpl(BaseDataType argument,
                               java.lang.String name)
```
    Check that the argument is unknown
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isPositiveImpl
```
public static void isPositiveImpl(NumberType argument,
                                  java.lang.String name)
```
    Check that the numeric argument is strictly positive
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isZeroImpl
```
private static void isZeroImpl(NumberType argument,
                               java.lang.String name)
```
    Check that the numeric argument is zero
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isZeroOrNegativeImpl
```
private static void isZeroOrNegativeImpl(NumberType argument,
                                         java.lang.String name)
```
    Check that the numeric argument is zero or negative
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - isZeroOrPositiveImpl
```
public static void isZeroOrPositiveImpl(NumberType argument,
                                        java.lang.String name)
```
    Check that the numeric argument is zero or positive
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notAvailableImpl
```
private static void notAvailableImpl(handle argument,
                                     java.lang.String name)
```
    Check that the buffer argument is not available
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notEmptyImpl
```
private static void notEmptyImpl(BaseDataType[] argument,
                                 java.lang.String name)
```
    Check that the argument is not empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notEqualImpl
```
private static void notEqualImpl(BaseDataType expected,
                                 BaseDataType actual)
```
    Check that two arguments are not equal
    
    Parameters:
    
    expected - The expected value
    
    actual - The actual value
  - notFalseImpl
```
private static void notFalseImpl(logical argument,
                                 java.lang.String name)
```
    Check that the logical argument is not false (is true or unknown)
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notInImpl
```
private static void notInImpl(Text argument,
                              longchar list,
                              Text delimiter,
                              character name)
```
    Check that a character value is not in the list
    
    Parameters:
    
    argument - The argument to check
    
    list - The list to look up
    
    delimiter - List delimiter
    
    name - The name of the argument
  - notNullImpl
```
private static void notNullImpl(handle argument,
                                java.lang.String name)
```
    Check that the argument is not unknown and valid
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNullOrEmptyImpl
```
public static void notNullOrEmptyImpl(BaseDataType argument,
                                      java.lang.String name)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNullOrEmptyImpl
```
private static void notNullOrEmptyImpl(BaseDataType[] argument,
                                       java.lang.String name)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notNullOrZeroImpl
```
private static void notNullOrZeroImpl(NumberType argument,
                                      java.lang.String name)
```
    Check that the numeric argument is neither unknown nor zero
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notTrueImpl
```
private static void notTrueImpl(logical argument,
                                java.lang.String name)
```
    Check that the logical argument is not true (is false or unknown)
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknownOrEmptyImpl
```
private static void notUnknownOrEmptyImpl(BaseDataType[] argument,
                                          java.lang.String name)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notUnknownOrEmptyImpl
```
private static void notUnknownOrEmptyImpl(Text argument,
                                          java.lang.String name)
```
    Check that the argument is neither unknown nor empty
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - nonZeroImpl
```
private static void nonZeroImpl(NumberType argument,
                                java.lang.String name)
```
    Check that the numeric argument is not zero
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - notZeroImpl
```
private static void notZeroImpl(NumberType argument,
                                java.lang.String name)
```
    Check that the numeric argument is not zero
    
    Parameters:
    
    argument - The argument to check
    
    name - The name of the argument
  - raiseNonNegative
```
private static void raiseNonNegative(java.lang.String name)
```
    Raise an ERROR condition as the value is not negative.
    
    Parameters:
    
    name - The name of the value.
  - raiseNonPositive
```
private static void raiseNonPositive(java.lang.String name)
```
    Raise an ERROR condition as the value is not positive.
    
    Parameters:
    
    name - The name of the value.
  - raiseNonZero
```
private static void raiseNonZero(java.lang.String name)
```
    Raise an ERROR condition as the value is not zero.
    
    Parameters:
    
    name - The name of the value.
  - raiseNonZeroOrNegative
```
private static void raiseNonZeroOrNegative(java.lang.String name)
```
    Raise an ERROR condition as the value is not zero or negative.
    
    Parameters:
    
    name - The name of the value.
  - raiseNonZeroOrPositive
```
private static void raiseNonZeroOrPositive(java.lang.String name)
```
    Raise an ERROR condition as the value is not zero or positive.
    
    Parameters:
    
    name - The name of the value.
  - raiseZero
```
private static void raiseZero(java.lang.String name)
```
    Raise an ERROR condition as the value is zero.
    
    Parameters:
    
    name - The name of the value.
  - __core_Assert_constructor__
```
public void __core_Assert_constructor__()
```
    The "default" constructor.
  - __core_Assert_execute__
```
public void __core_Assert_execute__()
```
    Initialize this procedure

Class Assert

Field Summary

Fields inherited from class com.goldencode.p2j.oo.core.AbstractAssert

Constructor Summary

Method Summary

Methods inherited from class com.goldencode.p2j.oo.core.AbstractAssert

Methods inherited from class com.goldencode.p2j.oo.lang.BaseObject

Methods inherited from class java.lang.Object

Methods inherited from interface com.goldencode.p2j.oo.lang._BaseObject_

Constructor Detail

Assert

Method Detail

__core_Assert_constructor__static__

isAvailable

isAvailable

isDecimal

isDecimal

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isFalse

isFalse

isIn

isIn

isInt64

isInt64

isInteger

isInteger

isLogical

isLogical

isLogical

isNegative

isNegative

isNegative

isNegative

isNegative

isNegative

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

isNull

__core_Assert_constructorstatic