Config.py

Go to the documentation of this file.

#
# Copyright 2007, 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
#
 
 
 
 
# -- local imports
try:
  import mevis
  mevisAvailable = hasattr(mevis, 'MLAB') and hasattr(mevis.MLAB, 'isDebug') and mevis.MLAB.isDebug() is not None
except ImportError:
  mevisAvailable = False
 
from . import Utils
from .Utils import deprecated
 
# -- system imports
import os
import sys
import tempfile
 
import xml.etree.cElementTree as etree
 
if sys.version_info.major >= 3:
  unicode = str
 
def getConfigFilePath (isTestCaseManager=False):
  if Utils.isMac:
    if mevisAvailable:
      path = os.path.join( mevis.MLABFileManager.getUserApplicationSupportDirectory(), 'Settings' )
    
    else:
      path = os.path.join( os.environ['HOME'], 'Library', 'Application Support', 'MeVisLab', 'Settings' )
 
  elif Utils.isWindows:
    path = os.path.join( os.environ[ 'LOCALAPPDATA' ], 'MeVis', 'MeVisLab' )
 
  elif Utils.isLinux:
    if mevisAvailable:
      path = mevis.MLABFileManager.getUserApplicationSupportDirectory()
 
    else:
      path = os.path.join( os.environ['HOME'], '.local', 'share', 'MeVis', 'MeVisLab' )
 
  else:
    path = os.getcwd()
 
  if ( not os.path.isdir( path )):
    os.makedirs( path )
 
  filePattern = "test_case_manager_cfg_{}.xml" if isTestCaseManager else "tc_cfg_{}.xml"
  return os.path.join( path, filePattern.format( sys.platform ))
 
 
def verifyConfiguration (cfgFile):
  if not os.path.isfile(cfgFile):
    Configuration(cfgFile)
    return False
  return True
 
 
class MLABExecutableNotFoundException(Exception):
  pass
 
 
class ReportConfig(object):
  def getReportDir():  # @NoSelf
    reportDir = ""
    if Utils.isWindows:
      reportDir = os.path.join(os.getenv("USERPROFILE"), "TestCenterReports")
    elif Utils.isMac:
      if mevisAvailable:
        reportDir = os.path.join(mevis.MLABFileManager.getUserApplicationSupportDirectory(), "TestCenterReports")
      else:
        reportDir = os.path.join(os.environ['HOME'], 'Library', 'Application Support', 'MeVisLab', 'TestCenterReports')
    elif Utils.isLinux:
      reportDir = os.path.join(os.getenv("HOME"), "TestCenterReports")
 
    return reportDir
 
 
  def __init__(self,
                directory = getReportDir(),
                name = "Report",
                timestampTemplate = "_%y_%m_%d__%H_%M",
                appendTestCaseName = False,
                appendTimestamp = False,
                collapseFunctions = False,
                showFailedFuctionsOnly = False,
                hideInfoMessages = False,
                hideSystemMessages = False):
      self.directorydirectory = directory
      self.namename = name
      self.timestampTemplatetimestampTemplate = timestampTemplate
      self.appendTestCaseNameappendTestCaseName = appendTestCaseName
      self.appendTimestampappendTimestamp = appendTimestamp
      self.collapseFunctionscollapseFunctions = collapseFunctions
      self.showFailedFunctionsOnlyshowFailedFunctionsOnly = showFailedFuctionsOnly
      self.hideInfoMessageshideInfoMessages = hideInfoMessages
      self.hideSystemMessageshideSystemMessages = hideSystemMessages
      self.maxErrorMessagesPerTestFunctionmaxErrorMessagesPerTestFunction = 1000
      self.maxInfoMessagesPerTestFunctionmaxInfoMessagesPerTestFunction = 1000
 
