Base.py

Go to the documentation of this file.

from builtins import str

# Already ported to Python 3
# **InsertLicense** code author="Gereon A. Frey"


# -- system imports ----------------------------------------------------------------------------{{{-
import difflib
import linecache
import os
import re
import subprocess
import sys
import hashlib
import traceback
# ----------------------------------------------------------------------------------------------}}}-

# -- local imports -----------------------------------------------------------------------------{{{-
import mevis

from TestSupport.TestHelper import TestHelper, UseStackFrameFromCallerForLogging, SetLoggingCallerStackFrame, \
                                   SuppressedErrors, SuppressedWarnings, ExpectInfos
from TestSupport.FieldValueTests import FieldValueTestCaseSet
import collections
# ----------------------------------------------------------------------------------------------}}}-

gEncodingRegExp = re.compile("^[ \t\v]*#.*?coding[:=][ \t]*([-_.a-zA-Z0-9]+)")
gEncodingCache = {}

def clearEncodingCache():
  global gEncodingCache
  gEncodingCache = {}

def getSourceFileEncoding(filename):
  encoding = gEncodingCache.get(filename)
  if encoding is None:
    encoding = "latin1"
    try:
      bom = open(filename, 'rb').read(3)
    except IOError:
      bom = None
    if bom == b"\xef\xbb\xbf":
      encoding = "utf8"
    else:
      line = linecache.getline(filename, 0)
      m = gEncodingRegExp.match(line)
      if m == None:
        line = linecache.getline(filename, 1)
        m = gEncodingRegExp.match(line)
      if m is not None:
        encoding = m.group(1)
    gEncodingCache[filename] = encoding
  return encoding

def decodeSourceCodeLine(filename, line):
  encoding = getSourceFileEncoding(filename)
  try:
    decodedLine = line.decode(encoding)
  except UnicodeDecodeError:
    decodedLine = line.decode("latin1")
  return decodedLine


# -- def getPackageList ------------------------------------------------------------------------{{{-

def getPackageList ():
  return TestHelper.getInstance().getPackageList()
# ----------------------------------------------------------------------------------------------}}}-

# -- def getTestCaseContext --------------------------------------------------------------------{{{-

def getTestCaseContext ():
  return TestHelper.getInstance().getTestCaseContext()
# ----------------------------------------------------------------------------------------------}}}-

# -- def getModuleName -------------------------------------------------------------------------{{{-

def getModuleName ():
  return TestHelper.getInstance().getModuleName()
# ----------------------------------------------------------------------------------------------}}}-


def getTestFunctionName ():
  frame = sys._getframe()
  lastFunction = frame.f_code.co_name
  while frame:
    if frame.f_code.co_name == '__callTestFunction':
      class_ = frame.f_locals['self'].__class__
      # verify that the class of __callTestFunction is TestCase
      if hasattr(class_, '_TestCase__callSetUpTestCase'):
        return lastFunction
    lastFunction = frame.f_code.co_name
    frame =  frame.f_back
  return 'Unknown'

# -- def MacrosShouldLogOnSuccess --------------------------------------------------------------{{{-

def setMacrosShouldLogOnSuccess(logOnSuccess):
  TestHelper.getInstance().setMacrosLogOnSuccess(logOnSuccess)
  
def shouldLogOnSuccess(logOnSuccess=None):
  if logOnSuccess is None:
    return TestHelper.getInstance().getMacrosLogOnSuccess()
  else:
    return logOnSuccess


class MacrosShouldLogOnSuccessDecorator:
  def __init__(self, logOnSuccess):
    self.__logOnSuccess = logOnSuccess
  def __call__(self, func):
    def wrapper (*args, **kwds):
      logOnSuccess = TestHelper.getInstance().getMacrosLogOnSuccess()
      setMacrosShouldLogOnSuccess(self.__logOnSuccess)
      try:
        r = func(*args, **kwds)
      finally:
        setMacrosShouldLogOnSuccess(logOnSuccess)
      return r
    return wrapper
# ----------------------------------------------------------------------------------------------}}}-

# -- def LoggingDecorator ----------------------------------------------------------------------{{{-
# @cond

