Base.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 ----------------------------------------------------------------------------{{{-
import difflib
import linecache
import os
import re
import subprocess
import sys
import hashlib
import traceback
# ----------------------------------------------------------------------------------------------}}}-
 
# -- local imports -----------------------------------------------------------------------------{{{-
from contextlib import contextmanager
 
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:
      with open(filename, 'rb') as fh:
        bom = fh.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 = logOnSuccess
  def __call__(self, func):
    def wrapper (*args, **kwds):
      logOnSuccess = TestHelper.getInstance().getMacrosLogOnSuccess()
      setMacrosShouldLogOnSuccess(self.__logOnSuccess__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 --------------------------------------------------------------------------{{{-
 
@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 -----------------------------------------------------------------------{{{-
 
@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 -----------------------------------------------------------------------{{{-
 
@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 ----------------------------------------------------------------{{{-
 
@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 ---------------------------------------------------------------------{{{-
 
@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 ------------------------------------------------------------------{{{-
 
@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 ------------------------------------------------------------------{{{-
 
@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 ---------------------------------------------------------{{{-
 
@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 ----------------------------------------------------------------------------{{{-
 
@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 ---------------------------------------------------------------------------{{{-
 
@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 ---------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def expectError (function, args=[], kargs={}, errorRegExp=None, preventReplacingMessageSeverity=False):
  testHelper = TestHelper.getInstance()
  logHandler = testHelper.getLogHandler()
  assert not logHandler is None
 
  errors = SuppressedErrors(errorRegExp, Logging_error, preventReplacingMessageSeverity)
  try:
    retVal = function(*args, **kargs)
  finally:
    errors.handleResult()
 
  return retVal
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def expectWarning -------------------------------------------------------------------------{{{-
 
@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 ---------------------------------------------------------------------------{{{-
 
@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 ignoreError ---------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ignoreError (function, args=(), kargs=None, errorRegExp=None, resultInfoDict=None):
  def ___doNotLog( _msg ): pass
  #
  kargs = kargs or {}
  testHelper = TestHelper.getInstance()
  logHandler = testHelper.getLogHandler()
 
  assert not logHandler is None
 
  hadIgnoredErrors = False
  errors = SuppressedErrors( errorRegExp, logErrorFunc=None )
  try:
    retVal = function(*args, **kargs)
  finally:
    hadIgnoredErrors = errors.handleResult()
    if isinstance( resultInfoDict, dict ):
      resultInfoDict[ "hadIgnoredErrors" ] = hadIgnoredErrors    
 
  return retVal
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def ignoreWarning ---------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ignoreWarning (function, args=(), kargs=None, warningRegExp=None, resultInfoDict=None ):
  def ___doNotLog( _msg ): pass
  #
  kargs = kargs or {}
  testHelper = TestHelper.getInstance()
  logHandler = testHelper.getLogHandler()
 
  assert not logHandler is None
 
  hadIgnoredWarnings = False
  warnings = SuppressedWarnings( warningRegExp, logErrorFunc=None )
  try:
    retVal = function(*args, **kargs)
  finally:
    hadIgnoredWarnings = warnings.handleResult()
    if isinstance( resultInfoDict, dict ):
      resultInfoDict[ "hadIgnoredWarnings" ] = hadIgnoredWarnings
 
  return retVal
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def ignoreWarningAndError ---------------------------------------------------------------------------{{{-
 
@UseStackFrameFromCallerForLogging
def ignoreWarningAndError (function, args=[], kargs={}, errorRegExp=None, warningRegExp=None, resultInfoDict=None):
  testHelper = TestHelper.getInstance()
  logHandler = testHelper.getLogHandler()
  assert not logHandler is None
 
  warnings = SuppressedWarnings(warningRegExp, logErrorFunc=None)
  errors = SuppressedErrors(errorRegExp, logErrorFunc=None)
  try:
    retVal = function(*args, **kargs)
  finally:
    hadIgnoredErrors = errors.handleResult()
    hadIgnoredWarnings = warnings.handleResult()
    if isinstance( resultInfoDict, dict ):
      resultInfoDict[ "hadIgnoredWarnings" ] = hadIgnoredWarnings
      resultInfoDict[ "hadIgnoredErrors" ] = hadIgnoredErrors        
 
  return retVal
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def expectInfo ---------------------------------------------------------------------------{{{-
 
@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
# ----------------------------------------------------------------------------------------------}}}-
 
 
# Helpers for expected errors or warnings that can be used with a context manager
 
 
@contextmanager
@UseStackFrameFromCallerForLogging
def hasNoWarning(warningRegExp=None):
  """Expect that the expression in the context block issues no warning that matches `warningRegExp`.
  If `warningRegExp` is not given, no warning is expected at all.
 
  Usage:
  with hasNoWarning():
      doStuff()
  """
  warnings = SuppressedWarnings(warningRegExp, expectWarning=False)
  try:
    yield
  finally:
    warnings.handleResult()
 
 
@contextmanager
@UseStackFrameFromCallerForLogging
def hasWarning(warningRegExp=None):
  """Expect that the expression in the context block logs a warning that matches `warningRegExp`.
  If `warningRegExp` is not given, any warning is expected.
 
  Usage:
  with hasWarning():
      doStuff()
  """
  warnings = SuppressedWarnings(warningRegExp, expectWarning=True)
  try:
    yield
  finally:
    warnings.handleResult()
 
 
@contextmanager
@UseStackFrameFromCallerForLogging
def hasError(errorRegExp=None):
  """Expect that the expression in the context logs an error that matches `errorRegExp`.
  If `errorRegExp` is not given, any error is expected.
 
  Usage:
  with hasError():
      doStuff()
  """
  errors = SuppressedErrors(errorRegExp, Logging_error)
  try:
    yield
  finally:
    errors.handleResult()
 
 
@contextmanager
@UseStackFrameFromCallerForLogging
def hasWarningAndError(errorRegExp=None, warningRegExp=None):
  """Expect that the expression in the context logs errors and warnings.
  See `hasError` and `hasWarning` for the arguments.
 
  Usage:
  with hasWarningAndError():
      doStuff()
  """
  warnings = SuppressedWarnings(warningRegExp, Logging_error)
  errors = SuppressedErrors(errorRegExp, Logging_error)
  try:
    yield
  finally:
    errors.handleResult()
    warnings.handleResult()
 
 
@contextmanager
@UseStackFrameFromCallerForLogging
def hasInfo(infoRegExp=None, allowUnexpectedMessages=True):
  """Expect that the expression in the context logs an info entry that matches `infoRegExp`.
  If `infoRegExp` is not given, any info message is expected.
  If `allowUnexpectedMessages` is set to True (the default), messages that do not match `infoRegExp` are ignored,
  otherwise they are considered a failure.
 
  Usage:
  with hasInfo(infoRegExp=".*Unknown module.*"):
      doStuff()
  """
  expectInfos = ExpectInfos(infoRegExp, allowUnexpectedMessages, Logging_error)
  try:
    yield
  finally:
    expectInfos.handleResult()
 
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def getResultDirectory --------------------------------------------------------------------{{{-
 
def getResultDirectory ():
  return TestHelper.getInstance().getTestCaseResultDirectory()
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def getDataDirectory ----------------------------------------------------------------------{{{-
 
def getDataDirectory ():
  return TestHelper.getInstance().getTestCaseDataDirectory()
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def getFileInDataDirectory ----------------------------------------------------------------{{{-
 
def getFileInDataDirectory (filename):
  return os.path.join(getDataDirectory(), filename)
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def existsFileInDataDirectory -------------------------------------------------------------{{{-
 
def existsFileInDataDirectory (filename):
  return os.path.exists(getFileInDataDirectory(filename))
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def getExternalDataDirectory --------------------------------------------------------------{{{-
 
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 -------------------------------------------------------------------------{{{-
 
def pushChangeSet ():
  return TestHelper.getInstance().pushChangeSet()
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def popChangeSet --------------------------------------------------------------------------{{{-
 
def popChangeSet ():
  retVal = True
  if TestHelper.getInstance().getChangeSetStackLength() > 2:
    retVal = TestHelper.getInstance().popChangeSet()
  else:
    retVal = False
  return retVal
# ----------------------------------------------------------------------------------------------}}}-
 
# -- def getHash -------------------------------------------------------------------------------{{{-
 
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 ----------------------------------------------------------------{{{-
 
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 ----------------------------------------------------------------{{{-
 
def addExtraTestCaseResult(extraTestCaseResult):
  return TestHelper.getInstance().addExtraTestCaseResult(extraTestCaseResult)
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def pushEnvironment -----------------------------------------------------------------------{{{-
 
def pushEnvironment():
  return TestHelper.getInstance().pushEnvironment()
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def popEnvironment -----------------------------------------------------------------------{{{-
 
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.abc.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.
# @param env A dictionary with environment variables. Default is os.environ.
# @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, env=None):
  Macros_INFO("Running: " + " ".join(command))
  if env is None:
    env = os.environ
  if wait:
    p = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env)
  else:
    p = subprocess.Popen(command, env=env)
  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.
# @param env A dictionary with environment variables. Default is os.environ.
# @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, env=None):
  python = mevis.MLABFileManager.getExecutable("MeVisPython")
  command = [python, "-u", script]
  command.extend(arguments)
  return runProcess(command, wait=wait, expectSuccess=expectSuccess, expectFailure=expectFailure, verbose=verbose, env=env)
 
 
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