# Assert.java

    /*
    ** Module   : Assert.java
    ** Abstract : Implementation of the OEUnit.Assertion.Assert class.
    **
    ** Copyright (c) 2023-2024, Golden Code Development Corporation.
    **
    ** -#- -I- --Date-- -------------------------------Description--------------------------------
    ** 001 VVT 20230307 Initial version
    ** 002 CA  20231113 The 'execute' method must be annotated with LegacySignature Type.Execute, and also can be
    **                  dropped if is a no-op.
    ** 003 CA  20240307 Added an 'areEqual' overload.
    */

    /*
    ** 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.oeunit.assertion;

    import com.goldencode.p2j.util.*;
    import com.goldencode.p2j.oo.lang.*;

    import static com.goldencode.p2j.report.ReportConstants.*;
    import static com.goldencode.p2j.util.BlockManager.*;
    import static com.goldencode.p2j.util.InternalEntry.Type;
    import static com.goldencode.p2j.util.CompareOps.*;
    import static com.goldencode.p2j.util.logical.*;
    import static com.goldencode.p2j.util.TextOps.*;
    import static com.goldencode.p2j.util.character.*;

    /**
     * OEUnit assertion library implementation.
     */
    @LegacyResource(resource = "OEUnit.Assertion.Assert")
    @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
    public class Assert
    extends BaseObject
    {
       /**
        * Static constructor
        */
       @LegacySignature(type = Type.CONSTRUCTOR)
       public static void __oeunit_assertion_Assert_constructor__static__()
       {
          externalProcedure(Assert.class, new Block((Body) () -> {
             onRoutineLevel(Condition.ERROR, Action.THROW);
          }));
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "CHARACTER", mode = "INPUT") })
       public static void areEqual(final character actual, final character expected)
       {
          areEqualImpl(actual, expected);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areEqual(final character actual,
                                   final character expected,
                                   final character failMessage)
       {
          areEqualImpl(actual, expected, failMessage);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "COMHANDLE", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "COMHANDLE", mode = "INPUT") })
       public static void areEqual(final comhandle actual, final comhandle expected)
       {
          areEqualImpl(actual, expected);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "COMHANDLE", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "COMHANDLE", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areEqual(final comhandle actual,
                                   final comhandle expected,
                                   final character failMessage)
       {
          areEqualImpl(actual, expected, failMessage);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "DATE", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "DATE", mode = "INPUT") })
       public static void areEqual(final date actual, final date expected)
       {
          areEqualImpl(actual, expected);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "DATE", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "DATE", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areEqual(final date actual,
                                   final date expected,
                                   final character failMessage)
       {
          areEqualImpl(actual, expected, failMessage);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "DATETIME", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "DATETIME", mode = "INPUT") })
       public static void areEqual(final datetime actual, final datetime expected)
       {
          areEqualImpl(actual, expected);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "DATETIME", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "DATETIME", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areEqual(final datetime actual,
                                   final datetime expected,
                                   final character failMessage)
       {
          areEqualImpl(actual, expected, failMessage);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "DATETIMETZ", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "DATETIMETZ", mode = "INPUT") })
       public static void areEqual(final datetimetz actual, final datetimetz expected)
       {
          areEqualImpl(actual, expected);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "DATETIMETZ", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "DATETIMETZ", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areEqual(final datetimetz actual,
                                   final datetimetz expected,
                                   final character failMessage)
       {
          areEqualImpl(actual, expected, failMessage);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "DECIMAL", mode = "INPUT") })
       public static void areEqual(final decimal actual, final decimal expected)
       {
          areEqualImpl(actual, expected);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areEqual(final decimal actual,
                                   final decimal expected,
                                   final character failMessage)
       {
          areEqualImpl(actual, expected, failMessage);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "HANDLE", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "HANDLE", mode = "INPUT") })
       public static void areEqual(final handle actual, final handle expected)
       {
          areEqualImpl(actual, expected);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "HANDLE", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "HANDLE", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areEqual(final handle actual,
                                   final handle expected,
                                   final character failMessage)
       {
          areEqualImpl(actual, expected, failMessage);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "INT64", mode = "INPUT") })
       public static void areEqual(final int64 actual, final int64 expected)
       {
          areEqualImpl(actual, expected);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areEqual(final int64 actual,
                                   final int64 expected,
                                   final character failMessage)
       {
          areEqualImpl(actual, expected, failMessage);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "INTEGER", mode = "INPUT") })
       public static void areEqual(final integer actual, final integer expected)
       {
          areEqualImpl(actual, expected);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areEqual(final integer actual,
                                   final integer expected,
                                   final character failMessage)
       {
          areEqualImpl(actual, expected, failMessage);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areEqual(final int actual,
                                   final integer expected,
                                   final character failMessage)
       {
          areEqualImpl(new integer(actual), expected, failMessage);
       }

       /**
        * @param actual
        * @param expected
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "LOGICAL", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "LOGICAL", mode = "INPUT") })
       public static void areEqual(final logical actual, final logical expected)
       {
          areEqualImpl(actual, expected);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "LOGICAL", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "LOGICAL", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areEqual(final logical actual,
                                   final logical expected,
                                   final character failMessage)
       {
          areEqualImpl(actual, expected, failMessage);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "LONGCHAR", mode = "INPUT") })
       public static void areEqual(final longchar actual, final longchar expected)
       {
          areEqualImpl(actual, expected);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areEqual(final longchar actual,
                                   final longchar expected,
                                   final character failMessage)
       {
          areEqualImpl(actual, expected, failMessage);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "MEMPTR", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "MEMPTR", mode = "INPUT") })
       public static void areEqual(final memptr actual, final memptr expected)
       {
          areEqual(actual, expected, new character());
       }

       /**
        * Assert a memptr value equals to the expected one.
        * <p>
        * Note: the implementation of this method in useless in original OEUnit
        * (it always raises error).
        * <p>
        * So, this implementation differs from that in original OEUnit, and is created
        * after that in ABLUnit
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "MEMPTR", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "MEMPTR", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areEqual(final memptr actual,
                                   final memptr expected,
                                   final character failMessage)
       {
          areEqualImpl(expected.length(), actual.length(), failMessage);

          call("Equals", () -> {
             if (!SecurityOps.messageDigest("SHA-256", expected)
                      .equals(SecurityOps.messageDigest("SHA-256", actual)))
             {
                failImpl(failMessage.isUnknown()
                         ? new character("Hashes of memptr values are not equal")
                         : failMessage);
             }
          });
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT") })
       public static void areEqual(
                final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> actual,
                final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> expected)
       {
          areEqualImpl(actual, expected);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areEqual(
                final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> actual,
                final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> expected,
                final character failMessage)
       {
          areEqualImpl(actual, expected, failMessage);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "RAW", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "RAW", mode = "INPUT") })
       public static void areEqual(final raw actual, final raw expected)
       {
          areEqualImpl(actual, expected);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "RAW", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "RAW", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areEqual(final raw actual, final raw expected, final character failMessage)
       {
          areEqualImpl(actual, expected, failMessage);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "RECID", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "RECID", mode = "INPUT") })
       public static void areEqual(final recid actual, final recid expected)
       {
          areEqualImpl(actual, expected);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "RECID", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "RECID", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areEqual(final recid actual,
                                   final recid expected,
                                   final character failMessage)
       {
          areEqualImpl(actual, expected, failMessage);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "ROWID", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "ROWID", mode = "INPUT") })
       public static void areEqual(final rowid actual, final rowid expected)
       {
          areEqualImpl(actual, expected);
       }

       /**
        * Assert a value equals to the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreEqual", parameters = {
                @LegacyParameter(name = "actual", type = "ROWID", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "ROWID", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areEqual(final rowid actual,
                                   final rowid expected,
                                   final character failMessage)
       {
          areEqualImpl(actual, expected, failMessage);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "CHARACTER", mode = "INPUT") })
       public static void areNotEqual(final character actual, final character notExpected)
       {
          areNotEqualImpl(actual, notExpected);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areNotEqual(final character actual,
                                      final character notExpected,
                                      final character failMessage)
       {
          areNotEqualImpl(actual, notExpected, failMessage);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "COMHANDLE", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "COMHANDLE", mode = "INPUT") })
       public static void areNotEqual(final comhandle actual, final comhandle notExpected)
       {
          areNotEqualImpl(actual, notExpected);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "COMHANDLE", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "COMHANDLE", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areNotEqual(final comhandle actual,
                                      final comhandle notExpected,
                                      final character failMessage)
       {
          areNotEqualImpl(actual, notExpected, failMessage);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "DATE", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "DATE", mode = "INPUT") })
       public static void areNotEqual(final date actual, final date notExpected)
       {
          areNotEqualImpl(actual, notExpected);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "DATE", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "DATE", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areNotEqual(final date actual,
                                      final date notExpected,
                                      final character failMessage)
       {
          areNotEqualImpl(actual, notExpected, failMessage);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "DATETIME", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "DATETIME", mode = "INPUT") })
       public static void areNotEqual(final datetime actual, final datetime notExpected)
       {
          areNotEqualImpl(actual, notExpected);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "DATETIME", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "DATETIME", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areNotEqual(final datetime actual,
                                      final datetime notExpected,
                                      final character failMessage)
       {
          areNotEqualImpl(actual, notExpected, failMessage);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "DATETIMETZ", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "DATETIMETZ", mode = "INPUT") })
       public static void areNotEqual(final datetimetz actual, final datetimetz notExpected)
       {
          areNotEqualImpl(actual, notExpected);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "DATETIMETZ", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "DATETIMETZ", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areNotEqual(final datetimetz actual,
                                      final datetimetz notExpected,
                                      final character failMessage)
       {
          areNotEqualImpl(actual, notExpected, failMessage);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "DECIMAL", mode = "INPUT") })
       public static void areNotEqual(final decimal actual, final decimal notExpected)
       {
          areNotEqualImpl(actual, notExpected);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areNotEqual(final decimal actual,
                                      final decimal notExpected,
                                      final character failMessage)
       {
          areNotEqualImpl(actual, notExpected, failMessage);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "HANDLE", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "HANDLE", mode = "INPUT") })
       public static void areNotEqual(final handle actual, final handle notExpected)
       {
          areNotEqualImpl(actual, notExpected);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "HANDLE", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "HANDLE", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areNotEqual(final handle actual,
                                      final handle notExpected,
                                      final character failMessage)
       {
          areNotEqualImpl(actual, notExpected, failMessage);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "INT64", mode = "INPUT") })
       public static void areNotEqual(final int64 actual, final int64 notExpected)
       {
          areNotEqualImpl(actual, notExpected);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areNotEqual(final int64 actual,
                                      final int64 notExpected,
                                      final character failMessage)
       {
          areNotEqualImpl(actual, notExpected, failMessage);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "INTEGER", mode = "INPUT") })
       public static void areNotEqual(final integer actual, final integer notExpected)
       {
          areNotEqualImpl(actual, notExpected);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areNotEqual(final integer actual,
                                      final integer notExpected,
                                      final character failMessage)
       {
          areNotEqualImpl(actual, notExpected, failMessage);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "LOGICAL", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "LOGICAL", mode = "INPUT") })
       public static void areNotEqual(final logical actual, final logical notExpected)
       {
          areNotEqualImpl(actual, notExpected);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "LOGICAL", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "LOGICAL", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areNotEqual(final logical actual,
                                      final logical notExpected,
                                      final character failMessage)
       {
          areNotEqualImpl(actual, notExpected, failMessage);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "LONGCHAR", mode = "INPUT") })
       public static void areNotEqual(final longchar actual, final longchar notExpected)
       {
          areNotEqualImpl(actual, notExpected);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areNotEqual(final longchar actual,
                                      final longchar notExpected,
                                      final character failMessage)
       {
          areNotEqualImpl(actual, notExpected, failMessage);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "MEMPTR", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "MEMPTR", mode = "INPUT") })
       public static void areNotEqual(final memptr actual, final memptr notExpected)
       {
          areNotEqualImpl(actual, notExpected);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "MEMPTR", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "MEMPTR", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areNotEqual(final memptr actual,
                                      final memptr notExpected,
                                      final character failMessage)
       {
          areNotEqualImpl(actual, notExpected, failMessage);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT") })
       public static void areNotEqual(
                final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> actual,
                final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> notExpected)
       {
          areNotEqualImpl(actual, notExpected);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areNotEqual(
                final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> actual,
                final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> notExpected,
                final character failMessage)
       {
          areNotEqualImpl(actual, notExpected, failMessage);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "RAW", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "RAW", mode = "INPUT") })
       public static void areNotEqual(final raw actual, final raw notExpected)
       {
          areNotEqualImpl(actual, notExpected);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "RAW", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "RAW", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areNotEqual(final raw actual,
                                      final raw notExpected,
                                      final character failMessage)
       {
          areNotEqualImpl(actual, notExpected, failMessage);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "RECID", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "RECID", mode = "INPUT") })
       public static void areNotEqual(final recid actual, final recid notExpected)
       {
          areNotEqualImpl(actual, notExpected);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "RECID", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "RECID", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areNotEqual(final recid actual,
                                      final recid notExpected,
                                      final character failMessage)
       {
          areNotEqualImpl(actual, notExpected, failMessage);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "ROWID", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "ROWID", mode = "INPUT") })
       public static void areNotEqual(final rowid actual, final rowid notExpected)
       {
          areNotEqualImpl(actual, notExpected);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotEqual", parameters = {
                @LegacyParameter(name = "actual", type = "ROWID", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "ROWID", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areNotEqual(final rowid actual,
                                      final rowid notExpected,
                                      final character failMessage)
       {
          areNotEqualImpl(actual, notExpected, failMessage);
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotSame", parameters = {
                @LegacyParameter(name = "actual", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT") })
       public static void areNotSame(
                final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> actual,
                final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> notExpected)
       {
          areNotSameImpl(actual, notExpected, new character());
       }

       /**
        * Assert a value is <b>not</b> equal to another one.
        *
        * @param actual
        *        the actual value
        * @param notExpected
        *        the unexpected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreNotSame", parameters = {
                @LegacyParameter(name = "actual", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT"),
                @LegacyParameter(name = "notExpected", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areNotSame(
                final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> actual,
                final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> notExpected,
                final character failMessage)
       {
          areNotSameImpl(actual, notExpected, failMessage);
       }

       /**
        * Assert a value is the same as the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        */
       @LegacySignature(type = Type.METHOD, name = "AreSame", parameters = {
                @LegacyParameter(name = "actual", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT") })
       public static void areSame(
                final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> actual,
                final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> expected)
       {
          areSameImpl(actual, expected, new character());
       }

       /**
        * Assert a value is the same as the expected one.
        *
        * @param actual
        *        the actual value
        * @param expected
        *        the expected value
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "AreSame", parameters = {
                @LegacyParameter(name = "actual", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT"),
                @LegacyParameter(name = "expected", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void areSame(
                final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> actual,
                final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> expected,
                final character failMessage)
       {
          areSameImpl(actual, expected, failMessage);
       }

       /**
        * Throw {@link AssertionFailedError} with default failure message.
        */
       @LegacySignature(type = Type.METHOD, name = "Fail")

       public static void fail()
       {
          fail(new character());
       }

       /**
        * Throw {@link AssertionFailedError} with the given failure message.
        *
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "Fail", parameters = {
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void fail(final character failMessage)
       {
          call("Fail", () -> {
             failImpl(_isUnknown(failMessage)
                      ? new character("Fail() method of Assert class was called")
                      : failMessage);
          });
       }

       /**
        * Assert a value is false.
        *
        * @param value
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsFalse", parameters = {
                @LegacyParameter(name = "value", type = "LOGICAL", mode = "INPUT") })
       public static void isFalse(final logical value)
       {
          isFalse(value, new character());
       }

       /**
        * Assert a value is false.
        *
        * @param value
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsFalse", parameters = {
                @LegacyParameter(name = "value", type = "LOGICAL", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isFalse(final logical value, final character failMessage)
       {
          call("IsFalse", () -> {
             assertImpl(not(value), value,
                      failMessage.isUnknown() ? substitute("Expecting: no but found: &1", value)
                               : failMessage);
          });
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "CHARACTER", mode = "INPUT") })
       public static void isNotNull(final character val)
       {
          isNotNullImpl(val);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNotNull(final character val, final character failMessage)
       {
          isNotNullImpl(val, failMessage);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "COMHANDLE", mode = "INPUT") })
       public static void isNotNull(final comhandle val)
       {
          isNotNullImpl(val);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "COMHANDLE", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNotNull(final comhandle val, final character failMessage)
       {
          isNotNullImpl(val, failMessage);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "DATE", mode = "INPUT") })
       public static void isNotNull(final date val)
       {
          isNotNullImpl(val);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "DATE", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNotNull(final date val, final character failMessage)
       {
          isNotNullImpl(val, failMessage);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "DATETIME", mode = "INPUT") })
       public static void isNotNull(final datetime val)
       {
          isNotNullImpl(val);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "DATETIME", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNotNull(final datetime val, final character failMessage)
       {
          isNotNullImpl(val, failMessage);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "DATETIMETZ", mode = "INPUT") })
       public static void isNotNull(final datetimetz val)
       {
          isNotNullImpl(val);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "DATETIMETZ", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNotNull(final datetimetz val, final character failMessage)
       {
          isNotNullImpl(val, failMessage);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "DECIMAL", mode = "INPUT") })
       public static void isNotNull(final decimal val)
       {
          isNotNullImpl(val);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNotNull(final decimal val, final character failMessage)
       {
          isNotNullImpl(val, failMessage);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "HANDLE", mode = "INPUT") })
       public static void isNotNull(final handle val)
       {
          isNotNullImpl(val);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "HANDLE", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNotNull(final handle val, final character failMessage)
       {
          isNotNullImpl(val, failMessage);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "INT64", mode = "INPUT") })
       public static void isNotNull(final int64 val)
       {
          isNotNullImpl(val);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNotNull(final int64 val, final character failMessage)
       {
          isNotNullImpl(val, failMessage);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "INTEGER", mode = "INPUT") })
       public static void isNotNull(final integer val)
       {
          isNotNullImpl(val);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNotNull(final integer val, final character failMessage)
       {
          isNotNullImpl(val, failMessage);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "LOGICAL", mode = "INPUT") })
       public static void isNotNull(final logical val)
       {
          isNotNullImpl(val);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "LOGICAL", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNotNull(final logical val, final character failMessage)
       {
          isNotNullImpl(val, failMessage);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "LONGCHAR", mode = "INPUT") })
       public static void isNotNull(final longchar val)
       {
          isNotNullImpl(val);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNotNull(final longchar val, final character failMessage)
       {
          isNotNullImpl(val, failMessage);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "MEMPTR", mode = "INPUT") })
       public static void isNotNull(final memptr val)
       {
          isNotNullImpl(val);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "MEMPTR", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNotNull(final memptr val, final character failMessage)
       {
          isNotNullImpl(val, failMessage);
       }

       /**
        * @param obj
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "obj", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT") })
       public static void isNotNull(
                final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> obj)
       {
          isNotNullImpl(obj, new character());
       }

       /**
        * @param obj
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "obj", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNotNull(
                final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> obj,
                final character failMessage)
       {
          isNotNullImpl(obj, failMessage);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "RAW", mode = "INPUT") })
       public static void isNotNull(final raw val)
       {
          isNotNullImpl(val);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "RAW", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNotNull(final raw val, final character failMessage)
       {
          isNotNullImpl(val, failMessage);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "RECID", mode = "INPUT") })
       public static void isNotNull(final recid val)
       {
          isNotNullImpl(val);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "RECID", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNotNull(final recid val, final character failMessage)
       {
          isNotNullImpl(val, failMessage);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "ROWID", mode = "INPUT") })
       public static void isNotNull(final rowid val)
       {
          isNotNullImpl(val);
       }

       /**
        * Assert a value is not unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNotNull", parameters = {
                @LegacyParameter(name = "val", type = "ROWID", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNotNull(final rowid val, final character failMessage)
       {
          isNotNullImpl(val, failMessage);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "CHARACTER", mode = "INPUT") })
       public static void isNull(final character val)
       {
          isNullImpl(val);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "CHARACTER", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNull(final character val, final character failMessage)
       {
          isNullImpl(val, failMessage);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "COMHANDLE", mode = "INPUT") })
       public static void isNull(final comhandle val)
       {
          isNullImpl(val);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "COMHANDLE", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNull(final comhandle val, final character failMessage)
       {
          isNullImpl(val, failMessage);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "DATE", mode = "INPUT") })
       public static void isNull(final date val)
       {
          isNullImpl(val);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "DATE", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNull(final date val, final character failMessage)
       {
          isNullImpl(val, failMessage);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "DATETIME", mode = "INPUT") })
       public static void isNull(final datetime val)
       {
          isNullImpl(val);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "DATETIME", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNull(final datetime val, final character failMessage)
       {
          isNullImpl(val, failMessage);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "DATETIMETZ", mode = "INPUT") })
       public static void isNull(final datetimetz val)
       {
          isNullImpl(val);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "DATETIMETZ", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNull(final datetimetz val, final character failMessage)
       {
          isNullImpl(val, failMessage);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "DECIMAL", mode = "INPUT") })
       public static void isNull(final decimal val)
       {
          isNullImpl(val);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "DECIMAL", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNull(final decimal val, final character failMessage)
       {
          isNullImpl(val, failMessage);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "HANDLE", mode = "INPUT") })
       public static void isNull(final handle val)
       {
          isNullImpl(val);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "HANDLE", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNull(final handle val, final character failMessage)
       {
          isNullImpl(val, failMessage);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "INT64", mode = "INPUT") })
       public static void isNull(final int64 val)
       {
          isNullImpl(val);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "INT64", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNull(final int64 val, final character failMessage)
       {
          isNullImpl(val, failMessage);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "INTEGER", mode = "INPUT") })
       public static void isNull(final integer val)
       {
          isNullImpl(val);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "INTEGER", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNull(final integer val, final character failMessage)
       {
          isNullImpl(val, failMessage);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "LOGICAL", mode = "INPUT") })
       public static void isNull(final logical val)
       {
          isNullImpl(val);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "LOGICAL", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNull(final logical val, final character failMessage)
       {
          isNullImpl(val, failMessage);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "LONGCHAR", mode = "INPUT") })
       public static void isNull(final longchar val)
       {
          isNullImpl(val);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "LONGCHAR", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNull(final longchar val, final character failMessage)
       {
          isNullImpl(val, failMessage);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "MEMPTR", mode = "INPUT") })
       public static void isNull(final memptr val)
       {
          isNullImpl(val);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "MEMPTR", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNull(final memptr val, final character failMessage)
       {
          isNullImpl(val, failMessage);
       }

       /**
        * @param obj
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "obj", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT") })
       public static void isNull(final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> obj)
       {
          isNullImpl(obj);
       }

       /**
        * @param obj
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "obj", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNull(final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> obj,
                                 final character failMessage)
       {
          isNullImpl(obj, failMessage);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "RAW", mode = "INPUT") })
       public static void isNull(final raw val)
       {
          isNullImpl(val);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "RAW", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNull(final raw val, final character failMessage)
       {
          isNullImpl(val, failMessage);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "RECID", mode = "INPUT") })
       public static void isNull(final recid val)
       {
          isNullImpl(val);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "RECID", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNull(final recid val, final character failMessage)
       {
          isNullImpl(val, failMessage);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "ROWID", mode = "INPUT") })
       public static void isNull(final rowid val)
       {
          isNullImpl(val);
       }

       /**
        * Assert a value is unknown.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
                @LegacyParameter(name = "val", type = "ROWID", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isNull(final rowid val, final character failMessage)
       {
          isNullImpl(val, failMessage);
       }

       /**
        * Assert a value is TRUE.
        *
        * @param value
        *        the value to test
        */
       @LegacySignature(type = Type.METHOD, name = "IsTrue", parameters = {
                @LegacyParameter(name = "value", type = "LOGICAL", mode = "INPUT") })
       public static void isTrue(final logical value)
       {
          isTrue(value, new character());
       }

       /**
        * Assert a value is TRUE.
        *
        * @param value
        *        the value to test
        * @param failMessage
        *        the failure message
        */
       @LegacySignature(type = Type.METHOD, name = "IsTrue", parameters = {
                @LegacyParameter(name = "value", type = "LOGICAL", mode = "INPUT"),
                @LegacyParameter(name = "failMessage", type = "CHARACTER", mode = "INPUT") })
       public static void isTrue(final logical value, final character failMessage)
       {
          call("IsTrue", () -> {
             assertEqualImpl(value, new logical(true), value, true, failMessage);
          });
       }

       /**
        * Assert two values are equal.
        *
        * @param actual
        *        the first value to compare
        * @param expected
        *        the second value to compare
        */
       private static void areEqualImpl(final BaseDataType actual, final BaseDataType expected)
       {
          areEqualImpl(actual, expected, new character());
       }

       /**
        * Assert two values are equal.
        *
        * @param actual
        *        the first value to compare
        * @param expected
        *        the second value to compare
        * @param failMessage
        *        the failure message, may be unknown
        */
       private static void areEqualImpl(final BaseDataType actual,
                                        final BaseDataType expected,
                                        final character failMessage)
       {
          call("AreEqual", () -> {
             assertEqualImpl(isEqual(expected, actual), expected, actual, true, failMessage);
          });
       }

       /**
        * Assert two values are not equal, calculate the failure message.
        *
        * @param actual
        *        the first value to compare
        * @param notExpected
        *        the second value to compare
        */
       private static void areNotEqualImpl(final BaseDataType actual, final BaseDataType notExpected)
       {
          areNotEqualImpl(actual, notExpected, new character());
       }

       /**
        * Assert two values are not equal.
        *
        * @param actual
        *        the first value to compare
        * @param notExpected
        *        the second value to compare
        * @param failMessage
        *        the failure message, if unknown, the value will be calculated
        */
       static void areNotEqualImpl(final BaseDataType actual,
                                   final BaseDataType notExpected,
                                   final character failMessage)
       {
          call("AreNotEqual", () -> {
             assertEqualImpl(isNotEqual(notExpected, actual), notExpected, actual, false,
                      failMessage);
          });
       }

       /**
        * Assert two objects are not same.
        *
        * @param actual
        *        the first value to compare
        * @param notExpected
        *        the second value to compare
        * @param failMessage
        *        the failure message, if unknown, the value will be calculated
        */
       private static void areNotSameImpl(final BaseDataType actual,
                                          final BaseDataType notExpected,
                                          final character failMessage)
       {
          call("AreNotSame", () -> {
             assertEqualImpl(isNotEqual(notExpected, actual), notExpected, actual, false,
                      failMessage);
          });
       }

       /**
        * Assert two objects are same.
        *
        * @param actual
        *        the first value to compare
        * @param expected
        *        the second value to compare
        * @param failMessage
        *        the failure message, if unknown, the value will be calculated
        */
       private static void areSameImpl(final BaseDataType actual,
                                       final BaseDataType expected,
                                       final character failMessage)
       {
          call("AreSame", () -> {
             assertEqualImpl(isEqual(expected, actual), expected, actual, true, failMessage);
          });
       }

       /**
        * The assert equal/notEqual implementation.
        *
        * @param success
        *        the assertion test result
        * @param expected
        *        the expected value
        * @param actual
        *        the actual value
        * @param expectedEqual
        *        are the two values expected to be equal
        * @param failMessage
        *        the failure message, if unknown, the message will be calculated
        */
       private static void assertEqualImpl(final logical success,
                                           final BaseDataType expected,
                                           final BaseDataType actual,
                                           final boolean expectedEqual,
                                           final character failMessage)
       {
          if (success.booleanValue())
          {
             return;
          }

          final character expectedFixed = replaceNull(quoteCharacter(expected));
          final character actualFixed = replaceNull(quoteCharacter(actual));
          final character effMessage = _isUnknown(failMessage)
                   ? expectedEqual ? concat("Expecting: ", expectedFixed, " but found: ", actualFixed)
                            : concat("Not expecting: ", expectedFixed, " but found: ", actualFixed)
                   : failMessage;
          returnError(ObjectOps.newInstance(AssertionFailedError.class, "III", effMessage, expected,
                   actual));
       }

       /**
        * Generic assert implementation.
        * <p>
        * The failure message, if missing, is calculated as
        * "Expecting: [type] but found: [value]"
        * <p>
        * where:
        * <p>
        * [type] is the parameter Progress type, like CHARACTER
        * [value] is the value being tested
        *
        * @param success
        *        the assertion test result, used to calculate the failure message if needed
        * @param value
        *        the value tested, used to calculate the failure message if needed
        * @param failMessage
        *        the failure message, if unknown, the message will be generated
        */
       private static void assertImpl(final logical success,
                                      final BaseDataType value,
                                      final character failMessage)
       {
          if (success.booleanValue())
          {
             return;
          }

          failImpl(failMessage.isUnknown()
                   ? substitute("Expecting: &1 but found: &2", getTypeName(value), value)
                   : failMessage);
       }

       /**
        * Convenience method to execute Java code as a legacy method.
        *
        * @param clazz
        *        the legacy class the method belongs to
        * @param legacyName
        *        legacy method name
        * @param body
        *        method body to execute
        */
       private final static void call(final Class<? extends _BaseObject_> clazz,
                                      final String legacyName,
                                      final Body body)
       {
          ObjectOps.load(clazz);
          internalProcedure(clazz, legacyName, new Block(body));
       }

       /**
        * 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);
       }

       /**
        * Throw {@link AssertionFailedError} with the given failure message.
        *
        * @param failMessage
        *        the failure message
        */
       private static void failImpl(final character failMessage)
       {
          returnError(ObjectOps.newInstance(AssertionFailedError.class, "I", failMessage));
       }

       /**
        * Get value type name to use in error reporting
        *
        * @param  value
        *         the values
        *
        * @return the 4gl type name
        */
       private final static String getTypeName(final BaseDataType value)
       {
          // Note: default method would return "DATETIMETZ" instead :-(
          return value instanceof datetimetz ? "DATETIME-TZ" : value.getType().name();
       }

       /**
        * IsNotNull implementation for all types.
        *
        * @param val
        *        the value to test
        */
       private static void isNotNullImpl(final BaseDataType val)
       {
          isNotNullImpl(val, new character());
       }

       /**
        * IsNotNull implementation for all types.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message, if unknown, the value type is used instead
        */
       static void isNotNullImpl(final BaseDataType val, final character failMessage)
       {
          call("IsNotNull", () -> {
             assertImpl(notUnknown(val), val, failMessage);
          });
       }

       /**
        * IsNull implementation for all types.
        *
        * @param val
        *        the value to test
        */
       private static void isNullImpl(final BaseDataType val)
       {
          isNullImpl(val, new character());
       }

       /**
        * IsNull implementation for all types.
        *
        * @param val
        *        the value to test
        * @param failMessage
        *        the failure message, if unknown, the value type is used instead
        */
       private static void isNullImpl(final BaseDataType val, final character failMessage)
       {
          call("IsNull", () -> {
             assertImpl(isUnknown(val), val,
                      failMessage.isUnknown()
                               ? substitute("Expecting: ? but found: &1", quoteCharacter(val))
                               : failMessage);
          });
       }

       /**
        * Format value to a printed form.
        *
        * @param  v
        *         the value to format
        *
        * @return the value converted to a string, surrounded by single quotes if necessary
        */
       private final static character quoteCharacter(final BaseDataType v)
       {
          final character stringValue = valueOf(v);
          return v instanceof Text ? concat("'", stringValue, "'") : stringValue;
       }

       /**
        * If the argument is unknown, return the "?" string, otherwise return the argument.
        *
        * @param  str
        *         the input string
        *
        * @return see above
        */
       private static character replaceNull(final character str)
       {
          return str.isUnknown() ? new character("?") : str;
       }

       /**
        * Constructor
        */
       @LegacySignature(type = Type.CONSTRUCTOR)
       public void __oeunit_assertion_assert__constructor__()
       {
          internalProcedure(this, "__oeunit_assertion_assert__constructor__", new Block((Body) () -> {
             __lang_BaseObject_constructor__();
          }));
       }

       /**
        * The "execute" method
        */
       @LegacySignature(type = Type.EXECUTE)
       public void __oeunit_assertion_Assert_execute__()
       {
          onRoutineLevel(Condition.ERROR, Action.THROW);
       }
    }