def LoggingDecorator (func):
  def wrapper (*args, **kwds):
    with SetLoggingCallerStackFrame(1):
      expr, msg, comment, logOnSuccess = func(*args, **kwds)
      stackLine = traceback.extract_stack(TestHelper.getInstance().getCallerStackFrame(), 1)[0]
      codeLine = stackLine[3]
      if isinstance(codeLine, bytes):
        codeLine = decodeSourceCodeLine(stackLine[0], stackLine[3])
      if not expr:
        Logging_error("%s: %s%s" % (codeLine, msg, ": %s" % (comment) if comment else ''), type="Compare", depth=1)
      else:
        if logOnSuccess:
          Logging_info("%s: %s%s" % (codeLine, msg, ": %s" % (comment) if comment else ''), type="Compare", depth=1)
      return expr
  return wrapper
# @endcond
# ----------------------------------------------------------------------------------------------}}}-

def escapedUnicode(value):
  """ Returns a unicode representation of value. If value is of type bytes then non-ASCII characters
      are escaped and a representation of the string is returned.
      For example, the 8-bit literal b'\x01' becomes 'u"\x01"'.
  """
  if isinstance(value, bytes):
    return repr(str(value))
  else:
    return str(value)

# -- def compareEqual --------------------------------------------------------------------------{{{-
## Compare the two given values for equality.
#  If the two values are unequal an error is logged.
#  @param a The first value.
#  @param b The second value.
#  @param comment Optional comment shown if comparison fails.
#  @param logOnSuccess Print message in case of success.
#  @return True if values are equal.
@LoggingDecorator
def compareEqual (a, b, comment="", logOnSuccess=None):
  expr = a==b
  if hasattr(expr, 'all'):  # looks like a numpy.ndarray
    expr = expr.all()
  return expr, u"%s (%s) == %s (%s)" % (escapedUnicode(a), type(a).__name__, escapedUnicode(b), type(b).__name__), comment, shouldLogOnSuccess(logOnSuccess)
# ----------------------------------------------------------------------------------------------}}}-

# -- def compareNotEqual -----------------------------------------------------------------------{{{-
## Compare the two given values for inequality.
#  If the two values are equal an error is logged.
#  @param a The first value.
#  @param b The second value.
#  @param comment Optional comment shown if comparison fails.
#  @param logOnSuccess Print message in case of success.
#  @return True if the values are unequal.
@LoggingDecorator
def compareNotEqual (a, b, comment="", logOnSuccess=None):
  expr = a!=b
  if hasattr(expr, 'any'):  # looks like a numpy.ndarray
    expr = expr.any()
  return expr, u"%s (%s) != %s (%s)" % (escapedUnicode(a), type(a).__name__, escapedUnicode(b), type(b).__name__), comment, shouldLogOnSuccess(logOnSuccess)
# ----------------------------------------------------------------------------------------------}}}-

# -- def compareLessThan -----------------------------------------------------------------------{{{-
## Compare the two given values if the first one is less than the second.
#  @param a The first value.
#  @param b The second value.
#  @param comment Optional comment shown if comparison fails.
#  @param logOnSuccess Print message in case of success.
#  @return True if the first value is less than the second.
@LoggingDecorator
def compareLessThan (a, b, comment="", logOnSuccess=None):
  return a<b, u"%s (%s) < %s (%s)" % (escapedUnicode(a), type(a).__name__, escapedUnicode(b), type(b).__name__), comment, shouldLogOnSuccess(logOnSuccess)
# ----------------------------------------------------------------------------------------------}}}-

# -- def compareLessThanOrEqual ----------------------------------------------------------------{{{-
## Compare the two given values if the first one is less than or equal to the
#  second.
#  @param a The first value.
#  @param b The second value.
#  @param comment Optional comment shown if comparison fails.
#  @param logOnSuccess Print message in case of success.
#  @return True if the first value less than or equal to the second.
@LoggingDecorator
def compareLessThanOrEqual (a, b, comment="", logOnSuccess=None):
  return a<=b, u"%s (%s) <= %s (%s)" % (escapedUnicode(a), type(a).__name__, escapedUnicode(b), type(b).__name__), comment, shouldLogOnSuccess(logOnSuccess)
# ----------------------------------------------------------------------------------------------}}}-

