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
#
 
from builtins import str
 
# Already ported to Python 3
 
 
# -- 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_compareLessThan(b, a, 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_compareLessThan(b, a, comment = msg, logOnSuccess = logOnSuccess)
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def ASSERT_GE -----------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ASSERT_GE (a, b, msg=None, logOnSuccess=None):
  if not Base_compareLessThanOrEqual(b, a, 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_compareLessThanOrEqual(b, a, 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_compareFloatLessThan(b, a, 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_compareFloatLessThan(b, a, 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, \
                  compareFloatEqual as Base_compareFloatEqual, compareFloatNotEqual as Base_compareFloatNotEqual, \
                  compareFloatLessThanOrEqual as Base_compareFloatLessThanOrEqual, \
                  compareFloatLessThan as Base_compareFloatLessThan
from .Logging import error as Logging_error, warning as Logging_warning, info as Logging_info, setStopped as Logging_setStopped