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.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:
  def getReportDir():  # @NoSelf
    reportDir = ""
    if Utils.isWindows:
      reportDir = os.path.join(os.getenv("USERPROFILE"), "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.directory = directory
      self.name = name
      self.timestampTemplate = timestampTemplate
      self.appendTestCaseName = appendTestCaseName
      self.appendTimestamp = appendTimestamp
      self.collapseFunctions = collapseFunctions
      self.showFailedFunctionsOnly = showFailedFuctionsOnly
      self.hideInfoMessages = hideInfoMessages
      self.hideSystemMessages = hideSystemMessages
      self.maxErrorMessagesPerTestFunction = 1000
      self.maxInfoMessagesPerTestFunction = 1000
 
class Configuration :
  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()
 
    # 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(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.save(filePath)
 
    self.__configFilePath = os.path.abspath(filePath)
 
  
  def __setDefaultValues (self):
    def getArguments():
      return ["-nosplash", "-noide", "-quick"]
 
    def getMLABBinariesPath():
      executablePath = ""
      if mevisAvailable:
        if Utils.isWindows:
          executablePath = os.path.dirname(mevis.MLABFileManager.getExecutable("MeVisLab"))
        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.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 = getMLABBinariesPath()
    self.__MLABExecutablePath = self.__MLABCurrentExecutablePath
    self.__MLABUseCurrent = True
    self.__MLABArguments = getArguments()
    self.__MLABCompileMode = "Automatic"
    self.__resultOutputDirectory = os.path.join(tempfile.gettempdir(), "TestCenter")
    self.__xmlResultFileName  = "tc_result.xml"
    self.__MLABSlaveLogFileName = "mevislab_slave.log"
    self.__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 = 1
    # If a test is configured with a timeout above this value, do not execute it and let it fail.
    self.__maxTestTimeoutSeconds = 0
    
    self.__shouldReloadPythonModulesWhenReloadingTestCases = True
 
    self.__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 = 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*",
                            "*/site-packages/*",
                            "*$*"]
 
    #convert to native path format
    self.__pythonCoverageExclusionExpressions = [
      os.path.normpath(expression) for expression in exclusionExpressions
    ]
    
    self.__pythonCoverageInclusionExpressions = []
 
    # C++ coverage tool
    self.__useBullseyeCoverage = False
    
    self.__ipcConnectionTimeout = 2
 
    self.__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.fetchMLABSettings(xmlRoot)
    self.fetchReportSettings(xmlRoot)
    self.fetchCoverageSettings(xmlRoot)
    self.fetchTestCaseManagerSettings(xmlRoot)
    self.fetchIPCSettings(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.nodeHasValidText(node):
      self.__MLABUseCurrent = node.text.lower() in ["true", "1", "yes", "on"]
    else:
      self.__MLABUseCurrent = True
 
    node = xmlRoot.find("mlab/executable")
    if self.nodeHasValidText(node):
      self.__MLABExecutablePath = node.text
 
    if node is not None:
      mode = node.get("compilemode")
      if mode:
        self.__MLABCompileMode = mode
      elif node.get("usedebug") == "True":
        self.__MLABCompileMode = "Debug"
      else:
        self.__MLABCompileMode = "Automatic"
 
    node = xmlRoot.find("mlab/arguments")
    if self.nodeHasValidText(node):
      self.__MLABArguments = node.text.split(",")
 
    node = xmlRoot.find("mlab/resultdir")
    if self.nodeHasValidText(node):
      self.__resultOutputDirectory = node.text
 
    node = xmlRoot.find("mlab/resultfile")
    if self.nodeHasValidText(node):
      self.__xmlResultFileName = node.text
 
    node = xmlRoot.find("mlab/slavelogfile")
    if self.nodeHasValidText(node):
      self.__MLABSlaveLogFileName = node.text
 
    node = xmlRoot.find("mlab/timeout")
    if self.nodeHasValidText(node):
      self.__defaultTestTimeoutSeconds = int(node.text)
 
    node = xmlRoot.find("mlab/restartinterval")
    if self.nodeHasValidText(node):
      self.__mMLABRestartInterval = int(node.text)
 
    node = xmlRoot.find("mlab/MaximumTestTimeout")
    if self.nodeHasValidText(node):
      self.__maxTestTimeoutSeconds = int(node.text)
 
 
  def fetchReportSettings(self, xmlRoot):
    self.fetchReportNodeSettings(xmlRoot)
 
    node = xmlRoot.find("report/directory")
    if self.nodeHasValidText(node):
      self.__report.directory = node.text
 
    node = xmlRoot.find("report/name")
    if self.nodeHasValidText(node):
      self.__report.name = node.text
 
    node = xmlRoot.find("report/timestamp")
    if self.nodeHasValidText(node):
      self.__report.timestampTemplate = node.text
 
 
  def fetchReportNodeSettings(self, xmlRoot):
    reportNode = xmlRoot.find("report")
    if not reportNode is None:
      self.__report.appendTestCaseName = self.getBoolean(reportNode,
                                                         self.__report.appendTestCaseName,
                                                         "appendTestCaseName")
      self.__report.appendTimestamp = self.getBoolean(reportNode,
                                                      self.__report.appendTimestamp,
                                                      "appendTimestamp")
      self.__report.collapseFunctions = self.getBoolean(reportNode,
                                                        self.__report.collapseFunctions,
                                                        "collapseFunctions")
      self.__report.showFailedFunctionsOnly = self.getBoolean(reportNode,
                                                              self.__report.showFailedFunctionsOnly,
                                                              "showFailedOnly")
      self.__report.hideInfoMessages = self.getBoolean(reportNode,
                                                       self.__report.hideInfoMessages,
                                                       "hideInfos")
      self.__report.hideSystemMessages = self.getBoolean(reportNode,
                                                         self.__report.hideSystemMessages,
                                                         "hideSystemMessages")
      self.__report.maxInfoMessagesPerTestFunction = self.getInteger(reportNode,
                                                         self.__report.maxInfoMessagesPerTestFunction,
                                                         "maxInfoMessagesPerTestFunction")
      self.__report.maxErrorMessagesPerTestFunction = self.getInteger(reportNode,
                                                         self.__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.getBoolean(node, True, "reloadPythonModulesBeforeTestExecution")
      self.__shouldReloadPythonModulesWhenReloadingTestCases = b
      
  def storeTestCaseManagerSettings(self, xmlRoot):
    node = etree.SubElement(xmlRoot, "TestCaseManager")
    node.set("reloadPythonModulesBeforeTestExecution", str(self.__shouldReloadPythonModulesWhenReloadingTestCases))
 
 
  def fetchCoverageSettings(self, xmlRoot):
    coverageNode = xmlRoot.find("Coverage")
    if not coverageNode is None:
      self.fetchBullseyeCoverageSettings(coverageNode)
      self.fetchPythonCoverageSettings(coverageNode)
 
  def fetchBullseyeCoverageSettings(self, coverageNode):
    bullseyeNode = coverageNode.find("Bullseye")
    if bullseyeNode is not None:
      self.fetchUseBullseyeCoverage(bullseyeNode)
 
  def fetchUseBullseyeCoverage(self, bullseyeNode):
    self.__useBullseyeCoverage = self.getBoolean(bullseyeNode,
                                                 self.__useBullseyeCoverage,
                                                 "enabled")
 
  def fetchPythonCoverageSettings(self, coverageNode):
    pythonCoverageNode = coverageNode.find("Python")
    if pythonCoverageNode is not None:
      self.fetchUsePythonCoverage(pythonCoverageNode)
      self.fetchUseGlobalPythonCoverage(pythonCoverageNode)
      self.fetchPythonCoverageExclusionExpressions(pythonCoverageNode)
      self.fetchPythonCoverageInclusionExpressions(pythonCoverageNode)
 
  def fetchUsePythonCoverage(self, pythonCoverageNode):
    self.__usePythonCoverage = self.getBoolean(pythonCoverageNode,
                                               self.__usePythonCoverage,
                                               "enabled")
 
  def fetchUseGlobalPythonCoverage(self, pythonCoverageNode):
    self.__useGlobalPythonCoverage = self.getBoolean(pythonCoverageNode,
                                                     self.__useGlobalPythonCoverage,
                                                     "global")
 
 
  def fetchPythonCoverageExclusionExpressions(self, coverageNode):
    default = set(self.__pythonCoverageExclusionExpressions)
    loaded = set([expression.text for expression in coverageNode.findall("ExclusionExpression")])
    #build union of default and loaded expressions using set type
    self.__pythonCoverageExclusionExpressions = list(default | loaded)
    #replace forward slashes with system default
    self.__pythonCoverageExclusionExpressions = [os.path.normpath(expression)
                                                   for expression in self.__pythonCoverageExclusionExpressions]
 
  def fetchPythonCoverageInclusionExpressions(self, coverageNode):
    default = set(self.__pythonCoverageInclusionExpressions)
    loaded = set([expression.text for expression in coverageNode.findall("InclusionExpression")])
    #build union of default and loaded expressions using set type
    self.__pythonCoverageInclusionExpressions = list(default | loaded)
    #replace forward slashes with system default
    self.__pythonCoverageInclusionExpressions = [os.path.normpath(expression)
                                                   for expression in self.__pythonCoverageInclusionExpressions]
    
  def fetchIPCSettings(self, xmlRoot):
    node = xmlRoot.find("IPCConnectionTimeout")
    if self.nodeHasValidText(node):
      self.__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
    etree.SubElement(mlabNode, "usecurrent").text = "True" if self.__MLABUseCurrent else "False"
    node = etree.SubElement(mlabNode, "executable")
    node.set("compilemode", self.__MLABCompileMode)
    node.text = self.__MLABExecutablePath
    etree.SubElement(mlabNode, "arguments").text = ",".join(self.__MLABArguments)
    etree.SubElement(mlabNode, "resultdir").text = self.__resultOutputDirectory
    etree.SubElement(mlabNode, "resultfile").text = self.__xmlResultFileName
    etree.SubElement(mlabNode, "timeout").text = str(self.__defaultTestTimeoutSeconds)
    etree.SubElement(mlabNode, "MaximumTestTimeout").text = str(self.__maxTestTimeoutSeconds)
    etree.SubElement(mlabNode, "restartinterval").text = str(self.__mMLABRestartInterval)
 
    reportNode = etree.SubElement(xmlRoot, "report")
 
    etree.SubElement(reportNode, "directory").text = self.__report.directory
    etree.SubElement(reportNode, "name").text = self.__report.name
    etree.SubElement(reportNode, "timestamp").text = self.__report.timestampTemplate
 
    reportNode.set("appendTestCaseName", unicode(self.__report.appendTestCaseName))
    reportNode.set("appendTimestamp", unicode(self.__report.appendTimestamp))
    reportNode.set("collapseFunctions",  unicode(self.__report.collapseFunctions))
    reportNode.set("showFailedOnly", unicode(self.__report.showFailedFunctionsOnly))
    reportNode.set("hideInfos", unicode(self.__report.hideInfoMessages))
    reportNode.set("hideSystemMessages", unicode(self.__report.hideSystemMessages))
    reportNode.set("maxErrorMessagesPerTestFunction", unicode(self.__report.maxErrorMessagesPerTestFunction))
    reportNode.set("maxInfoMessagesPerTestFunction", unicode(self.__report.maxInfoMessagesPerTestFunction))
 
    coverageNode =  etree.SubElement(xmlRoot, "Coverage")
 
    pythonCoverageNode = etree.SubElement(coverageNode, "Python")
    pythonCoverageNode.set("enabled", str(self.__usePythonCoverage))
    pythonCoverageNode.set("global", str(self.__useGlobalPythonCoverage))
 
    for expression in self.__pythonCoverageExclusionExpressions:
      etree.SubElement(pythonCoverageNode, "ExclusionExpression").text = expression
      
    for expression in self.__pythonCoverageInclusionExpressions:
      etree.SubElement(pythonCoverageNode, "InclusionExpression").text = expression
 
    bullseNode = etree.SubElement(coverageNode, "Bullseye")
    bullseNode.set("enabled", str(self.__useBullseyeCoverage))
    
    ipcConnectionTimeoutNode = etree.SubElement(xmlRoot, "IPCConnectionTimeout")
    ipcConnectionTimeoutNode.text = str(self.__ipcConnectionTimeout)
    
    self.storeTestCaseManagerSettings(xmlRoot)
 
    Utils.indentXML(xmlRoot)
 
    if filename == None:
      filename = self.__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, self.__MLABSlaveLogFileName)
 
 
  def setResultDir (self, directory):
    self.__resultOutputDirectory = directory
 
 
  def getResultDir (self):
    return self.__resultOutputDirectory
 
 
  def getResultFile (self):
    return os.path.join(self.__resultOutputDirectory, self.__xmlResultFileName)
 
 
  def getMLABCurrentBinariesPath (self):
    return self.__MLABCurrentExecutablePath
 
 
  def getMLABBinariesPath (self):
    return os.path.expandvars(self.__MLABExecutablePath)
 
 
  def getMLABUseCurrent (self):
    return self.__MLABUseCurrent
 
 
  def getMLABEffectiveBinariesPath (self):
    return self.getMLABCurrentBinariesPath() if self.getMLABUseCurrent() else self.getMLABBinariesPath()
 
 
  @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.getMLABEffectiveBinariesPath()
    mlabExecutableName = "MeVisLab_d" if self.useMLABDebugVersion() else "MeVisLab"
    if Utils.isWindows:
      mlabExecutableName += ".exe"
 
    command = [self.findMLABExecutable(expandedMLABPath, mlabExecutableName, "Packages/MeVisLab/IDE/bin" if Utils.isWindows else "bin")]
 
    return command
 
 
  def getMLABArguments (self):
    return self.__MLABArguments
 
 
  def getMLABCompileMode (self):
    return self.__MLABCompileMode
 
 
  def useMLABDebugVersion (self):
    if self.__MLABCompileMode == "Debug":
      return True
    elif self.__MLABCompileMode == "Release":
      return False
    else:
      return mevisAvailable and mevis.MLAB.isDebug()
    
  def setMLABUseDebug (self, useDebug):
    if useDebug:
      self.__MLABCompileMode = "Debug"
    else:
      self.__MLABCompileMode = "Release"
 
 
  def shouldReloadPythonModulesWhenReloadingTestCases(self):
    return self.__shouldReloadPythonModulesWhenReloadingTestCases
  
  def setTestCaseManagerOptions(self, shouldReloadPythonModulesWhenReloadingTestCases):
    self.__shouldReloadPythonModulesWhenReloadingTestCases = shouldReloadPythonModulesWhenReloadingTestCases
    
 
  def getMLABTestCenterCommand (self, macroName):
    return (  self.getMLABExecutableCommand()
            + self.getMLABArguments()
            + ['-nomateconnection', '-runmacro', macroName, '-c', self.__configFilePath])
 
 
  def setMLABExecutablePath (self, executablePath):
    if executablePath:
      self.__MLABExecutablePath = executablePath
 
 
  def setMLABUseCurrent (self, usecurrent):
    self.__MLABUseCurrent = usecurrent
 
 
  def setMLABArguments (self, arguments):
    self.__MLABArguments = arguments
 
 
  def setMLABCompileMode (self, value):
    self.__MLABCompileMode = value
 
 
  def getDefaultTestTimeoutSeconds (self):
    return self.__defaultTestTimeoutSeconds
 
 
  def getConfigFilePath (self):
    return self.__configFilePath
 
  def getReportOptions(self):
      return self.__report
 
  def setReportOptions (self,
                        directory,
                        name,
                        timestampTemplate,
                        appendTestCaseName,
                        appendTimestamp,
                        collapseFunctions,
                        showFailedFunctionsOnly,
                        hideInfoMessages,
                        hideSystemMessages):
    self.__report = ReportConfig(directory,
                                 name,
                                 timestampTemplate,
                                 appendTestCaseName,
                                 appendTimestamp,
                                 collapseFunctions,
                                 showFailedFunctionsOnly,
                                 hideInfoMessages,
                                 hideSystemMessages)
 
  def getReportDirectory (self):
    return self.__report.directory
 
 
  def getReportName (self):
    return self.__report.name
 
 
  def getReportTimestampTemplate (self):
    return self.__report.timestampTemplate
 
 
  def appendTestCaseNameToReportName (self):
    return self.__report.appendTestCaseName
 
 
  def appendTimestampToReportName (self):
    return self.__report.appendTimestamp
 
 
  def collapseFunctions (self):
    return self.__report.collapseFunctions
 
 
  def showFailedFunctionsOnly (self):
    return self.__report.showFailedFunctionsOnly
 
 
  def hideInfoMessages (self):
    return self.__report.hideInfoMessages
 
 
  def hideSystemMessages (self):
    return self.__report.hideSystemMessages
 
 
  def getCoverageExclusions(self):
    return self.__pythonCoverageExclusionExpressions
    
  def getCoverageInclusions(self):
    return self.__pythonCoverageInclusionExpressions
 
 
  def isPythonCoverageEnabled(self):
    return self.__usePythonCoverage
 
 
  def isGlobalPythonCoverageEnabled(self):
    return self.__useGlobalPythonCoverage
 
 
  def setPythonCoverageEnabled (self, value):
    self.__usePythonCoverage = True if value else False
 
 
  def setGlobalPythonCoverageEnabled (self, value):
    self.__useGlobalPythonCoverage = True if value else False
 
 
  def isBullseyeCoverageEnabled(self):
    return self.__useBullseyeCoverage
 
 
  def setBullseyeCoverageEnabled (self, value):
    self.__useBullseyeCoverage = True if value else False
 
 
  def getRestartInterval(self):
    return self.__mMLABRestartInterval
 
 
  def getMaxTestTimeoutSeconds(self):
    return self.__maxTestTimeoutSeconds
  
  def getIPCConnectionTimeout(self):
    return self.__ipcConnectionTimeout