# -- def compareFloatEqual ---------------------------------------------------------------------{{{-
## Compare the two given float values if they are epsilon-equal.
#  @param a The first value.
#  @param b The second value.
#  @param comment Comment shown if comparison fails.
#  @param epsilon Epsilon used for float comparison.
#  @param logOnSucces Print message in case of success.
#  @return True if values are equal.
@LoggingDecorator
def compareFloatEqual (a, b, comment="", epsilon=0.0001, logOnSuccess=None):
  msg = u"Comparing %s (%s) == %s (%s) with epsilon=%f" % (str(a), type(a).__name__, str(b), type(b).__name__, epsilon)
  return Math_compareFloatEqual(a, b, epsilon), msg, comment, shouldLogOnSuccess(logOnSuccess)
# ----------------------------------------------------------------------------------------------}}}-

# -- def compareFloatNotEqual ------------------------------------------------------------------{{{-
## Compare the two given float values if they are epsilon-unequal.
#  @param a The first value.
#  @param b The second value.
#  @param comment Comment shown if comparison fails.
#  @param epsilon Epsilon used for float comparison.
#  @param logOnSucces Print message in case of success.
#  @return True if values are unequal.
@LoggingDecorator
def compareFloatNotEqual (a, b, comment="", epsilon=0.0001, logOnSuccess=None):
  msg = u"Comparing %s (%s) != %s (%s) with epsilon=%f" % (str(a), type(a).__name__, str(b), type(b).__name__, epsilon)
  return not Math_compareFloatEqual(a, b, epsilon), msg, comment, shouldLogOnSuccess(logOnSuccess)
# ----------------------------------------------------------------------------------------------}}}-

# -- def compareFloatLessThan ------------------------------------------------------------------{{{-
## Compare the two given float values if the first is less than the second.
#  @param a The first value.
#  @param b The second value.
#  @param comment Comment shown if comparison fails.
#  @param logOnSucces Print message in case of success.
#  @return True if first value is less than the second.
@LoggingDecorator
def compareFloatLessThan (a, b, comment="", logOnSuccess=None):
  msg = u"Comparing %s (%s) < %s (%s)" % (str(a), type(a).__name__, str(b), type(b).__name__)
  return Math_compareFloatLessThan(a, b), msg, comment, shouldLogOnSuccess(logOnSuccess)
# ----------------------------------------------------------------------------------------------}}}-

# -- def compareFloatLessThanOrEqual ---------------------------------------------------------{{{-
## Compare the two given float values if the first is less than or equal to the
#  second.
#  @param a The first value.
#  @param b The second value.
#  @param comment Comment shown if comparison fails.
#  @param epsilon Epsilon used for float comparison.
#  @param logOnSucces Print message in case of success.
#  @return True if first value is less than or equal to the second.
@LoggingDecorator
def compareFloatLessThanOrEqual (a, b, comment="", epsilon=0.0001, logOnSuccess=None):
  msg = u"Comparing %s (%s) <= %s (%s) with epsilon=%f" % (str(a), type(a).__name__, str(b), type(b).__name__, epsilon)
  return Math_compareFloatLessThanOrEqual(a, b, epsilon), msg, comment, shouldLogOnSuccess(logOnSuccess)
# ----------------------------------------------------------------------------------------------}}}-

# -- def verifyTrue ----------------------------------------------------------------------------{{{-
## If the given expression evaluates to False, an error is logged.
#  @param expr The expression that must evaluate to True.
#  @param comment Optional comment shown if expression is not True.
#  @param logOnSucces Print message in case of success.
#  @return True if expression evaluates to True.
@LoggingDecorator
def verifyTrue (expr, comment="", logOnSuccess=None, msg=None):
  success = bool( expr ) # we must do this before evaluating expr for the msg string generation which may have side effects
  if msg is None:
    msg = u"Must evaluate to True: {} ({})".format( escapedUnicode(expr), type(expr).__name__ )
  return success, msg, comment, shouldLogOnSuccess(logOnSuccess)
# ----------------------------------------------------------------------------------------------}}}-

# -- def verifyFalse ---------------------------------------------------------------------------{{{-
## If the given expression evaluates to True, an error is logged.
#  @param expr The expression that must evaluate to False.
#  @param comment Optional comment shown if expression is True.
#  @param logOnSucces Print message in case of success.
#  @return True if expression evaluates to False.
@LoggingDecorator
def verifyFalse (expr, comment="", logOnSuccess=None, msg=None):
  success = not bool( expr ) # we must do this before evaluating expr for the msg string generation which may have side effects
  if msg is None:
    msg = u"Must evaluate to False: {} ({})".format( expr, type(expr).__name__ )
  return success, msg, comment, shouldLogOnSuccess(logOnSuccess)
