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
#
 

 
# -- 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,
)
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
 
    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, optional=True):
            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,
        f"{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,
        f"{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,
        f"{escapedUnicode(a)} ({type(a).__name__}) < {escapedUnicode(b)} ({type(b).__name__})",
        comment,
        shouldLogOnSuccess(logOnSuccess),
    )
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def compareGreaterThan -----------------------------------------------------------------------{{{-

@LoggingDecorator
def compareGreaterThan(a, b, comment="", logOnSuccess=None):
    return (
        a > b,
        f"{escapedUnicode(a)} ({type(a).__name__}) > {escapedUnicode(b)} ({type(b).__name__})",
        comment,
        shouldLogOnSuccess(logOnSuccess),
    )
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def compareLessThanOrEqual ----------------------------------------------------------------{{{-

@LoggingDecorator
def compareGreaterThanOrEqual(a, b, comment="", logOnSuccess=None):
    return (
        a >= b,
        f"{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,
        f"{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 = f"Comparing {str(a)} ({type(a).__name__}) == {str(b)} ({type(b).__name__}) with epsilon={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 = f"Comparing {str(a)} ({type(a).__name__}) != {str(b)} ({type(b).__name__}) with epsilon={epsilon}"
    return not Math_compareFloatEqual(a, b, epsilon), msg, comment, shouldLogOnSuccess(logOnSuccess)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def compareFloatLessThan ------------------------------------------------------------------{{{-

@LoggingDecorator
def compareFloatLessThan(a, b, comment="", logOnSuccess=None):
    msg = f"Comparing {str(a)} ({type(a).__name__}) < {str(b)} ({type(b).__name__})"
    return Math_compareFloatLessThan(a, b), msg, comment, shouldLogOnSuccess(logOnSuccess)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def compareFloatGreaterThan ------------------------------------------------------------------{{{-

@LoggingDecorator
def compareFloatGreaterThan(a, b, comment="", logOnSuccess=None):
    msg = f"Comparing {str(a)} ({type(a).__name__}) > {str(b)} ({type(b).__name__})"
    return Math_compareFloatLessThan(b, a), msg, comment, shouldLogOnSuccess(logOnSuccess)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def compareFloatLessThanOrEqual ---------------------------------------------------------{{{-

@LoggingDecorator
def compareFloatLessThanOrEqual(a, b, comment="", epsilon=0.0001, logOnSuccess=None):
    msg = f"Comparing {str(a)} ({type(a).__name__}) <= {str(b)} ({type(b).__name__}) with epsilon={epsilon}"
    return Math_compareFloatLessThanOrEqual(a, b, epsilon), msg, comment, shouldLogOnSuccess(logOnSuccess)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def compareFloatGreaterThanOrEqual ---------------------------------------------------------{{{-

@LoggingDecorator
def compareFloatGreaterThanOrEqual(a, b, comment="", epsilon=0.0001, logOnSuccess=None):
    msg = f"Comparing {str(a)} ({type(a).__name__}) >= {str(b)} ({type(b).__name__}) with epsilon={epsilon}"
    return Math_compareFloatLessThanOrEqual(b, a, 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 = f"Must evaluate to True: {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 = f"Must evaluate to False: {escapedUnicode(expr)} ({type(expr).__name__})"
    return success, msg, comment, shouldLogOnSuccess(logOnSuccess)
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def expectError ---------------------------------------------------------------------------{{{-

@UseStackFrameFromCallerForLogging
def expectError(function, args=(), kwargs=None, errorRegExp=None, preventReplacingMessageSeverity=False, *, kargs=None):
    testHelper = TestHelper.getInstance()
    logHandler = testHelper.getLogHandler()
    assert logHandler is not None
 
    errors = SuppressedErrors(errorRegExp, Logging_error, preventReplacingMessageSeverity)
    try:
        return function(*args, **(kwargs or kargs or {}))
    finally:
        errors.handleResult()
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def expectWarning -------------------------------------------------------------------------{{{-

@UseStackFrameFromCallerForLogging
def expectWarning(function, args=(), kwargs=None, warningRegExp=None, *, kargs=None):
    testHelper = TestHelper.getInstance()
    logHandler = testHelper.getLogHandler()
    assert not logHandler is None
 
    warnings = SuppressedWarnings(warningRegExp, Logging_error)
    try:
        return function(*args, **(kwargs or kargs or {}))
    finally:
        warnings.handleResult()
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def expectWarningAndError ---------------------------------------------------------------------------{{{-

@UseStackFrameFromCallerForLogging
def expectWarningAndError(function, args=(), kwargs=None, errorRegExp=None, warningRegExp=None, *, kargs=None):
    testHelper = TestHelper.getInstance()
    logHandler = testHelper.getLogHandler()
    assert not logHandler is None
 
    warnings = SuppressedWarnings(warningRegExp, Logging_error)
    errors = SuppressedErrors(errorRegExp, Logging_error)
    try:
        return function(*args, **(kwargs or kargs or {}))
    finally:
        errors.handleResult()
        warnings.handleResult()
 
 
# -- def ignoreError ---------------------------------------------------------------------------{{{-

@UseStackFrameFromCallerForLogging
def ignoreError(function, args=(), kwargs=None, errorRegExp=None, resultInfoDict=None, *, kargs=None):
    testHelper = TestHelper.getInstance()
    logHandler = testHelper.getLogHandler()
 
    assert not logHandler is None
 
    errors = SuppressedErrors(errorRegExp, logErrorFunc=None)
    try:
        return function(*args, **(kwargs or kargs or {}))
    finally:
        hadIgnoredErrors = errors.handleResult()
        if isinstance(resultInfoDict, dict):
            resultInfoDict["hadIgnoredErrors"] = hadIgnoredErrors
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def ignoreWarning ---------------------------------------------------------------------------{{{-

@UseStackFrameFromCallerForLogging
def ignoreWarning(function, args=(), kwargs=None, warningRegExp=None, resultInfoDict=None, *, kargs=None):
    testHelper = TestHelper.getInstance()
    logHandler = testHelper.getLogHandler()
 
    assert not logHandler is None
 
    warnings = SuppressedWarnings(warningRegExp, logErrorFunc=None)
    try:
        return function(*args, **(kwargs or kargs or {}))
    finally:
        hadIgnoredWarnings = warnings.handleResult()
        if isinstance(resultInfoDict, dict):
            resultInfoDict["hadIgnoredWarnings"] = hadIgnoredWarnings
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def ignoreWarningAndError ---------------------------------------------------------------------------{{{-

@UseStackFrameFromCallerForLogging
def ignoreWarningAndError(
    function, args=(), kwargs=None, errorRegExp=None, warningRegExp=None, resultInfoDict=None, *, kargs=None
):
    testHelper = TestHelper.getInstance()
    logHandler = testHelper.getLogHandler()
    assert not logHandler is None
 
    warnings = SuppressedWarnings(warningRegExp, logErrorFunc=None)
    errors = SuppressedErrors(errorRegExp, logErrorFunc=None)
    try:
        return function(*args, **(kwargs or kargs or {}))
    finally:
        hadIgnoredErrors = errors.handleResult()
        hadIgnoredWarnings = warnings.handleResult()
        if isinstance(resultInfoDict, dict):
            resultInfoDict["hadIgnoredWarnings"] = hadIgnoredWarnings
            resultInfoDict["hadIgnoredErrors"] = hadIgnoredErrors
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- def expectInfo ---------------------------------------------------------------------------{{{-

@UseStackFrameFromCallerForLogging
def expectInfo(function, args=(), kwargs=None, infoRegExp=None, allowUnexpectedMessages=True, *, kargs=None):
    testHelper = TestHelper.getInstance()
    logHandler = testHelper.getLogHandler()
    assert not logHandler is None
 
    expectInfos = ExpectInfos(infoRegExp, allowUnexpectedMessages, Logging_error)
    try:
        return function(*args, **(kwargs or kargs or {}))
    finally:
        expectInfos.handleResult()
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# 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():
    if TestHelper.getInstance().getChangeSetStackLength() > 2:
        return TestHelper.getInstance().popChangeSet()
    return False
 
 
# ----------------------------------------------------------------------------------------------}}}-
 
 
# -- 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 the readability of log messages.
# @param returncode The return code 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,
)