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