# ----------------------------------------------------------------------------------------------}}}-

# -- def expectError ---------------------------------------------------------------------------{{{-
## Call the given function with the given parameters and expect an error.
#  Please note that nesting the expect{Warning, Error} methods will lead to
#  invalid line numbers in the reports!
#  @param function The function to be called.
#  @param args List of parameters for the function.
#  @param kargs Dictionary of named parameters for the function.
#  @param errorRegExp Optional RegexObject to control which errors are handled.
#         (Strings will be assumed to be regular expressions and compiled automatically.)
#  @return Return value of the called function.
@UseStackFrameFromCallerForLogging
def expectError (function, args=[], kargs={}, errorRegExp=None):
  testHelper = TestHelper.getInstance()
  logHandler = testHelper.getLogHandler()
  assert not logHandler is None

  errors = SuppressedErrors(errorRegExp, Logging_error)
  try:
    retVal = function(*args, **kargs)
  finally:
    errors.handleResult()

  return retVal
# ----------------------------------------------------------------------------------------------}}}-

# -- def expectWarning -------------------------------------------------------------------------{{{-
## Call the given function with the given parameters and expect a warning.
#  Please note that nesting the expect{Warning, Error, Info} methods will lead to
#  invalid line numbers in the reports!
#  @param function The function to be called.
#  @param args List of parameters for the function.
#  @param kargs Dictionary of named parameters for the function.
#  @param warningRegExp Optional RegexObject to control which warnings are handled.
#         (Strings will be assumed to be regular expressions and compiled automatically.)
#  @return Return value of the called function.
@UseStackFrameFromCallerForLogging
def expectWarning (function, args=[], kargs={}, warningRegExp=None):
  testHelper = TestHelper.getInstance()
  logHandler = testHelper.getLogHandler()
  assert not logHandler is None

  warnings = SuppressedWarnings(warningRegExp, Logging_error)
  try:
    retVal = function(*args, **kargs)
  finally:
    warnings.handleResult()

  return retVal
# ----------------------------------------------------------------------------------------------}}}-

# -- def expectWarningAndError ---------------------------------------------------------------------------{{{-
## Call the given function with the given parameters and expect both a warning and an error.
#  Please note that nesting the expect{Warning, Error, Info} methods will lead to
#  invalid line numbers in the reports!
#  @param function The function to be called.
#  @param args List of parameters for the function.
#  @param kargs Dictionary of named parameters for the function.
#  @param errorRegExp Optional RegexObject to control which errors are handled.
#  @param warningRegExp Optional RegexObject to control which warnings are handled.
#  @return Return value of the called function.
@UseStackFrameFromCallerForLogging
def expectWarningAndError (function, args=[], kargs={}, errorRegExp=None, warningRegExp=None):
  testHelper = TestHelper.getInstance()
  logHandler = testHelper.getLogHandler()
  assert not logHandler is None

  warnings = SuppressedWarnings(warningRegExp, Logging_error)
  errors = SuppressedErrors(errorRegExp, Logging_error)
  try:
    retVal = function(*args, **kargs)
  finally:
    errors.handleResult()
    warnings.handleResult()

  return retVal

# -- def expectInfo ---------------------------------------------------------------------------{{{-
## Call the given function with the given parameters and expect an info message.
#  Please note that nesting the expect{Warning, Error, Info} methods will lead to
#  invalid line numbers in the reports!
#  @param function The function to be called.
#  @param args List of parameters for the function.
#  @param kargs Dictionary of named parameters for the function.
#  @param infoRegExp Optional RegexObject to control which info messages are expected.
#  @param allowUnexpectedMessages Optional flag to specify if unexpected messages are allowed.
#  @return Return value of the called function.
@UseStackFrameFromCallerForLogging
def expectInfo (function, args=[], kargs={}, infoRegExp=None, allowUnexpectedMessages=True):
  testHelper = TestHelper.getInstance()
  logHandler = testHelper.getLogHandler()
  assert not logHandler is None

  expectInfos = ExpectInfos(infoRegExp, allowUnexpectedMessages, Logging_error)
  try:
    retVal = function(*args, **kargs)
  finally:
    expectInfos.handleResult()

  return retVal