class Configuration (object):
  def __init__ (self, filePath=None, autoSave=True, isTestCaseManager=False):
    """ Loads configuration from given file or creates configuration with default values.
        If a configuration is created and @a autoSave is True then the configuration is
        automatically saved. Otherwise, you have to save is explicitly.
    """
    self.__setDefaultValues__setDefaultValues()
 
    # The default config file name is tc_cfg_<platform>.xml which can be
    # overwritten by explicitly specifying a filePath.
    if not filePath:
      filePath = getConfigFilePath(isTestCaseManager=isTestCaseManager)
 
    cfgFileToLoad = filePath
    if not os.path.isfile(cfgFileToLoad):
      # for backward compatibility: read settings from config file of automated test center
      cfgFileToLoad = getConfigFilePath(isTestCaseManager=False)
      
    if os.path.isfile(cfgFileToLoad):
      self.__load__load(cfgFileToLoad)
 
    if autoSave and not os.path.isfile(filePath):
      if mevisAvailable:
        warningTemplate = "Config file <a href='mlab-open:{filePath}'>{fileName}</a> does not exist: creating it."
        mevis.MLAB.logHTML(warningTemplate.format(filePath=filePath,
                                                         fileName=os.path.basename(filePath)))
      else:
        print("Config file %s does not exist: creating it." % (filePath))
      self.savesave(filePath)
 
    self.__configFilePath__configFilePath = os.path.abspath(filePath)
 
  
  def __setDefaultValues (self):
    def getArguments():
      arguments =  ["-nosplash", "-noide", "-quick"]
 
      if Utils.isMac:
        arguments.append("-unique")
 
      return arguments
 
    def getMLABBinariesPath():
      executablePath = ""
      if mevisAvailable:
        if Utils.isWindows:
          executablePath = os.path.dirname(mevis.MLABFileManager.getExecutable("MeVisLab"))
        elif Utils.isMac:
          executablePath = mevis.MLABFileManager.macGetBundleDir()
        elif Utils.isLinux:
          executablePath =  os.path.dirname(mevis.MLABFileManager.getExecutable("MeVisLab"))
      elif 'MLAB_BUILD' in os.environ:
        # developer environment, use that, no questions asked
        executablePath = os.path.abspath(
          os.path.join(os.environ.get('MLAB_BUILD'), 'MeVisLab', 'IDE', 'bin'))
      else:
        # check public sdk location relative to this file
        thisDir = os.path.dirname(os.path.abspath(__file__))
        thisMLABRoot = os.path.normpath(os.path.join(thisDir, '..', '..', '..', '..', '..', '..'))
        if Utils.isWindows:
          path = os.path.abspath(os.path.join(thisMLABRoot, 'MeVisLab', 'IDE', 'bin'))
          if os.path.isfile(os.path.join(path, 'MeVisLab.exe')):
            executablePath = path
        elif Utils.isMac:
          # MLAB_ROOT is MeVisLab.app/Contents/Packages
          path = os.path.abspath(os.path.join(thisMLABRoot, '..', '..'))
          if os.path.isdir(os.path.join(path, 'Contents')):
            executablePath = path
          else:
            path = os.path.join(os.environ['HOME'], 'Applications', 'MeVisLab.app')
            if os.path.isdir(path):
              executablePath = path
        elif Utils.isLinux:
          path = os.path.abspath(os.path.join(thisMLABRoot, '..', 'bin'))
          if os.path.isfile(os.path.join(path, 'MeVisLab')):
            executablePath = path
 
      return executablePath
 
 
    if Utils.isUnsupportedPlatform:
      raise Exception("Unsupported platform (%s)" % (sys.platform))
 
    self.__MLABCurrentExecutablePath__MLABCurrentExecutablePath = getMLABBinariesPath()
    self.__MLABExecutablePath__MLABExecutablePath = self.__MLABCurrentExecutablePath__MLABCurrentExecutablePath
    self.__MLABUseCurrent__MLABUseCurrent = True
    self.__MLABArguments__MLABArguments = getArguments()
    self.__MLABCompileMode__MLABCompileMode = "Automatic"
    self.__resultOutputDirectory__resultOutputDirectory = os.path.join(tempfile.gettempdir(), "TestCenter")
    self.__xmlResultFileName__xmlResultFileName  = "tc_result.xml"
    self.__MLABSlaveLogFileName__MLABSlaveLogFileName = "mevislab_slave.log"
    self.__defaultTestTimeoutSeconds__defaultTestTimeoutSeconds = 20
    # Number of TestCases after which MLAB is restarted during the execution of multiple
    # tests. If this is set to zero, MLAB is not restarted at all.
    self.__mMLABRestartInterval__mMLABRestartInterval = 1
    # If a test is configured with a timeout above this value, do not execute it and let it fail.
    self.__maxTestTimeoutSeconds__maxTestTimeoutSeconds = 0
    
    self.__shouldReloadPythonModulesWhenReloadingTestCases__shouldReloadPythonModulesWhenReloadingTestCases = True
 
    self.__usePythonCoverage__usePythonCoverage = False
    # Controls if the python coverage measured during the execution of tests is accumulated
    # into one report (True) or if for every test a separate report is generated (False).
    self.__useGlobalPythonCoverage__useGlobalPythonCoverage = False
    # All files matching one of these expressions
    # are excluded from the coverage for that test run.
    exclusionExpressions = ["*/TestSupport/*",
                            "*/TestCenterAdvanced/*",
                            "*/MLABPythonTools/*",
                            "*/*.script*",
                            "*/*.def*",
                            "*/IDE/mevislabInternal.py",
                            "*/__mevislab_bootstrap_importlib.py",
                            "*/Standard/Modules/Scripts/python/PackageSorter.py",
                            "*/BuildTools/Scripts/MeVisPython.py",
                            "*/@@scriptconsole*",
                            "*$*"]
 
    #convert to native path format
    self.__pythonCoverageExclusionExpressions__pythonCoverageExclusionExpressions = [
      os.path.normpath(expression) for expression in exclusionExpressions
    ]
 
    # C++ coverage tool
    self.__useBullseyeCoverage__useBullseyeCoverage = False
    
    self.__ipcConnectionTimeout__ipcConnectionTimeout = 2
 
    self.__report__report = ReportConfig()
 
 
  
  def __load (self, filename):
    if not os.path.isfile(filename):
      raise Exception("Given file does not exist: %s" % (filename))
 
    xmlTree = etree.parse(filename)
    xmlRoot = xmlTree.getroot()
 
    self.fetchMLABSettingsfetchMLABSettings(xmlRoot)
    self.fetchReportSettingsfetchReportSettings(xmlRoot)
    self.fetchCoverageSettingsfetchCoverageSettings(xmlRoot)
    self.fetchTestCaseManagerSettingsfetchTestCaseManagerSettings(xmlRoot)
    self.fetchIPCSettingsfetchIPCSettings(xmlRoot)
 
 
  @staticmethod
  def nodeHasValidText(node):
    return node is not None and node.text is not None
 
 
  def fetchMLABSettings(self, xmlRoot):
    node = xmlRoot.find("mlab/usecurrent")
    if self.nodeHasValidTextnodeHasValidText(node):
      self.__MLABUseCurrent__MLABUseCurrent = node.text.lower() in ["true", "1", "yes", "on"]
    else:
      self.__MLABUseCurrent__MLABUseCurrent = True
 
    node = xmlRoot.find("mlab/executable")
    if self.nodeHasValidTextnodeHasValidText(node):
      self.__MLABExecutablePath__MLABExecutablePath = node.text
 
    if node is not None:
      mode = node.get("compilemode")
      if mode:
        self.__MLABCompileMode__MLABCompileMode = mode
      elif node.get("usedebug") == "True":
        self.__MLABCompileMode__MLABCompileMode = "Debug"
      else:
        self.__MLABCompileMode__MLABCompileMode = "Automatic"
 
    node = xmlRoot.find("mlab/arguments")
    if self.nodeHasValidTextnodeHasValidText(node):
      self.__MLABArguments__MLABArguments = node.text.split(",")
 
    node = xmlRoot.find("mlab/resultdir")
    if self.nodeHasValidTextnodeHasValidText(node):
      self.__resultOutputDirectory__resultOutputDirectory = node.text
 
    node = xmlRoot.find("mlab/resultfile")
    if self.nodeHasValidTextnodeHasValidText(node):
      self.__xmlResultFileName__xmlResultFileName = node.text
 
    node = xmlRoot.find("mlab/slavelogfile")
    if self.nodeHasValidTextnodeHasValidText(node):
      self.__MLABSlaveLogFileName__MLABSlaveLogFileName = node.text
 
    node = xmlRoot.find("mlab/timeout")
    if self.nodeHasValidTextnodeHasValidText(node):
      self.__defaultTestTimeoutSeconds__defaultTestTimeoutSeconds = int(node.text)
 
    node = xmlRoot.find("mlab/restartinterval")
    if self.nodeHasValidTextnodeHasValidText(node):
      self.__mMLABRestartInterval__mMLABRestartInterval = int(node.text)
 
    node = xmlRoot.find("mlab/MaximumTestTimeout")
    if self.nodeHasValidTextnodeHasValidText(node):
      self.__maxTestTimeoutSeconds__maxTestTimeoutSeconds = int(node.text)
 
 
  def fetchReportSettings(self, xmlRoot):
    self.fetchReportNodeSettingsfetchReportNodeSettings(xmlRoot)
 
    node = xmlRoot.find("report/directory")
    if self.nodeHasValidTextnodeHasValidText(node):
      self.__report__report.directory = node.text
 
    node = xmlRoot.find("report/name")
    if self.nodeHasValidTextnodeHasValidText(node):
      self.__report__report.name = node.text
 
    node = xmlRoot.find("report/timestamp")
    if self.nodeHasValidTextnodeHasValidText(node):
      self.__report__report.timestampTemplate = node.text
 
 
  def fetchReportNodeSettings(self, xmlRoot):
    reportNode = xmlRoot.find("report")
    if not reportNode is None:
      self.__report__report.appendTestCaseName = self.getBooleangetBoolean(reportNode,
                                                         self.__report__report.appendTestCaseName,
                                                         "appendTestCaseName")
      self.__report__report.appendTimestamp = self.getBooleangetBoolean(reportNode,
                                                      self.__report__report.appendTimestamp,
                                                      "appendTimestamp")
      self.__report__report.collapseFunctions = self.getBooleangetBoolean(reportNode,
                                                        self.__report__report.collapseFunctions,
                                                        "collapseFunctions")
      self.__report__report.showFailedFunctionsOnly = self.getBooleangetBoolean(reportNode,
                                                              self.__report__report.showFailedFunctionsOnly,
                                                              "showFailedOnly")
      self.__report__report.hideInfoMessages = self.getBooleangetBoolean(reportNode,
                                                       self.__report__report.hideInfoMessages,
                                                       "hideInfos")
      self.__report__report.hideSystemMessages = self.getBooleangetBoolean(reportNode,
                                                         self.__report__report.hideSystemMessages,
                                                         "hideSystemMessages")
      self.__report__report.maxInfoMessagesPerTestFunction = self.getIntegergetInteger(reportNode,
                                                         self.__report__report.maxInfoMessagesPerTestFunction,
                                                         "maxInfoMessagesPerTestFunction")
      self.__report__report.maxErrorMessagesPerTestFunction = self.getIntegergetInteger(reportNode,
                                                         self.__report__report.maxErrorMessagesPerTestFunction,
                                                         "maxErrorMessagesPerTestFunction")
 
  @staticmethod
  def getBoolean(node, default, attributeName):
      boolean = default
 
      attributeValue = node.get(attributeName)
      if attributeValue is not None:
        boolean = attributeValue == "True"
 
      return boolean
    
  @staticmethod
  def getInteger(node, default, attributeName):
      result = default
 
      attributeValue = node.get(attributeName)
      if attributeValue is not None:
        try:
          result = int(attributeValue)
        except:
          print("Error: Can't parse %s with value %s as int." % (attributeName, attributeValue))
      return result
 
  def fetchTestCaseManagerSettings(self, xmlRoot):
    node = xmlRoot.find("TestCaseManager")
    if not node is None:
      b = self.getBooleangetBoolean(node, True, "reloadPythonModulesBeforeTestExecution")
      self.__shouldReloadPythonModulesWhenReloadingTestCases__shouldReloadPythonModulesWhenReloadingTestCases = b
      
  def storeTestCaseManagerSettings(self, xmlRoot):
    node = etree.SubElement(xmlRoot, "TestCaseManager")
    node.set("reloadPythonModulesBeforeTestExecution", str(self.__shouldReloadPythonModulesWhenReloadingTestCases__shouldReloadPythonModulesWhenReloadingTestCases))
 
 
  def fetchCoverageSettings(self, xmlRoot):
    coverageNode = xmlRoot.find("Coverage")
    if not coverageNode is None:
      self.fetchBullseyeCoverageSettingsfetchBullseyeCoverageSettings(coverageNode)
      self.fetchPythonCoverageSettingsfetchPythonCoverageSettings(coverageNode)
 
  def fetchBullseyeCoverageSettings(self, coverageNode):
    bullseyeNode = coverageNode.find("Bullseye")
    if bullseyeNode is not None:
      self.fetchUseBullseyeCoveragefetchUseBullseyeCoverage(bullseyeNode)
 
  def fetchUseBullseyeCoverage(self, bullseyeNode):
    self.__useBullseyeCoverage__useBullseyeCoverage = self.getBooleangetBoolean(bullseyeNode,
                                                 self.__useBullseyeCoverage__useBullseyeCoverage,
                                                 "enabled")
 
  def fetchPythonCoverageSettings(self, coverageNode):
    pythonCoverageNode = coverageNode.find("Python")
    if pythonCoverageNode is not None:
      self.fetchUsePythonCoveragefetchUsePythonCoverage(pythonCoverageNode)
      self.fetchUseGlobalPythonCoveragefetchUseGlobalPythonCoverage(pythonCoverageNode)
      self.fetchPythonCoverageExclusionExpressionsfetchPythonCoverageExclusionExpressions(pythonCoverageNode)
 
  def fetchUsePythonCoverage(self, pythonCoverageNode):
    self.__usePythonCoverage__usePythonCoverage = self.getBooleangetBoolean(pythonCoverageNode,
                                               self.__usePythonCoverage__usePythonCoverage,
                                               "enabled")
 
  def fetchUseGlobalPythonCoverage(self, pythonCoverageNode):
    self.__useGlobalPythonCoverage__useGlobalPythonCoverage = self.getBooleangetBoolean(pythonCoverageNode,
                                                     self.__useGlobalPythonCoverage__useGlobalPythonCoverage,
                                                     "global")
 
 
  def fetchPythonCoverageExclusionExpressions(self, coverageNode):
    default = set(self.__pythonCoverageExclusionExpressions__pythonCoverageExclusionExpressions)
    loaded = set([expression.text for expression in coverageNode.findall("ExclusionExpression")])
    #build union of default and loaded expressions using set type
    self.__pythonCoverageExclusionExpressions__pythonCoverageExclusionExpressions = list(default | loaded)
    #replace forward slashes with system default
    self.__pythonCoverageExclusionExpressions__pythonCoverageExclusionExpressions = [os.path.normpath(expression)
                                                   for expression in self.__pythonCoverageExclusionExpressions__pythonCoverageExclusionExpressions]
    
  def fetchIPCSettings(self, xmlRoot):
    node = xmlRoot.find("IPCConnectionTimeout")
    if self.nodeHasValidTextnodeHasValidText(node):
      self.__ipcConnectionTimeout__ipcConnectionTimeout = int(node.text)
 
  
  def save (self, filename = None):
    xmlRoot  = etree.Element("Configuration")
    xmlTree  = etree.ElementTree(xmlRoot)
 
    mlabNode = etree.SubElement(xmlRoot, "mlab")
 
    etree.SubElement(mlabNode, "slavelogfile").text = self.__MLABSlaveLogFileName__MLABSlaveLogFileName
    etree.SubElement(mlabNode, "usecurrent").text = "True" if self.__MLABUseCurrent__MLABUseCurrent else "False"
    node = etree.SubElement(mlabNode, "executable")
    node.set("compilemode", self.__MLABCompileMode__MLABCompileMode)
    node.text = self.__MLABExecutablePath__MLABExecutablePath
    etree.SubElement(mlabNode, "arguments").text = ",".join(self.__MLABArguments__MLABArguments)
    etree.SubElement(mlabNode, "resultdir").text = self.__resultOutputDirectory__resultOutputDirectory
    etree.SubElement(mlabNode, "resultfile").text = self.__xmlResultFileName__xmlResultFileName
    etree.SubElement(mlabNode, "timeout").text = str(self.__defaultTestTimeoutSeconds__defaultTestTimeoutSeconds)
    etree.SubElement(mlabNode, "MaximumTestTimeout").text = str(self.__maxTestTimeoutSeconds__maxTestTimeoutSeconds)
    etree.SubElement(mlabNode, "restartinterval").text = str(self.__mMLABRestartInterval__mMLABRestartInterval)
 
    reportNode = etree.SubElement(xmlRoot, "report")
 
    etree.SubElement(reportNode, "directory").text = self.__report__report.directory
    etree.SubElement(reportNode, "name").text = self.__report__report.name
    etree.SubElement(reportNode, "timestamp").text = self.__report__report.timestampTemplate
 
    reportNode.set("appendTestCaseName", unicode(self.__report__report.appendTestCaseName))
    reportNode.set("appendTimestamp", unicode(self.__report__report.appendTimestamp))
    reportNode.set("collapseFunctions",  unicode(self.__report__report.collapseFunctions))
    reportNode.set("showFailedOnly", unicode(self.__report__report.showFailedFunctionsOnly))
    reportNode.set("hideInfos", unicode(self.__report__report.hideInfoMessages))
    reportNode.set("hideSystemMessages", unicode(self.__report__report.hideSystemMessages))
    reportNode.set("maxErrorMessagesPerTestFunction", unicode(self.__report__report.maxErrorMessagesPerTestFunction))
    reportNode.set("maxInfoMessagesPerTestFunction", unicode(self.__report__report.maxInfoMessagesPerTestFunction))
 
    coverageNode =  etree.SubElement(xmlRoot, "Coverage")
 
    pythonCoverageNode = etree.SubElement(coverageNode, "Python")
    pythonCoverageNode.set("enabled", str(self.__usePythonCoverage__usePythonCoverage))
    pythonCoverageNode.set("global", str(self.__useGlobalPythonCoverage__useGlobalPythonCoverage))
 
    for expression in self.__pythonCoverageExclusionExpressions__pythonCoverageExclusionExpressions:
      etree.SubElement(pythonCoverageNode, "ExclusionExpression").text = expression
 
    bullseNode = etree.SubElement(coverageNode, "Bullseye")
    bullseNode.set("enabled", str(self.__useBullseyeCoverage__useBullseyeCoverage))
    
    ipcConnectionTimeoutNode = etree.SubElement(xmlRoot, "IPCConnectionTimeout")
    ipcConnectionTimeoutNode.text = str(self.__ipcConnectionTimeout__ipcConnectionTimeout)
    
    self.storeTestCaseManagerSettingsstoreTestCaseManagerSettings(xmlRoot)
 
    Utils.indentXML(xmlRoot)
 
    if filename == None:
      filename = self.__configFilePath__configFilePath
 
    try:
      xmlTree.write(filename)
    except Exception as e:
      mevis.MLAB.logWarningHTML("Unable to write config file: %s.\n%s" % (filename, e))
 
 
  def getSlaveLogFilePath (self):
    return os.path.join(self.__resultOutputDirectory__resultOutputDirectory, self.__MLABSlaveLogFileName__MLABSlaveLogFileName)
 
 
  def setResultDir (self, directory):
    self.__resultOutputDirectory__resultOutputDirectory = directory
 
 
  def getResultDir (self):
    return self.__resultOutputDirectory__resultOutputDirectory
 
 
  def getResultFile (self):
    return os.path.join(self.__resultOutputDirectory__resultOutputDirectory, self.__xmlResultFileName__xmlResultFileName)
 
 
  def getMLABCurrentBinariesPath (self):
    return self.__MLABCurrentExecutablePath__MLABCurrentExecutablePath
 
 
  def getMLABBinariesPath (self):
    return os.path.expandvars(self.__MLABExecutablePath__MLABExecutablePath)
 
 
  def getMLABUseCurrent (self):
    return self.__MLABUseCurrent__MLABUseCurrent
 
 
  def getMLABEffectiveBinariesPath (self):
    return self.getMLABCurrentBinariesPathgetMLABCurrentBinariesPath() if self.getMLABUseCurrentgetMLABUseCurrent() else self.getMLABBinariesPathgetMLABBinariesPath()
 
 
  @staticmethod
  def findMLABExecutable(basePath, executableName, subPath):
    """
    Searches for the executable in the basePath and all levels of the provided
    subPath in a 'deepest first' manner
    """
    path = os.path.normpath(subPath)
    pathComponents = path.split(os.sep)
    pathComponents.append(executableName)
 
    executablePath = None
    while pathComponents:
      candidate = os.path.join(basePath, *pathComponents)
      if os.path.isfile(candidate):
        executablePath = candidate
        break
 
      pathComponents.pop(0)
 
    if executablePath is None:
      raise MLABExecutableNotFoundException()
 
    return os.path.normpath(candidate)
 
 
  def getMLABExecutableCommand (self):
    expandedMLABPath = self.getMLABEffectiveBinariesPathgetMLABEffectiveBinariesPath()
    if not Utils.isMac:
      mlabExecutableName = "MeVisLab_d" if self.useMLABDebugVersionuseMLABDebugVersion() else "MeVisLab"
      if Utils.isWindows:
        mlabExecutableName += ".exe"
 
      command = [self.findMLABExecutablefindMLABExecutable(expandedMLABPath, mlabExecutableName, "Packages/MeVisLab/IDE/bin" if Utils.isWindows else "bin")]
    else:
      executablePath = self.findMLABExecutablefindMLABExecutable(expandedMLABPath, "MeVisLab", "Contents/MacOS")
      command = [executablePath, "-debug" if self.useMLABDebugVersionuseMLABDebugVersion() else "-release"]
 
    return command
 
 
  def getMLABArguments (self):
    return self.__MLABArguments__MLABArguments
 
 
  def getMLABCompileMode (self):
    return self.__MLABCompileMode__MLABCompileMode
 
 
  def useMLABDebugVersion (self):
    if self.__MLABCompileMode__MLABCompileMode == "Debug":
      return True
    elif self.__MLABCompileMode__MLABCompileMode == "Release":
      return False
    else:
      return mevisAvailable and mevis.MLAB.isDebug()
    
  def setMLABUseDebug (self, useDebug):
    if useDebug:
      self.__MLABCompileMode__MLABCompileMode = "Debug"
    else:
      self.__MLABCompileMode__MLABCompileMode = "Release"
 
 
  def shouldReloadPythonModulesWhenReloadingTestCases(self):
    return self.__shouldReloadPythonModulesWhenReloadingTestCases__shouldReloadPythonModulesWhenReloadingTestCases
  
  def setTestCaseManagerOptions(self, shouldReloadPythonModulesWhenReloadingTestCases):
    self.__shouldReloadPythonModulesWhenReloadingTestCases__shouldReloadPythonModulesWhenReloadingTestCases = shouldReloadPythonModulesWhenReloadingTestCases
    
 
  def getMLABTestCenterCommand (self, macroName):
    return (  self.getMLABExecutableCommandgetMLABExecutableCommand()
            + self.getMLABArgumentsgetMLABArguments()
            + ['-nomateconnection', '-runmacro', macroName, '-c', self.__configFilePath__configFilePath])
 
 
  def setMLABExecutablePath (self, executablePath):
    if executablePath:
      self.__MLABExecutablePath__MLABExecutablePath = executablePath
 
 
  def setMLABUseCurrent (self, usecurrent):
    self.__MLABUseCurrent__MLABUseCurrent = usecurrent
 
 
  def setMLABArguments (self, arguments):
    self.__MLABArguments__MLABArguments = arguments
 
 
  def setMLABCompileMode (self, value):
    self.__MLABCompileMode__MLABCompileMode = value
 
 
  def getDefaultTestTimeoutSeconds (self):
    return self.__defaultTestTimeoutSeconds__defaultTestTimeoutSeconds
 
 
  def getConfigFilePath (self):
    return self.__configFilePath__configFilePath
 
  @deprecated
  def getConfigFile(self):
    return getConfigFilePath()
 
  def getReportOptions(self):
      return self.__report__report
 
  def setReportOptions (self,
                        directory,
                        name,
                        timestampTemplate,
                        appendTestCaseName,
                        appendTimestamp,
                        collapseFunctions,
                        showFailedFunctionsOnly,
                        hideInfoMessages,
                        hideSystemMessages):
    self.__report__report = ReportConfig(directory,
                                 name,
                                 timestampTemplate,
                                 appendTestCaseName,
                                 appendTimestamp,
                                 collapseFunctions,
                                 showFailedFunctionsOnly,
                                 hideInfoMessages,
                                 hideSystemMessages)
 
  def getReportDirectory (self):
    return self.__report__report.directory
 
 
  def getReportName (self):
    return self.__report__report.name
 
 
  def getReportTimestampTemplate (self):
    return self.__report__report.timestampTemplate
 
 
  def appendTestCaseNameToReportName (self):
    return self.__report__report.appendTestCaseName
 
 
  def appendTimestampToReportName (self):
    return self.__report__report.appendTimestamp
 
 
  def collapseFunctions (self):
    return self.__report__report.collapseFunctions
 
 
  def showFailedFunctionsOnly (self):
    return self.__report__report.showFailedFunctionsOnly
 
 
  def hideInfoMessages (self):
    return self.__report__report.hideInfoMessages
 
 
  def hideSystemMessages (self):
    return self.__report__report.hideSystemMessages
 
 
  def getCoverageExclusions(self):
    return self.__pythonCoverageExclusionExpressions__pythonCoverageExclusionExpressions
 
 
  def isPythonCoverageEnabled(self):
    return self.__usePythonCoverage__usePythonCoverage
 
 
  def isGlobalPythonCoverageEnabled(self):
    return self.__useGlobalPythonCoverage__useGlobalPythonCoverage
 
 
  def setPythonCoverageEnabled (self, value):
    self.__usePythonCoverage__usePythonCoverage = True if value else False
 
 
  def setGlobalPythonCoverageEnabled (self, value):
    self.__useGlobalPythonCoverage__useGlobalPythonCoverage = True if value else False
 
 
  def isBullseyeCoverageEnabled(self):
    return self.__useBullseyeCoverage__useBullseyeCoverage
 
 
  def setBullseyeCoverageEnabled (self, value):
    self.__useBullseyeCoverage__useBullseyeCoverage = True if value else False
 
 
  def getRestartInterval(self):
    return self.__mMLABRestartInterval__mMLABRestartInterval
 
 
  def getMaxTestTimeoutSeconds(self):
    return self.__maxTestTimeoutSeconds__maxTestTimeoutSeconds
  
  def getIPCConnectionTimeout(self):
    return self.__ipcConnectionTimeout__ipcConnectionTimeout