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