# ----------------------------------------------------------------------------------------------}}}-

# -- def getResultDirectory --------------------------------------------------------------------{{{-
## Getter for the directory used to save results.
#  All results should be collected in the given directory such that the
#  generated data will be cleaned up when appropriate.
#  @return Path to the result directory.
def getResultDirectory ():
  return TestHelper.getInstance().getTestCaseResultDirectory()
# ----------------------------------------------------------------------------------------------}}}-

# -- def getDataDirectory ----------------------------------------------------------------------{{{-
## Method to return path to the data files.
#  Sometimes data is required for test case that should not reside inside the
#  repository. This is where the dataDirectory option in the test case
#  definition comes into play. This is the value that can be changed using this
#  tag. The default is $(LOCAL)/Data.
#  @return The path to the directory where required data lives.
def getDataDirectory ():
  return TestHelper.getInstance().getTestCaseDataDirectory()
# ----------------------------------------------------------------------------------------------}}}-

# -- def getFileInDataDirectory ----------------------------------------------------------------{{{-
## Returns the absolute filename of a file in the data directory using getDataDirectory().
#  @return The absolute filename of a file in the data directory.
def getFileInDataDirectory (filename):
  return os.path.join(getDataDirectory(), filename)
# ----------------------------------------------------------------------------------------------}}}-

# -- def existsFileInDataDirectory -------------------------------------------------------------{{{-
## Checks if the given file exists in the data directory.
#  @return True if the file exists in the data directory, False otherwise.
def existsFileInDataDirectory (filename):
  return os.path.exists(getFileInDataDirectory(filename))
# ----------------------------------------------------------------------------------------------}}}-

# -- def getExternalDataDirectory --------------------------------------------------------------{{{-
## Method to return path to the external data directory.
#  Sometimes test cases require large data that should not be added to the
#  version control. The external data directories provide a solution for such
#  situations. If the subDirectory parameter is not given the same folder
#  structure is used like in the calling test case.
#  If the data directory does not exist None is returned.
#  @params name The name of the external data directory (FME or MMS for example).
#  @params subDirectory The sub directory in the external data store.
#  @return The path to the directory where required data lives.
def getExternalDataDirectory (name, subDirectory=None):
  testHelper = TestHelper.getInstance()
  testCaseContext = testHelper.getTestCaseContext()
  externalDataVariable = 'TESTCENTER_EXTERNAL_DATA_%s' % name
  externalDataPlaceholder = '$(%s)' % externalDataVariable
  externalDataBaseDirectory = testCaseContext.expandFilename(externalDataPlaceholder)
  if externalDataBaseDirectory == externalDataPlaceholder:
    raise LookupError('Variable %s could not be expanded. Please define it in your .prefs file.' %
                      externalDataVariable)
  if os.path.isdir(externalDataBaseDirectory):
    if subDirectory:
      return os.path.join(externalDataBaseDirectory, subDirectory)
    else:
      testCasePath = testCaseContext.localPath()
      path = mevis.MLABPackageManager.findPackageIdentifierAndRelativePath(testCasePath)[1]
      return os.path.join(externalDataBaseDirectory, path)
  raise ValueError('"%s" is not a directory.' % externalDataBaseDirectory)
# ----------------------------------------------------------------------------------------------}}}-

# -- def pushChangeSet -------------------------------------------------------------------------{{{-
## Push a new ChangeSet to the stack.
def pushChangeSet ():
  return TestHelper.getInstance().pushChangeSet()
# ----------------------------------------------------------------------------------------------}}}-

# -- def popChangeSet --------------------------------------------------------------------------{{{-
## Pop the last ChangeSet from the stack.
#  At least two ChangeSets (the global one and the one for the function) must
#  remain on the stack as they are not in the control of the user.
def popChangeSet ():
  retVal = True
  if TestHelper.getInstance().getChangeSetStackLength() > 2:
    retVal = TestHelper.getInstance().popChangeSet()
  else:
    retVal = False
  return retVal
# ----------------------------------------------------------------------------------------------}}}-

