# Assert.java

    /*
    ** Module   : Assert.java
    ** Abstract : Implementation of the OpenEdge.Core.Assert builtin class.
    **
    ** Copyright (c) 2019-2023, Golden Code Development Corporation.
    **
    ** -#- -I- --Date-- -------------------------------Description--------------------------------
    ** 001 CA  20190423 Created the first version, by converting the legacy skeleton .cls file and
    **                  using that output.
    ** 002 CA  20190508 Fixed the converted package.
    ** 002 CA  20190710 Added LegacyResource annotation.  Implemented Equals, NotEquals, IsFalse,
    **                  IsTrue.
    ** 003 IAS 20190923 Added implementation of additional methods
    ** 004 CA  20191024 Added method support levels and updated the class support level.
    ** 005 ME  20201023 Added implementation for isType, notType.
    **     ME  20210916 Delegate to AssertObject as needed.
    **     ME  20210930 Remove use of Apache StringUtils.
    ** 006 VVT 20230318 The file re-designed completely, API is compatible with the latest
    **                  OE releases. Javadocs added. All methods are now fully implemented.
    **                  See #3827.
    ** 007 VVT 20230504 Assert:NonZero support added. See #3827-399.
    ** 008 CA  20231113 The 'execute' method must be annotated with LegacySignature Type.Execute, and also can be
    **                  dropped if is a no-op.
    */

    /*
    ** This program is free software: you can redistribute it and/or modify
    ** it under the terms of the GNU Affero General Public License as
    ** published by the Free Software Foundation, either version 3 of the
    ** License, or (at your option) any later version.
    **
    ** This program is distributed in the hope that it will be useful,
    ** but WITHOUT ANY WARRANTY; without even the implied warranty of
    ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    ** GNU Affero General Public License for more details.
    **
    ** You may find a copy of the GNU Affero GPL version 3 at the following
    ** location: https://www.gnu.org/licenses/agpl-3.0.en.html
    **
    ** Additional terms under GNU Affero GPL version 3 section 7:
    **
    **   Under Section 7 of the GNU Affero GPL version 3, the following additional
    **   terms apply to the works covered under the License.  These additional terms
    **   are non-permissive additional terms allowed under Section 7 of the GNU
    **   Affero GPL version 3 and may not be removed by you.
    **
    **   0. Attribution Requirement.
    **
    **     You must preserve all legal notices or author attributions in the covered
    **     work or Appropriate Legal Notices displayed by works containing the covered
    **     work.  You may not remove from the covered work any author or developer
    **     credit already included within the covered work.
    **
    **   1. No License To Use Trademarks.
    **
    **     This license does not grant any license or rights to use the trademarks
    **     Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks
    **     of Golden Code Development Corporation. You are not authorized to use the
    **     name Golden Code, FWD, or the names of any author or contributor, for
    **     publicity purposes without written authorization.
    **
    **   2. No Misrepresentation of Affiliation.
    **
    **     You may not represent yourself as Golden Code Development Corporation or FWD.
    **
    **     You may not represent yourself for publicity purposes as associated with
    **     Golden Code Development Corporation, FWD, or any author or contributor to
    **     the covered work, without written authorization.
    **
    **   3. No Misrepresentation of Source or Origin.
    **
    **     You may not represent the covered work as solely your work.  All modified
    **     versions of the covered work must be marked in a reasonable way to make it
    **     clear that the modified work is not originating from Golden Code Development
    **     Corporation or FWD.  All modified versions must contain the notices of
    **     attribution required in this license.
    */
    package com.goldencode.p2j.oo.core;

    import static com.goldencode.p2j.report.ReportConstants.*;
    import static com.goldencode.p2j.util.BlockManager.*;
    import static com.goldencode.p2j.util.ErrorManager.silent;
    import static com.goldencode.p2j.util.TextOps.substitute;

    import com.goldencode.p2j.oo.core.assertion.*;
    import com.goldencode.p2j.oo.lang.*;
    import com.goldencode.p2j.util.*;
    import com.goldencode.p2j.util.InternalEntry.*;
    import com.goldencode.util.*;

    /**
     * Business logic (initially converted to Java from the 4GL source code in
     * OpenEdge/Core/Assert.cls).
     */
    @LegacyResource(resource = "OpenEdge.Core.Assert")
    @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_PARTIAL)
    public class Assert
    extends AbstractAssert
    {
       /**
        * The static constructor
        */
       @LegacySignature(type = Type.CONSTRUCTOR)
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void __core_Assert_constructor__static__()
       {
          externalProcedure(Assert.class, new Block((Body) () -> {
             onBlockLevel(Condition.ERROR, Action.THROW);
          }));
       }

       /**
        * Check that the buffer argument is available
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsAvailable", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isAvailable(final handle argument)
       {
          isAvailableImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the buffer argument is available
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsAvailable", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isAvailable(final handle argument, final character name)
       {
          isAvailableImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the character argument can be parsed to a decimal value
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsDecimal", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isDecimal(final character argument)
       {
          isDecimalImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the character argument can be parsed to a decimal value
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsDecimal", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isDecimal(final character argument, final character name)
       {
          isDecimalImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isEmpty(final character argument)
       {
          isEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isEmpty(final character argument, final character name)
       {
          isEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isEmpty(final handle argument)
       {
          isEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isEmpty(final handle argument, final character name)
       {
          isEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isEmpty(final longchar argument)
       {
          isEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isEmpty(final longchar argument, final character name)
       {
          isEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "MEMPTR", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isEmpty(final memptr argument)
       {
          isEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "MEMPTR", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isEmpty(final memptr argument, final character name)
       {
          isEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the logical argument is false
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsFalse", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isFalse(final logical argument)
       {
          // Notice: failure message is created differently!
          call("IsFalse", () -> {
             if (argument.isUnknown() || argument.booleanValue())
             {
                raiseError("Expected: FALSE but was: &1", argument);
             }
          });
       }

       /**
        * Check that the logical argument is false
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsFalse", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isFalse(final logical argument, final character name)
       {
          call("IsFalse", () -> {
             if (argument.isUnknown() || argument.booleanValue())
             {
                raiseError("&1 is not false", name);
             }
          });
       }

       /**
        * Check that a character value is in the list
        *
        * @param argument
        *        The argument to check
        * @param list
        *        The list to look up
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsIn", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "list", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isIn(final character argument, final longchar list, final character name)
       {
          isInImpl(argument, list, new character(","), name);
       }

       /**
        * Check that a character value is in the list
        *
        * @param argument
        *        The argument to check
        * @param list
        *        The list to look up
        * @param delimiter
        *        List delimiter
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsIn", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "list", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "delimiter", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isIn(final character argument, final longchar list,
                final character delimiter, final character name)
       {
          isInImpl(argument, list, delimiter, name);
       }

       /**
        * Check that the character argument can be parsed to an int64 value
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsInt64", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isInt64(final character argument)
       {
          isInt64Impl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the character argument can be parsed to an int64 value
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsInt64", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isInt64(final character argument, final character name)
       {
          isInt64Impl(argument, name.toStringMessage());
       }

       /**
        * Check that the character argument can be parsed to an integer value
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsInteger", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isInteger(final character argument)
       {
          isIntegerImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the character argument can be parsed to an integer value
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsInteger", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isInteger(final character argument, final character name)
       {
          isIntegerImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the character argument can be parsed to a logical value
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsLogical", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isLogical(final character argument)
       {
          isLogicalImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the character argument can be parsed to a logical value
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsLogical", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isLogical(final character argument, final character name)
       {
          isLogicalImpl(argument, name.toStringMessage());
       }

       /**
        * Asserts value can be parsed to a logical value with mask
        *
        * @param argument
        *        The argument to check
        * @param mask
        *        The mask
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsLogical", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "mask", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isLogical(final character argument, final character mask,
                final character name)
       {
          isLogicalImpl(argument, mask, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is strictly negative
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNegative", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNegative(final decimal argument)
       {
          isNegativeImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is strictly negative
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNegative", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNegative(final decimal argument, final character name)
       {
          isNegativeImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is strictly negative
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNegative", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNegative(final int64 argument)
       {
          isNegativeImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is strictly negative
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNegative", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNegative(final int64 argument, final character name)
       {
          isNegativeImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is strictly negative
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNegative", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNegative(final integer argument)
       {
          isNegativeImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is strictly negative
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNegative", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNegative(final integer argument, final character name)
       {
          isNegativeImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final character argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final character argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final character[] argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final character[] argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATE", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final date argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATE", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final date argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATE", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final date[] argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATE", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final date[] argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIME", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final datetime argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIME", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final datetime argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIME", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final datetime[] argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIME", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final datetime[] argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIMETZ", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final datetimetz argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIMETZ", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final datetimetz argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIMETZ", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final datetimetz[] argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIMETZ", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final datetimetz[] argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final decimal argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final decimal argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final decimal[] argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final decimal[] argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final handle argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final handle argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final handle[] argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final handle[] argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final int64 argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final int64 argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final int64[] argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final int64[] argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final integer argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final integer argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final integer[] argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final integer[] argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final logical argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final logical argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final logical[] argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final logical[] argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final longchar argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final longchar argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final longchar[] argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final longchar[] argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "RAW", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final raw argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "RAW", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final raw argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "RAW", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final raw[] argument)
       {
          isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "argument", type = "RAW", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isNull(final raw[] argument, final character name)
       {
          isNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is strictly positive
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsPositive", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isPositive(final decimal argument)
       {
          isPositiveImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is strictly positive
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsPositive", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isPositive(final decimal argument, final character name)
       {
          isPositiveImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is strictly positive
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsPositive", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isPositive(final int64 argument)
       {
          isPositiveImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is strictly positive
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsPositive", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isPositive(final int64 argument, final character name)
       {
          isPositiveImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is strictly positive
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsPositive", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isPositive(final integer argument)
       {
          isPositiveImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is strictly positive
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsPositive", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isPositive(final integer argument, final character name)
       {
          isPositiveImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the logical argument is true
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsTrue", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isTrue(final logical argument)
       {
          call("IsTrue", () -> {
             if (argument.isUnknown() || !argument.booleanValue())
             {
                raiseError("Expected: TRUE but was: &1", argument);
             }
          });
       }

       /**
        * Check that the logical argument is true
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsTrue", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isTrue(final logical argument, final character name)
       {
          call("IsTrue", () -> {
             if (argument.isUnknown() || !argument.booleanValue())
             {
                raiseError("&1 is not true", name.toStringMessage());
             }
          });
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final character argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final character argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final character[] argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final character[] argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATE", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final date argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATE", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final date argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATE", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final date[] argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATE", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final date[] argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIME", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final datetime argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIME", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final datetime argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIME", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final datetime[] argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIME", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final datetime[] argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIMETZ", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final datetimetz argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIMETZ", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final datetimetz argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIMETZ", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final datetimetz[] argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIMETZ", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final datetimetz[] argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final decimal argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final decimal argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final decimal[] argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final decimal[] argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final handle argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final handle argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final handle[] argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final handle[] argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final int64 argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final int64 argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final int64[] argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final int64[] argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final integer argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final integer argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final integer[] argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final integer[] argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final logical argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final logical argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final logical[] argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final logical[] argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final longchar argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final longchar argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final longchar[] argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final longchar[] argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "RAW", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final raw argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "RAW", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final raw argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "RAW", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final raw[] argument)
       {
          isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "RAW", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isUnknown_(final raw[] argument, final character name)
       {
          isUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is zero
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsZero", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isZero(final decimal argument)
       {
          isZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is zero
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsZero", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isZero(final decimal argument, final character name)
       {
          isZeroImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is zero
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsZero", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isZero(final int64 argument)
       {
          isZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is zero
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsZero", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isZero(final int64 argument, final character name)
       {
          isZeroImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is zero
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsZero", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isZero(final integer argument)
       {
          isZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is zero
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsZero", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isZero(final integer argument, final character name)
       {
          isZeroImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is zero or negative
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsZeroOrNegative", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isZeroOrNegative(final decimal argument)
       {
          isZeroOrNegativeImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is zero or negative
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsZeroOrNegative", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isZeroOrNegative(final decimal argument, final character name)
       {
          isZeroOrNegativeImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is zero or negative
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsZeroOrNegative", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isZeroOrNegative(final int64 argument)
       {
          isZeroOrNegativeImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is zero or negative
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsZeroOrNegative", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isZeroOrNegative(final int64 argument, final character name)
       {
          isZeroOrNegativeImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is zero or negative
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsZeroOrNegative", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isZeroOrNegative(final integer argument)
       {
          isZeroOrNegativeImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is zero or negative
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsZeroOrNegative", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isZeroOrNegative(final integer argument, final character name)
       {
          isZeroOrNegativeImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is zero or positive
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsZeroOrPositive", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isZeroOrPositive(final decimal argument)
       {
          isZeroOrPositiveImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is zero or positive
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsZeroOrPositive", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isZeroOrPositive(final decimal argument, final character name)
       {
          isZeroOrPositiveImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is zero or positive
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsZeroOrPositive", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isZeroOrPositive(final int64 argument)
       {
          isZeroOrPositiveImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is zero or positive
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsZeroOrPositive", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isZeroOrPositive(final int64 argument, final character name)
       {
          isZeroOrPositiveImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is zero or positive
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "IsZeroOrPositive", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isZeroOrPositive(final integer argument)
       {
          isZeroOrPositiveImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is zero or positive
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "IsZeroOrPositive", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void isZeroOrPositive(final integer argument, final character name)
       {
          isZeroOrPositiveImpl(argument, name.toStringMessage());
       }

       /**
        * Check that two arguments are equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
                @LegacyParameter(name = "expected", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void legacyEquals(final character expected, final character actual)
       {
          equalsImpl(expected, actual);
       }

       /**
        * Check that two arguments are equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
                @LegacyParameter(name = "expected", type = "DATE", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "DATE", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void legacyEquals(final date expected, final date actual)
       {
          equalsImpl(expected, actual);
       }

       /**
        * Check that two arguments are equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
                @LegacyParameter(name = "expected", type = "DATETIME", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "DATETIME", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void legacyEquals(final datetime expected, final datetime actual)
       {
          equalsImpl(expected, actual);
       }

       /**
        * Check that two arguments are equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
                @LegacyParameter(name = "expected", type = "DATETIMETZ", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "DATETIMETZ", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void legacyEquals(final datetimetz expected, final datetimetz actual)
       {
          equalsImpl(expected, actual);
       }

       /**
        * Check that two arguments are equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
                @LegacyParameter(name = "expected", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "DECIMAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void legacyEquals(final decimal expected, final decimal actual)
       {
          equalsImpl(expected, actual);
       }

       /**
        * Check that two arguments are equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
                @LegacyParameter(name = "expected", type = "HANDLE", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "HANDLE", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void legacyEquals(final handle expected, final handle actual)
       {
          equalsImpl(expected, actual);
       }

       /**
        * Check that two arguments are equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
                @LegacyParameter(name = "expected", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "INT64", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void legacyEquals(final int64 expected, final int64 actual)
       {
          equalsImpl(expected, actual);
       }

       /**
        * Check that two arguments are equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
                @LegacyParameter(name = "expected", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "INTEGER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void legacyEquals(final integer expected, final integer actual)
       {
          equalsImpl(expected, actual);
       }

       /**
        * Check that two arguments are equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
                @LegacyParameter(name = "expected", type = "LOGICAL", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "LOGICAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void legacyEquals(final logical expected, final logical actual)
       {
          equalsImpl(expected, actual);
       }

       /**
        * Check that two arguments are equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
                @LegacyParameter(name = "expected", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "LONGCHAR", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void legacyEquals(final longchar expected, final longchar actual)
       {
          equalsImpl(expected, actual);
       }

       /**
        * Check that two arguments are equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
                @LegacyParameter(name = "expected", type = "MEMPTR", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "MEMPTR", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void legacyEquals(final memptr expected, final memptr actual)
       {
          equalsImpl(expected.length(), actual.length());

          call("Equals", () -> {
             if (!SecurityOps.messageDigest("SHA-256", expected)
                      .equals(SecurityOps.messageDigest("SHA-256", actual)))
             {
                raiseError("Hashes of memptr values are not equal");
             }
          });
       }

       /**
        * Check that two arguments are equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
                @LegacyParameter(name = "expected", type = "RAW", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "RAW", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void legacyEquals(final raw expected, final raw actual)
       {
          equalsImpl(expected, actual);
       }

       /**
        * Check that two arguments are equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
                @LegacyParameter(name = "expected", type = "RECID", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "RECID", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void legacyEquals(final recid expected, final recid actual)
       {
          equalsImpl(expected, actual);
       }

       /**
        * Check that two arguments are equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
                @LegacyParameter(name = "expected", type = "ROWID", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "ROWID", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void legacyEquals(final rowid expected, final rowid actual)
       {
          equalsImpl(expected, actual);
       }

       /**
        * Check that the buffer argument is not available
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotAvailable", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notAvailable(final handle argument)
       {
          notAvailableImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the buffer argument is not available
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotAvailable", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notAvailable(final handle argument, final character name)
       {
          notAvailableImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEmpty(final character argument)
       {
          notEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEmpty(final character argument, final character name)
       {
          notEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEmpty(final character[] argument)
       {
          notEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEmpty(final character[] argument, final character name)
       {
          notEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEmpty(final handle argument)
       {
          notEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEmpty(final handle argument, final character name)
       {
          notEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEmpty(final handle[] argument)
       {
          notEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEmpty(final handle[] argument, final character name)
       {
          notEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEmpty(final longchar argument)
       {
          notEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEmpty(final longchar argument, final character name)
       {
          notEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEmpty(final longchar[] argument)
       {
          notEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEmpty(final longchar[] argument, final character name)
       {
          notEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "MEMPTR", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEmpty(final memptr argument)
       {
          notEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "MEMPTR", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEmpty(final memptr argument, final character name)
       {
          notEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "MEMPTR", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEmpty(final memptr[] argument)
       {
          notEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "MEMPTR", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEmpty(final memptr[] argument, final character name)
       {
          notEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that two arguments are not equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
                @LegacyParameter(name = "expected", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEqual(final character expected, final character actual)
       {
          notEqualImpl(expected, actual);
       }

       /**
        * Check that two arguments are not equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
                @LegacyParameter(name = "expected", type = "DATE", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "DATE", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEqual(final date expected, final date actual)
       {
          notEqualImpl(expected, actual);
       }

       /**
        * Check that two arguments are not equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
                @LegacyParameter(name = "expected", type = "DATETIME", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "DATETIME", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEqual(final datetime expected, final datetime actual)
       {
          notEqualImpl(expected, actual);
       }

       /**
        * Check that two arguments are not equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
                @LegacyParameter(name = "expected", type = "DATETIMETZ", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "DATETIMETZ", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEqual(final datetimetz expected, final datetimetz actual)
       {
          notEqualImpl(expected, actual);
       }

       /**
        * Check that two arguments are not equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
                @LegacyParameter(name = "expected", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "DECIMAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEqual(final decimal expected, final decimal actual)
       {
          notEqualImpl(expected, actual);
       }

       /**
        * Check that two arguments are not equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
                @LegacyParameter(name = "expected", type = "HANDLE", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "HANDLE", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEqual(final handle expected, final handle actual)
       {
          notEqualImpl(expected, actual);
       }

       /**
        * Check that two arguments are not equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
                @LegacyParameter(name = "expected", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "INT64", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEqual(final int64 expected, final int64 actual)
       {
          notEqualImpl(expected, actual);
       }

       /**
        * Check that two arguments are not equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
                @LegacyParameter(name = "expected", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "INTEGER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEqual(final integer expected, final integer actual)
       {
          notEqualImpl(expected, actual);
       }

       /**
        * Check that two arguments are not equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
                @LegacyParameter(name = "expected", type = "LOGICAL", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "LOGICAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEqual(final logical expected, final logical actual)
       {
          notEqualImpl(expected, actual);
       }

       /**
        * Check that two arguments are not equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
                @LegacyParameter(name = "expected", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "LONGCHAR", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEqual(final longchar expected, final longchar actual)
       {
          notEqualImpl(expected, actual);
       }

       /**
        * Check that two arguments are not equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
                @LegacyParameter(name = "expected", type = "MEMPTR", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "MEMPTR", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEqual(final memptr expected, final memptr actual)
       {
          // FIXME probably needs special treatment.
          notEqualImpl(expected, actual);
       }

       /**
        * Check that two arguments are not equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
                @LegacyParameter(name = "expected", type = "RAW", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "RAW", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEqual(final raw expected, final raw actual)
       {
          notEqualImpl(expected, actual);
       }

       /**
        * Check that two arguments are not equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
                @LegacyParameter(name = "expected", type = "RECID", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "RECID", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEqual(final recid expected, final recid actual)
       {
          notEqualImpl(expected, actual);
       }

       /**
        * Check that two arguments are not equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       @LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
                @LegacyParameter(name = "expected", type = "ROWID", mode = "INPUT"),
                @LegacyParameter(name = "actual", type = "ROWID", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notEqual(final rowid expected, final rowid actual)
       {
          notEqualImpl(expected, actual);
       }

       /**
        * Check that the logical argument is not false (is true or unknown)
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotFalse", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notFalse(final logical argument)
       {
          notFalseImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the logical argument is not false (is true or unknown)
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotFalse", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notFalse(final logical argument, final character name)
       {
          notFalseImpl(argument, name.toStringMessage());
       }

       /**
        * Check that a character value is not in the list
        *
        * @param argument
        *        The argument to check
        * @param list
        *        The list to look up
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotIn", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "list", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notIn(final character argument, final longchar list, final character name)
       {
          notInImpl(argument, list, new character(","), name);
       }

       /**
        * Check that a character value is not in the list
        *
        * @param argument
        *        The argument to check
        * @param list
        *        The list to look up
        * @param delimiter
        *        List delimiter
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotIn", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "list", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "delimiter", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notIn(final character argument, final longchar list,
                final character delimiter, final character name)
       {
          notInImpl(argument, list, delimiter, name);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final character argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final character argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final character[] argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final character[] argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATE", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final date argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATE", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final date argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATE", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final date[] argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATE", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final date[] argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIME", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final datetime argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIME", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final datetime argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIME", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final datetime[] argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIME", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final datetime[] argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIMETZ", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final datetimetz argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIMETZ", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final datetimetz argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIMETZ", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final datetimetz[] argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIMETZ", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final datetimetz[] argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final decimal argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final decimal argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final decimal[] argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final decimal[] argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final handle argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final handle argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final handle[] argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final handle[] argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final int64 argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final int64 argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final int64[] argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final int64[] argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final integer argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final integer argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final integer[] argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final integer[] argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final logical argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final logical argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final logical[] argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final logical[] argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final longchar argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final longchar argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final longchar[] argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final longchar[] argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "RAW", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final raw argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "RAW", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final raw argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "RAW", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final raw[] argument)
       {
          notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
                @LegacyParameter(name = "argument", type = "RAW", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNull(final raw[] argument, final character name)
       {
          notNullImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrEmpty(final character argument)
       {
          notNullOrEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrEmpty(final character argument, final character name)
       {
          notNullOrEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrEmpty(final character[] argument)
       {
          notNullOrEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrEmpty(final character[] argument, final character name)
       {
          notNullOrEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrEmpty(final longchar argument)
       {
          notNullOrEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrEmpty(final longchar argument, final character name)
       {
          notNullOrEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrEmpty(final longchar[] argument)
       {
          notNullOrEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrEmpty(final longchar[] argument, final character name)
       {
          notNullOrEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "OBJECT", qualified = "openedge.core.collections.icollection", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrEmptyCollection(
                final object<? extends com.goldencode.p2j.oo.core.collections.Icollection> argument)
       {
          notNullOrEmptyCollection(argument, new character(DEFAULT_ARGUMENT_NAME));
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
                @LegacyParameter(name = "argument", qualified = "openedge.core.collections.icollection", type = "OBJECT", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrEmptyCollection(
                final object<? extends com.goldencode.p2j.oo.core.collections.Icollection> argument,
                final character name)
       {
          AssertObject.notNullOrEmptyCollection(argument, name);
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
                @LegacyParameter(name = "argument", qualified = "openedge.core.collections.imap", type = "OBJECT", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrEmptyMap(
                final object<? extends com.goldencode.p2j.oo.core.collections.Imap> argument)
       {
          notNullOrEmptyMap(argument, new character(DEFAULT_ARGUMENT_NAME));
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
                @LegacyParameter(name = "argument", qualified = "openedge.core.collections.imap", type = "OBJECT", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrEmptyMap(
                final object<? extends com.goldencode.p2j.oo.core.collections.Imap> argument,
                final character name)
       {
          AssertObject.notNullOrEmptyMap(argument, name);
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
                @LegacyParameter(name = "argument", qualified = "progress.lang.object", type = "OBJECT", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrEmptyObject(final object<? extends _BaseObject_> argument)
       {
          notNullOrEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
                @LegacyParameter(name = "argument", qualified = "progress.lang.object", type = "OBJECT", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrEmptyObject(final object<? extends _BaseObject_> argument,
                final character name)
       {
          notNullOrEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "OBJECT", extent = -1, qualified = "progress.lang.object", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrEmptyObjectArray(final object<? extends _BaseObject_>[] argument)
       {
          notNullOrEmptyObjectArray(argument, new character(DEFAULT_ARGUMENT_NAME));
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "OBJECT", extent = -1, qualified = "progress.lang.object", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrEmptyObjectArray(final object<? extends _BaseObject_>[] argument,
                final character name)
       {
          call("NotNullOrEmpty", () -> {
             AssertObject.notNullOrEmptyObjectArray(argument, name);
          });
       }

       /**
        * Check that the numeric argument is neither unknown nor zero
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrZero", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrZero(final decimal argument)
       {
          notNullOrZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is neither unknown nor zero
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrZero", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrZero(final decimal argument, final character name)
       {
          notNullOrZeroImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is neither unknown nor zero
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrZero", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrZero(final int64 argument)
       {
          notNullOrZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is neither unknown nor zero
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrZero", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrZero(final int64 argument, final character name)
       {
          notNullOrZeroImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is neither unknown nor zero
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrZero", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrZero(final integer argument)
       {
          notNullOrZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is neither unknown nor zero
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotNullOrZero", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notNullOrZero(final integer argument, final character name)
       {
          notNullOrZeroImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the logical argument is not true (is false or unknown)
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotTrue", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notTrue(final logical argument)
       {
          notTrueImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the logical argument is not true (is false or unknown)
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotTrue", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notTrue(final logical argument, final character name)
       {
          notTrueImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final character argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final character argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final character[] argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final character[] argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATE", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final date argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATE", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final date argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATE", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final date[] argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATE", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final date[] argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIME", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final datetime argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIME", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final datetime argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIME", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final datetime[] argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIME", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final datetime[] argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIMETZ", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final datetimetz argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIMETZ", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final datetimetz argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIMETZ", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final datetimetz[] argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DATETIMETZ", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final datetimetz[] argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final decimal argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final decimal argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final decimal[] argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final decimal[] argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final handle argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final handle argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final handle[] argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "HANDLE", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final handle[] argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final int64 argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final int64 argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final int64[] argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final int64[] argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final integer argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final integer argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final integer[] argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final integer[] argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final logical argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final logical argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final logical[] argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "LOGICAL", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final logical[] argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final longchar argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final longchar argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final longchar[] argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final longchar[] argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "RAW", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final raw argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "RAW", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final raw argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "RAW", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final raw[] argument)
       {
          notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is not unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
                @LegacyParameter(name = "argument", type = "RAW", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknown(final raw[] argument, final character name)
       {
          notUnknownImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknownOrEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknownOrEmpty(final character argument)
       {
          notUnknownOrEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknownOrEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknownOrEmpty(final character argument, final character name)
       {
          notUnknownOrEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknownOrEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknownOrEmpty(final character[] argument)
       {
          notUnknownOrEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknownOrEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknownOrEmpty(final character[] argument, final character name)
       {
          notUnknownOrEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknownOrEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknownOrEmpty(final longchar argument)
       {
          notUnknownOrEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknownOrEmpty", parameters = {
                @LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknownOrEmpty(final longchar argument, final character name)
       {
          notUnknownOrEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknownOrEmpty", parameters = {
                @LegacyParameter(name = "argument", qualified = "progress.lang.object", type = "OBJECT", extent = -1, mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknownOrEmpty(final object<? extends _BaseObject_>[] argument,
                final character name)
       {
          notUnknownOrEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotUnknownOrEmpty", parameters = {
                @LegacyParameter(name = "argument", qualified = "progress.lang.object", type = "OBJECT", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notUnknownOrEmptyObject(final object<? extends _BaseObject_> argument,
                final character name)
       {
          notNullUnknownOrEmptyImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is not zero
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotZero", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notZero(final decimal argument)
       {
          notZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is not zero
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotZero", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notZero(final decimal argument, final character name)
       {
          notZeroImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is not zero
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotZero", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notZero(final int64 argument)
       {
          notZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is not zero
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotZero", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notZero(final int64 argument, final character name)
       {
          notZeroImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is not zero
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NotZero", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notZero(final integer argument)
       {
          notZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is not zero
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NotZero", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void notZero(final integer argument, final character name)
       {
          notZeroImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is not zero
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NonZero", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void nonZero(final decimal argument)
       {
          nonZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is not zero
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NonZero", parameters = {
                @LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void nonZero(final decimal argument, final character name)
       {
          nonZeroImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is not zero
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NonZero", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void nonZero(final int64 argument)
       {
          nonZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is not zero
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NonZero", parameters = {
                @LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void nonZero(final int64 argument, final character name)
       {
          nonZeroImpl(argument, name.toStringMessage());
       }

       /**
        * Check that the numeric argument is not zero
        *
        * @param argument
        *        The argument to check
        */
       @LegacySignature(type = Type.METHOD, name = "NonZero", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void nonZero(final integer argument)
       {
          nonZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
       }

       /**
        * Check that the numeric argument is not zero
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       @LegacySignature(type = Type.METHOD, name = "NonZero", parameters = {
                @LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void nonZero(final integer argument, final character name)
       {
          nonZeroImpl(argument, name.toStringMessage());
       }

       /**
        * Throw AssertionFailedError with the given message
        *
        * @param message The failure message
        */
       @LegacySignature(type = Type.METHOD, name = "RaiseError", parameters = {
                @LegacyParameter(name = "message", type = "CHARACTER", mode = "INPUT") })
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public static void raiseError(final character message)
       {
          raiseError(message.toStringMessage());
       }

       /**
        * Implementation helper for all test methods in this very class.
        *
        * @param legacyName
        *        the legacy name of the method
        * @param body
        *        the method body
        */
       private static void call(final String legacyName, final Body body)
       {
          call(Assert.class, legacyName, body);
       }

       /**
        * Check that the character argument can be parsed to a decimal value
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       private static void isDecimalImpl(final character argument, final String name)
       {
          call("IsDecimal", () -> {
             silent(() -> new decimal(argument.getValue()));
             if (ErrorManager.isError().booleanValue())
             {
                raiseError("&1 is not a decimal value", name);
             }
          });
       }

       /**
        * Check that a handle is empty (not available)
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       private static void isEmptyImpl(final handle argument, final String name)
       {
          call("IsEmpty", () -> {

             notNullImpl(argument, name);

             final handle _h = TypeFactory.initInput(argument);
             silent(() -> _h.unwrapBuffer().findFirst());

             notAvailableImpl(_h, name);
          });
       }

       /**
        * Check that the argument is empty (size is zero)
        *
        * @param argument
        *        the value to check
        * @param name
        *        the argument name to use in the failure message
        */
       private static void isEmptyImpl(final memptr argument, final String name)
       {
          call("IsEmpty", () -> {
             if (argument.length().intValue() != 0)
             {
                raiseError("&1 must be empty", name);
             }
          });
       }

       /**
        * Check that the argument is empty (contains no characters).
        *
        * @param argument
        *        the value to check
        * @param name
        *        the argument name to use in the failure message
        */
       private static void isEmptyImpl(final Text argument, final String name)
       {
          notNullImpl(argument, name);
          call("IsEmpty", () -> {
             if (!argument.getValue().isEmpty())
             {
                raiseError("&1 must be empty", name);
             }
          });
       }

       /**
        * Check that a character value is in the list
        *
        * @param argument
        *        The argument to check
        * @param list
        *        The list to look up
        * @param delimiter
        *        List delimiter
        * @param name
        *        The name of the argument
        */
       private static void isInImpl(final character argument, final longchar list,
                final character delimiter, final character name)
       {
          notEqualImpl(argument, delimiter);

          call("IsIn", () -> {
             // FIXME: test how OE handles unknown values
             // FIXME: use the OE LOOKUP function here
             if (!argument.isUnknown() && !list.isUnknown() && !delimiter.isUnknown())
             {
                final String val = StringHelper.safeTrimTrailingSpaces(argument.getValue());

                for (final String entry : TextOps.entries(list.getValue(), delimiter.getValue()))
                {
                   if (CompareOps._isEqual(val, StringHelper.safeTrimTrailingSpaces(entry)))
                   {
                      returnNormal();
                   }
                }
             }

             raiseError("&1 (\"&2\") is not in the list: &3", name, argument, list);
          });
       }

       /**
        * Check that the character argument can be parsed to an int64 value
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       private static void isInt64Impl(final character argument, final String name)
       {
          call("IsInt64", () -> {
             silent(() -> new int64(argument.getValue()));
             if (ErrorManager.isError().booleanValue())
             {
                raiseError("&1 is not an int64 value", name);
             }

          });
       }

       /**
        * Check that the character argument can be parsed to an integer value
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       private static void isIntegerImpl(final character argument, final String name)
       {
          call("IsInteger", () -> {
             silent(() -> new integer(argument.getValue()));
             if (ErrorManager.isError().booleanValue())
             {
                raiseError("&1 is not an integer value", name);
             }
          });
       }

       /**
        * Check that the character argument can be parsed to a logical value
        *
        * @param argument
        *        The argument to check
        * @param mask
        *        parse format, e.g. "yes/no", "da/net"
        * @param name
        *        The name of the argument
        */
       private static void isLogicalImpl(final character argument, final character mask,
                final String name)
       {
          call("IsLogical", () -> {
             if (!argument.isUnknown())
             {
                silent(() -> new logical(argument, mask));
                if (ErrorManager.isError().booleanValue())
                {
                   raiseError("&1 does not evaluate to a logical value with mask &2", name, mask);
                }
             }
          });
       }

       /**
        * Check that the character argument can be parsed to a logical value
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       private static void isLogicalImpl(final character argument, final String name)
       {
          call("IsLogical", () -> {
             if (!argument.isUnknown())
             {
                silent(() -> new logical(argument.getValue()));
                if (ErrorManager.isError().booleanValue())
                {
                   raiseError("&1 does not evaluate to a logical value", name);
                }
             }
          });
       }

       /**
        * Check that the numeric argument is strictly negative
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       private static void isNegativeImpl(final NumberType argument, final String name)
       {
          call("IsNegative", () -> {
             notNullImpl(argument, name);

             if (argument.doubleValue() >= 0)
             {
                raiseNonNegative(name);
             }

          });
       }

       /**
        * Check that the argument is unknown
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       private static void isNullImpl(final BaseDataType argument, final String name)
       {
          call("IsNull", () -> {
             if (!argument.isUnknown())
             {
                raiseNotUnknown(name);
             }

          });
       }

       /**
        * Check that the numeric argument is strictly positive
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       public static void isPositiveImpl(final NumberType argument, final String name)
       {
          notNullImpl(argument, name);

          call("IsPositive", () -> {

             if (argument.doubleValue() <= 0)
             {
                raiseNonPositive(name);
             }

          });
       }

       /**
        * Check that the numeric argument is zero
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       private static void isZeroImpl(final NumberType argument, final String name)
       {
          call("IsZero", () -> {
             if (argument.isUnknown() || argument.doubleValue() != 0)
             {
                raiseNonZero(name);
             }
          });
       }

       /**
        * Check that the numeric argument is zero or negative
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       private static void isZeroOrNegativeImpl(final NumberType argument, final String name)
       {
          call("IsZeroOrNegative", () -> {
             notNullImpl(argument, name);

             if (argument.doubleValue() > 0)
             {
                raiseNonZeroOrNegative(name);
             }
          });
       }

       /**
        * Check that the numeric argument is zero or positive
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       public static void isZeroOrPositiveImpl(final NumberType argument, final String name)
       {
          call("IsZeroOrPositive", () -> {
             notNullImpl(argument, name);

             if (argument.doubleValue() < 0)
             {
                raiseNonZeroOrPositive(name);
             }

          });
       }

       /**
        * Check that the buffer argument is not available
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       private static void notAvailableImpl(final handle argument, final String name)
       {
          call("NotAvailable", () -> {
             if (argument.unwrapAvailable().available().booleanValue())
             {
                raiseError("record in buffer &1 is available", name);
             }
          });
       }

       /**
        * Check that the argument is not empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       private static void notEmptyImpl(final BaseDataType[] argument, final String name)
       {
          // FIXME: why should not we test this for memptr?
          notUnknownImpl(argument, name);
          hasDeterminateExtentImpl(argument, name);
          for (int i = 0; i < argument.length; i++)
          {
             final BaseDataType e = argument[i];
             notEmptyImpl(e, substitute("Extent &2 of &1", name, i).toStringMessage());
          }
       }

       /**
        * Check that two arguments are not equal
        *
        * @param expected
        *        The expected value
        * @param actual
        *        The actual value
        */
       private static void notEqualImpl(final BaseDataType expected, final BaseDataType actual)
       {
          call("NotEqual", () -> {
             if (CompareOps._isEqual(expected, actual))
             {
                raiseErrorForEquals("&1 and &2 are equal", expected, actual);
             }
          });
       }

       /**
        * Check that the logical argument is not false (is true or unknown)
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       private static void notFalseImpl(final logical argument, final String name)
       {
          call("NotFalse", () -> {
             if (!argument.isUnknown() && !argument.booleanValue())
                raiseError("&1 is false", name);
          });
       }

       /**
        * Check that a character value is not in the list
        *
        * @param argument
        *        The argument to check
        * @param list
        *        The list to look up
        * @param delimiter
        *        List delimiter
        * @param name
        *        The name of the argument
        */
       private static void notInImpl(Text argument, longchar list, Text delimiter,
                final character name)
       {
          if (list.isUnknown() || StringHelper.safeTrimTrailingSpaces(list.getValue()).isEmpty())
          {
             returnNormal();
          }

          call("NotIn", () -> {
             notEqualImpl(argument, delimiter);

             if (argument.isUnknown() || delimiter.isUnknown())
             {
                raiseError("&1 (\"&2\") is in the list: &3", name, argument, list);
             }

             // FIXME use LOOKUP function
             final String val = StringHelper.safeTrimTrailingSpaces(argument.getValue());

             for (final String entry : TextOps.entries(list.getValue(), delimiter.getValue()))
             {
                if (CompareOps._isEqual(val, StringHelper.safeTrimTrailingSpaces(entry)))
                {
                   raiseError("&1 (\"&2\") is in the list: &3", name, argument, list);
                }
             }

          });
       }

       /**
        * Check that the argument is not unknown and valid
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       private static void notNullImpl(final handle argument, final String name)
       {
          call("NotNull", () -> {
             if (argument == null || argument.isUnknown() || !argument._isValid())
             {
                raiseUnknown(name);
             }
          });
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       public static void notNullOrEmptyImpl(final BaseDataType argument, final String name)
       {
          call("NotNullOrEmpty", () -> {
             notNullImpl(argument, name);
             notEmptyImpl(argument, name);
          });
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       private static void notNullOrEmptyImpl(final BaseDataType[] argument, final String name)
       {
          call("NotNullOrEmpty", () -> {
             if (argument.length == 0)
             {
                raiseUnknown(name);
             }
          });
       }

       /**
        * Check that the numeric argument is neither unknown nor zero
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       private static void notNullOrZeroImpl(final NumberType argument, final String name)
       {
          call("NotNullOrZero", () -> {
             notNullImpl(argument, name);
             notZeroImpl(argument, name);
          });
       }

       /**
        * Check that the logical argument is not true (is false or unknown)
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       private static void notTrueImpl(final logical argument, final String name)
       {
          call("NotTrue", () -> {
             if (argument.booleanValue())
             {
                raiseError("&1 is true", name);
             }
          });
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       private static void notUnknownOrEmptyImpl(final BaseDataType[] argument, String name)
       {
          notUnknownImpl(argument, name);
          notEmptyImpl(argument, name);
       }

       /**
        * Check that the argument is neither unknown nor empty
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       private static void notUnknownOrEmptyImpl(final Text argument, final String name)
       {
          notUnknownImpl(argument, name);
          notEmptyImpl(argument, name);
       }

       /**
        * Check that the numeric argument is not zero
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       private static void nonZeroImpl(final NumberType argument, final String name)
       {
          call("NonZero", () -> {
             if (!argument.isUnknown() && argument.doubleValue() == 0)
             {
                raiseZero(name);
             }

          });
       }

       /**
        * Check that the numeric argument is not zero
        *
        * @param argument
        *        The argument to check
        * @param name
        *        The name of the argument
        */
       private static void notZeroImpl(final NumberType argument, final String name)
       {
          call("NotZero", () -> {
             if (!argument.isUnknown() && argument.doubleValue() == 0)
             {
                raiseZero(name);
             }

          });
       }

       /**
        * Raise an ERROR condition as the value is not negative.
        *
        * @param name The name of the value.
        */
       private static void raiseNonNegative(final String name)
       {
          raiseError("&1 must be negative", name);
       }

       /**
        * Raise an ERROR condition as the value is not positive.
        *
        * @param name The name of the value.
        */
       private static void raiseNonPositive(final String name)
       {
          raiseError("&1 must be positive", name);
       }

       /**
        * Raise an ERROR condition as the value is not zero.
        *
        * @param name The name of the value.
        */
       private static void raiseNonZero(final String name)
       {
          raiseError("&1 must be zero", name);
       }

       /**
        * Raise an ERROR condition as the value is not zero or negative.
        *
        * @param name The name of the value.
        */
       private static void raiseNonZeroOrNegative(final String name)
       {
          raiseError("&1 must be zero or negative", name);
       }

       /**
        * Raise an ERROR condition as the value is not zero or positive.
        *
        * @param name The name of the value.
        */
       private static void raiseNonZeroOrPositive(final String name)
       {
          raiseError("&1 must be zero or positive", name);
       }

       /**
        * Raise an ERROR condition as the value is zero.
        *
        * @param name The name of the value.
        */
       private static void raiseZero(final String name)
       {
          raiseError("&1 cannot be zero", name);
       }

       /**
        * The "default" constructor.
        */
       @LegacySignature(type = Type.CONSTRUCTOR)
       @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
       public void __core_Assert_constructor__()
       {
          internalProcedure(this, "__core_Assert_constructor__", new Block((Body) () -> {
             __core_AbstractAssert_constructor__();
          }));
       }

       /**
        * Initialize this procedure
        */
       @LegacySignature(type = Type.EXECUTE)
       public void __core_Assert_execute__()
       {
          onBlockLevel(Condition.ERROR, Action.THROW);
       }

    }