Macros.py

Go to the documentation of this file.

#
# Copyright 2009, MeVis Medical Solutions AG
#
# The user may use this file in accordance with the license agreement provided with
# the Software or, alternatively, in accordance with the terms contained in a
# written agreement between the user and MeVis Medical Solutions AG.
#
# For further information use the contact form at https://www.mevislab.de/contact
#
 
 
 
# -- system imports ----------------------------------------------------------------------------{{{-
# ----------------------------------------------------------------------------------------------}}}-
 
# -- local imports -----------------------------------------------------------------------------{{{-
import os
 
import sys
 
from TestSupport.TestHelper import TestHelper, UseStackFrameFromCallerForLogging, CancelTestException
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- class AssertException ---------------------------------------------------------------------{{{-
# @cond
 
class AssertException(Exception):
    # -- def __init__ ----------------------------------------------------------------------------{{{-
    def __init__(self, reason):
        self.__reason = reason
 
    # --------------------------------------------------------------------------------------------}}}-
 
    # -- def getReason ---------------------------------------------------------------------------{{{-
    def getReason(self):
        return repr(self.__reason)
 
    # --------------------------------------------------------------------------------------------}}}-
 
    # -- def __str__ -----------------------------------------------------------------------------{{{-
    def __str__(self):
        return repr(self.__reason)
 
    # --------------------------------------------------------------------------------------------}}}-
 
 
# @endcond
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def ASSERT_TRUE ---------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ASSERT_TRUE(expr, msg=None, logOnSuccess=None):
    if not Base_verifyTrue(expr, comment=msg, logOnSuccess=logOnSuccess):
        raise AssertException("Expression does not evaluate to true.")
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def EXPECT_TRUE ---------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def EXPECT_TRUE(expr, msg=None, logOnSuccess=None):
    return Base_verifyTrue(expr, comment=msg, logOnSuccess=logOnSuccess)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def ASSERT_FALSE --------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ASSERT_FALSE(expr, msg=None, logOnSuccess=None):
    if not Base_verifyFalse(expr, comment=msg, logOnSuccess=logOnSuccess):
        raise AssertException("Expression does not evaluate to false.")
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def EXPECT_FALSE --------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def EXPECT_FALSE(expr, msg=None, logOnSuccess=None):
    return Base_verifyFalse(expr, comment=msg, logOnSuccess=logOnSuccess)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def ASSERT_EQ -----------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ASSERT_EQ(expected, actual, msg=None, logOnSuccess=None):
    if not Base_compareEqual(expected, actual, comment=msg, logOnSuccess=logOnSuccess):
        raise AssertException("Values (%s and %s) are not equal." % (str(expected), str(actual)))
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def EXPECT_EQ -----------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def EXPECT_EQ(expected, actual, msg=None, logOnSuccess=None):
    return Base_compareEqual(expected, actual, comment=msg, logOnSuccess=logOnSuccess)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def ASSERT_NE -----------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ASSERT_NE(expected, actual, msg=None, logOnSuccess=None):
    if not Base_compareNotEqual(expected, actual, comment=msg, logOnSuccess=logOnSuccess):
        raise AssertException("Values (%s and %s) are equal." % (str(expected), str(actual)))
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def EXPECT_NE -----------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def EXPECT_NE(expected, actual, msg=None, logOnSuccess=None):
    return Base_compareNotEqual(expected, actual, comment=msg, logOnSuccess=logOnSuccess)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def ASSERT_GT -----------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ASSERT_GT(a, b, msg=None, logOnSuccess=None):
    if not Base_compareGreaterThan(a, b, comment=msg, logOnSuccess=logOnSuccess):
        raise AssertException("Value %s not greater than %s." % (str(a), str(b)))
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def EXPECT_GT -----------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def EXPECT_GT(a, b, msg=None, logOnSuccess=None):
    return Base_compareGreaterThan(a, b, comment=msg, logOnSuccess=logOnSuccess)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def ASSERT_GE -----------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ASSERT_GE(a, b, msg=None, logOnSuccess=None):
    if not Base_compareGreaterThanOrEqual(a, b, comment=msg, logOnSuccess=logOnSuccess):
        raise AssertException("Value %s not greater than or equal to %s." % (str(a), str(b)))
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def EXPECT_GE -----------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def EXPECT_GE(a, b, msg=None, logOnSuccess=None):
    return Base_compareGreaterThanOrEqual(a, b, comment=msg, logOnSuccess=logOnSuccess)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def ASSERT_LT -----------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ASSERT_LT(a, b, msg=None, logOnSuccess=None):
    if not Base_compareLessThan(a, b, comment=msg, logOnSuccess=logOnSuccess):
        raise AssertException("Value %s not less than %s." % (str(a), str(b)))
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def EXPECT_LT -----------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def EXPECT_LT(a, b, msg=None, logOnSuccess=None):
    return Base_compareLessThan(a, b, comment=msg, logOnSuccess=logOnSuccess)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def ASSERT_LE -----------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ASSERT_LE(a, b, msg=None, logOnSuccess=None):
    if not Base_compareLessThanOrEqual(a, b, comment=msg, logOnSuccess=logOnSuccess):
        raise AssertException("Value %s not less than or equal to %s." % (str(a), str(b)))
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def EXPECT_LE -----------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def EXPECT_LE(a, b, msg=None, logOnSuccess=None):
    return Base_compareLessThanOrEqual(a, b, comment=msg, logOnSuccess=logOnSuccess)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def ASSERT_FLOAT_EQ -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ASSERT_FLOAT_EQ(expected, actual, msg=None, epsilon=0.0001, logOnSuccess=None):
    if not Base_compareFloatEqual(expected, actual, msg, epsilon, logOnSuccess):
        raise AssertException("Values (%s and %s) not equal." % (str(expected), str(actual)))
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def EXPECT_FLOAT_EQ -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def EXPECT_FLOAT_EQ(expected, actual, msg=None, epsilon=0.0001, logOnSuccess=None):
    return Base_compareFloatEqual(expected, actual, msg, epsilon, logOnSuccess)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def ASSERT_FLOAT_NE -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ASSERT_FLOAT_NE(expected, actual, msg=None, epsilon=0.0001, logOnSuccess=None):
    if not Base_compareFloatNotEqual(expected, actual, msg, epsilon, logOnSuccess):
        raise AssertException("Values (%s and %s) equal." % (str(expected), str(actual)))
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def EXPECT_FLOAT_NE -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def EXPECT_FLOAT_NE(expected, actual, msg=None, epsilon=0.0001, logOnSuccess=None):
    return Base_compareFloatNotEqual(expected, actual, msg, epsilon, logOnSuccess)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def ASSERT_FLOAT_GT -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ASSERT_FLOAT_GT(a, b, msg=None, logOnSuccess=None):
    if not Base_compareFloatGreaterThan(a, b, comment=msg, logOnSuccess=logOnSuccess):
        raise AssertException("Value %s not greater than %s." % (str(a), str(b)))
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def EXPECT_FLOAT_GT -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def EXPECT_FLOAT_GT(a, b, msg=None, logOnSuccess=None):
    return Base_compareFloatGreaterThan(a, b, comment=msg, logOnSuccess=logOnSuccess)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def ASSERT_FLOAT_GE -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ASSERT_FLOAT_GE(a, b, msg=None, epsilon=0.0001, logOnSuccess=None):
    if not Base_compareFloatLessThanOrEqual(b, a, msg, epsilon, logOnSuccess):
        raise AssertException("Value %s not greater than or equal to %s." % (str(a), str(b)))
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def EXPECT_FLOAT_GE -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def EXPECT_FLOAT_GE(a, b, msg=None, epsilon=0.0001, logOnSuccess=None):
    return Base_compareFloatLessThanOrEqual(b, a, msg, epsilon, logOnSuccess)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def ASSERT_FLOAT_LT -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ASSERT_FLOAT_LT(a, b, msg=None, logOnSuccess=None):
    if not Base_compareFloatLessThan(a, b, comment=msg, logOnSuccess=logOnSuccess):
        raise AssertException("Value %s not less than %s." % (str(a), str(b)))
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def EXPECT_FLOAT_LT -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def EXPECT_FLOAT_LT(a, b, msg=None, logOnSuccess=None):
    return Base_compareFloatLessThan(a, b, comment=msg, logOnSuccess=logOnSuccess)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def ASSERT_FLOAT_LE -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ASSERT_FLOAT_LE(a, b, msg=None, epsilon=0.0001, logOnSuccess=None):
    if not Base_compareFloatLessThanOrEqual(a, b, msg, epsilon, logOnSuccess):
        raise AssertException("Value %s not less than or equal to %s." % (str(a), str(b)))
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def EXPECT_FLOAT_LE -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def EXPECT_FLOAT_LE(a, b, msg=None, epsilon=0.0001, logOnSuccess=None):
    return Base_compareFloatLessThanOrEqual(a, b, msg, epsilon, logOnSuccess)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def EXPECT_EMPTY -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def EXPECT_EMPTY(a, msg=None, logOnSuccess=None):
    return Base_compareEqual(0, len(a), comment=msg, logOnSuccess=logOnSuccess)
 
 
# -- def ASSERT_EMPTY -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ASSERT_EMPTY(a, msg=None, logOnSuccess=None):
    if not Base_compareEqual(0, len(a), comment=msg, logOnSuccess=logOnSuccess):
        raise AssertException("Container %s is not empty." % (str(a)))
 
 
# -- def EXPECT_NOT_EMPTY -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def EXPECT_NOT_EMPTY(a, msg=None, logOnSuccess=None):
    return Base_compareLessThan(0, len(a), comment=msg, logOnSuccess=logOnSuccess)
 
 
# -- def ASSERT_NOT_EMPTY -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ASSERT_NOT_EMPTY(a, msg=None, logOnSuccess=None):
    if not Base_compareLessThan(0, len(a), comment=msg, logOnSuccess=logOnSuccess):
        raise AssertException("Container %s is empty." % (str(a)))
 
 
# -- def EXPECT_SIZE -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def EXPECT_SIZE(a, size, msg=None, logOnSuccess=None):
    return Base_compareEqual(size, len(a), comment=msg, logOnSuccess=logOnSuccess)
 
 
# -- def ASSERT_SIZE -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ASSERT_SIZE(a, size, msg=None, logOnSuccess=None):
    if not Base_compareEqual(size, len(a), comment=msg, logOnSuccess=logOnSuccess):
        raise AssertException("Container %s size is not %s." % (str(a), str(size)))
 
 
# -- def EXPECT_PATH_EXISTS -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def EXPECT_PATH_EXISTS(path, msg=None, logOnSuccess=None):
    contextMsg = "Path = %s" % path
    return Base_verifyTrue(os.path.exists(path), comment=msg, msg=contextMsg, logOnSuccess=logOnSuccess)
 
 
# -- def EXPECT_PATH_MISSING -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def EXPECT_PATH_MISSING(path, msg=None, logOnSuccess=None):
    contextMsg = "Path = %s" % path
    return Base_verifyFalse(os.path.exists(path), comment=msg, msg=contextMsg, logOnSuccess=logOnSuccess)
 
 
# -- def ASSERT_PATH_EXISTS -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ASSERT_PATH_EXISTS(path, msg=None, logOnSuccess=None):
    contextMsg = "Path = %s" % path
    if not Base_verifyTrue(os.path.exists(path), comment=msg, msg=contextMsg, logOnSuccess=logOnSuccess):
        raise AssertException("Path does not exist: %s" % path)
 
 
# -- def ASSERT_PATH_MISSING -----------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ASSERT_PATH_MISSING(path, msg=None, logOnSuccess=None):
    contextMsg = "Path = %s" % path
    if not Base_verifyFalse(os.path.exists(path), comment=msg, msg=contextMsg, logOnSuccess=logOnSuccess):
        raise AssertException("Path exists: %s" % path)
 
 
# -- def INFO ----------------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def INFO(msg):
    Logging_info(msg, depth=1)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def WARNING -------------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def WARNING(msg):
    Logging_warning(msg, depth=1)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def ERROR ---------------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ERROR(msg):
    Logging_error(msg, depth=1)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def DEBUG_STOP ---------------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def DEBUG_STOP():
    Logging_info("Stopping because of DEBUG_STOP()", depth=1)
    Logging_setStopped(True)
    raise CancelTestException
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
from .Base import (
    verifyFalse as Base_verifyFalse,
    verifyTrue as Base_verifyTrue,
    compareEqual as Base_compareEqual,
    compareNotEqual as Base_compareNotEqual,
    compareLessThan as Base_compareLessThan,
    compareLessThanOrEqual as Base_compareLessThanOrEqual,
    compareGreaterThan as Base_compareGreaterThan,
    compareGreaterThanOrEqual as Base_compareGreaterThanOrEqual,
    compareFloatEqual as Base_compareFloatEqual,
    compareFloatNotEqual as Base_compareFloatNotEqual,
    compareFloatLessThanOrEqual as Base_compareFloatLessThanOrEqual,
    compareFloatGreaterThan as Base_compareFloatGreaterThan,
    compareFloatLessThan as Base_compareFloatLessThan,
)
from .Logging import (
    error as Logging_error,
    warning as Logging_warning,
    info as Logging_info,
    setStopped as Logging_setStopped,
)