# -- def getHash -------------------------------------------------------------------------------{{{-
## Compute a hash for the content of the given file.
#  The hash is computed using the ImageHash module for images and using
#  python's hashlib for other files.
#  @param filename The file that should be hashed.
#  @param hash The hash algorithm to use.
#  @param encoder The encoder to use.
#  @return The computed hash or None in case of failure.
def getHash (filename, hash="SHA1", encoder="Hex"):
  result = None
  # Images are handled using the ImageHash module!
  b, ext = os.path.splitext(filename)
  if ext.lower() in (".dcm", ".hdr", ".img", ".bmp", ".jpg", ".jpeg", ".png", ".pnm", ".quo", ".raw", ".tif", ".tiff"):
    result = Image_calculateHashFromImage(filename, hash, encoder)
  else:
    try:
      h = hashlib.new(hash)
      with open(filename, "rb") as f:
        h.update(f.read())
      if encoder == "Hex":
        result = h.hexdigest()
      elif encoder == "Base64":
        result = h.digest()
      else:
        Logging_error("Unknown encoder (%s) selected." % (encoder))
    except Exception as e:
      Logging_error("Failed to generate hash: %s." % e)
  return result
# ----------------------------------------------------------------------------------------------}}}-

# -- def createExtraTestCaseResult ----------------------------------------------------------------{{{-
## Creates an ExtraTestCaseResult object.
# The extra test case results enable test cases to provide additional results as a test case.
# For example, this is used for web tests, where the web application generates an xml report.
# @param testCaseName The name of the test case.
# @param package The MeVisLab package of the test case.
# @param author The author of the test case.
# @param maintainer The current maintainer of the test case.
# @return The ExtraTestCaseResult object.
def createExtraTestCaseResult(testCaseName, package, author, duration, maintainer=None, file=None, line=None, comment=None, showTestFunctionSortingLiterals=False):
  return ExtraTestCaseResult(testCaseName, package, author, duration, maintainer, file, line, comment, showTestFunctionSortingLiterals)
# ----------------------------------------------------------------------------------------------}}}-


# -- def addExtraTestCaseResult ----------------------------------------------------------------{{{-
## Adds an ExtraTestCaseResult object.
# See createExtraTestCaseResult().
# @param extraTestCaseResult A ExtraTestCaseResult object.
def addExtraTestCaseResult(extraTestCaseResult):
  return TestHelper.getInstance().addExtraTestCaseResult(extraTestCaseResult)
# ----------------------------------------------------------------------------------------------}}}-


# -- def pushEnvironment -----------------------------------------------------------------------{{{-
## Pushes the current environment dictionary on a stack, so that modifications can be applied
# and be popped again later.
# See popEnvironment().
def pushEnvironment():
  return TestHelper.getInstance().pushEnvironment()
# ----------------------------------------------------------------------------------------------}}}-


# -- def popEnvironment -----------------------------------------------------------------------{{{-
## Pops the last pushed environment dictionary from a stack and makes it the current one.
# See pushEnvironment().
# @return Returns if there was an environment dictionary to pop.
def popEnvironment():
  return TestHelper.getInstance().popEnvironment()
# ----------------------------------------------------------------------------------------------}}}-

# -- def pushEnvironmentDecorator --------------------------------------------------------------{{{-

# Pushes the current environment before the function is called and pops it again after it has finished
def pushEnvironmentDecorator (func):
  def wrapper (*args, **kwds):
    pushEnvironment()
    # execute macro
    try:
      result = func(*args, **kwds)
    finally:
      popEnvironment()
    return result
  return wrapper
# ----------------------------------------------------------------------------------------------}}}-

def EnableHighPrecisionLoggingTimeStampsDecorator(func):
  def wrapper (*args, **kwds):
    wereHighPrecisionTimeStampsEnabled = mevis.MLAB.setHighPrecisionLoggingTimeStampsEnabled(True)
    try:
      result = func(*args, **kwds)
    finally:
      mevis.MLAB.setHighPrecisionLoggingTimeStampsEnabled(wereHighPrecisionTimeStampsEnabled)
    return result
  return wrapper

class HtmlDiff(difflib.HtmlDiff):

    _styles = """
        table.diff {font-family:monospace;border:medium;margin:0;}
        .diff_header {background-color:#e0e0e0}
        td.diff_header {text-align:right}
        .diff_next {background-color:#c0c0c0}
        .diff_add {background-color:#aaffaa}
        .diff_chg {background-color:#ffff77}
        .diff_sub {background-color:#ffaaaa}
        tr, td, th {vertical-align:top;}
        table.diff tbody {
          white-space: -pre-wrap;
          white-space: -o-pre-wrap;
          white-space: -moz-pre-wrap;
          white-space: pre-wrap;
          word-wrap: break-word;
        }"""

    _table_template = """
    <table class="diff" id="difflib_chg_%(prefix)s_top"
           cellspacing="0" cellpadding="1" rules="groups" width="100%%">
        <colgroup></colgroup> <colgroup></colgroup> <colgroup width="50%%"></colgroup>
        <colgroup></colgroup> <colgroup></colgroup> <colgroup width="50%%"></colgroup>
        %(header_row)s
        <tbody>
%(data_rows)s        </tbody>
    </table>"""

    def __init__(self):
        difflib.HtmlDiff.__init__(self)

    def _format_line(self,side,flag,linenum,text):
        try:
            linenum = '%d' % linenum
            id = ' id="%s%s"' % (self._prefix[side],linenum)
        except TypeError:
            # handle blank lines where linenum is '>' or ''
            id = ''
        # replace those things that would get confused with HTML symbols
        text=text.replace("&","&amp;").replace(">","&gt;").replace("<","&lt;")
        if len(text) == 0 or text == '\n':
            text = '<span style="display: block; background-color:#e0e0e0;">' + text + '</span>'
        return '<td class="diff_header"%s>%s</td><td>%s</td>' \
                % (id,linenum,text)

# ----------------------------------------------------------------------------------------------}}}-

# -- def pushEnvironmentDecorator --------------------------------------------------------------{{{-

# Creates a HTML diff from the two files
# @param fromLines The array containing the lines of the left string.
# @param toLines The array containing the lines of the right string.
# @param showOnlyContextOfDiff If true, then only the context lines around the diff are shown, otherwise the whole content is shown.
# @param numberOfContextLines The number of context line only the diff context is shown.
def createHtmlDiff(fromLines, toLines, showOnlyContextOfDiff=False, numberOfContextLines=10):
  diff = HtmlDiff().make_file(fromLines, toLines, "", "", showOnlyContextOfDiff, numberOfContextLines)
  return diff

# ----------------------------------------------------------------------------------------------}}}-


# Decorator for disabling test functions conditionally
def disableTestFunctionIf(condition):
  def MLABTC__disableTestFunctionIf_Decorator(func):
    disableTestFunction = condition() if isinstance(condition, collections.Callable) else condition
    if disableTestFunction:
      module = sys.modules[func.__module__]
      if not hasattr(module, 'MLABTC_DISABLED_TEST_FUNCTIONS'):
        setattr(module, 'MLABTC_DISABLED_TEST_FUNCTIONS', [])
      module.MLABTC_DISABLED_TEST_FUNCTIONS.append(func.__name__)
    return func
  return MLABTC__disableTestFunctionIf_Decorator


# Returns True if offscreen rendering is supported by the hardware. Otherwise returns False.
def hardwareSupportsOffscreenRendering():
    context = TestHelper.getInstance().getHelperContext()
    return context.field('oSSOffscreenRender.supported').value


# Creates a subprocess.Popen instance.
# @param command A list containing the executable and arguments for the process.
# @param wait If True (default), then the function waits for the process to finish. Afterwards it checks the
#             return code, stderr, and stdout according to the values of expectSuccess and expectFailure. Finally,
#             a tuple (stdout, stderr, returncode) is returned.
#             If False, then the subprocess.Popen instance is returned after it was created and started.
# @param expectSuccess If True (default), then this function expects the process to return 0.
#                      Stdout/stderr is logged as an info message on success, otherwise as error messages.
# @param expectFailure If True, then this function expects the process to return non-zero.
#                      Stdout/stderr is logged as an info message on failure, otherwise as error messages.
# @param verbose A boolean to indicate if stdout/stderr should be printed via Macros_INFO.
# @return A tuple (stdout, stderr, returncode) if wait is True, the subprocess.Popen instance otherwise.
def runProcess(command, wait=True, expectSuccess=True, expectFailure=False, verbose=True):
  Macros_INFO("Running: " + " ".join(command))
  if wait:
    p = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=os.environ)
  else:
    p = subprocess.Popen(command, env=os.environ)
  if wait:
    shortCommand = []
    for c in command:
      if len(os.path.splitext(c)[1]) > 0:
        c = os.path.basename(c)
      shortCommand.append(c)
    shortCommand = " ".join(shortCommand)
    stdout, stderr = p.communicate()
    stdout = stdout.strip()
    stderr = stderr.strip()
    stderr = stderr.decode('utf-8','replace')
    stdout = stdout.decode('utf-8','replace')
    verifyProcessResult(" ".join(command), shortCommand, p.returncode, stdout, stderr, expectSuccess, expectFailure, verbose)
    return stdout, stderr, p.returncode
  else:
    return p


# Helper function for runProcess().
# @param command A list containing the executable and arguments for the process.
# @param shortCommand A shorter command string to improve readability of log messages.
# @param returncode The returncode of the process.
# @param stdout The stdout output of the process.
# @param stderr The stderr output of the process.
# @param expectSuccess If True (default), then this function expects the process to return 0.
#                      Stdout/stderr is logged as an info message on success, otherwise as error messages.
# @param expectFailure If True, then this function expects the process to return non-zero.
#                      Stdout/stderr is logged as an info message on failure, otherwise as error messages.
# @param verbose A boolean to indicate if stdout/stderr should be printed via Macros_INFO.
def verifyProcessResult(command, shortCommand, returncode, stdout, stderr, expectSuccess=True, expectFailure=False, verbose=True):
  if expectSuccess:
    if returncode != 0:
      Macros_ERROR("Command returned non-zero: '" + command + "', return code: " + str(returncode))
      if len(stderr): Macros_ERROR(stderr)
      if len(stdout): Macros_ERROR(stdout)
    else:
      msg = "Success: " + shortCommand
      if verbose:
        if len(stderr): msg += "\n\n" + stderr
        if len(stdout): msg += "\n\n" + stdout
      Macros_INFO(msg)
  elif expectFailure:
    if returncode == 0:
      Macros_ERROR("Command returned zero: '" + command + "'")
      if len(stderr): Macros_ERROR(stderr)
      if len(stdout): Macros_ERROR(stdout)
    else:
      msg = "Expected failure: " + shortCommand
      if verbose:
        if len(stderr): msg += "\n\n" + stderr
        if len(stdout): msg += "\n\n" + stdout
      Macros_INFO(msg)


# Creates and starts a process from the python script using runProcess()
# @param wait If True (default), then the function waits for the process to finish. Afterwards it checks the
#             return code, stderr, and stdout according to the values of expectSuccess and expectFailure. Finally,
#             a tuple (stdout, stderr, returncode) is returned.
#             If False, then the subprocess.Popen instance is returned after it was created and started.
# @param expectSuccess If True (default), then this function expects the process to return 0.
#                      Stdout/stderr is logged as an info message on success, otherwise as error messages.
# @param expectFailure If True, then this function expects the process to return non-zero.
#                      Stdout/stderr is logged as an info message on failure, otherwise as error messages.
# @param verbose A boolean to indicate if stdout/stderr should be printed via Macros_INFO.
# @return A tuple (stdout, stderr, returncode) if wait is True, the subprocess.Popen instance otherwise.
def runPythonScript(script, arguments, wait=True, expectSuccess=True, expectFailure=False, verbose=True):
  python = mevis.MLABFileManager.getExecutable("MeVisPython")
  command = [python, "-u", script]
  command.extend(arguments)
  return runProcess(command, wait=wait, expectSuccess=expectSuccess, expectFailure=expectFailure, verbose=verbose)


from .ExtraTestCaseResult import ExtraTestCaseResult
from .Image import calculateHashFromImage as Image_calculateHashFromImage
from .Logging import error as Logging_error, warning as Logging_warning, info as Logging_info
from .Macros import ERROR as Macros_ERROR, INFO as Macros_INFO
from .Math import compareFloatEqual as Math_compareFloatEqual, \
                  compareFloatLessThan as Math_compareFloatLessThan, \
                  compareFloatLessThanOrEqual as Math_compareFloatLessThanOrEqual