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
 
import os
import sys
import tempfile
 
import xml.etree.cElementTree as etree
 
 
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:
    @staticmethod
    def getReportDir():
        if Utils.isWindows:
            return os.path.join(os.getenv("USERPROFILE"), "TestCenterReports")
        return os.path.join(os.getenv("HOME"), "TestCenterReports")
 
    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.
        """
        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()
 
        # 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 __load(self, filename):
        """Load the configuration values from the given file.
        The method raises an exception if the given file does not exist. The method is private as it is
        called by the classes' __init__ method.
        """
        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 ValueError:
                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", str(self.__report.appendTestCaseName))
        reportNode.set("appendTimestamp", str(self.__report.appendTimestamp))
        reportNode.set("collapseFunctions", str(self.__report.collapseFunctions))
        reportNode.set("showFailedOnly", str(self.__report.showFailedFunctionsOnly))
        reportNode.set("hideInfos", str(self.__report.hideInfoMessages))
        reportNode.set("hideSystemMessages", str(self.__report.hideSystemMessages))
        reportNode.set("maxErrorMessagesPerTestFunction", str(self.__report.maxErrorMessagesPerTestFunction))
        reportNode.set("maxInfoMessagesPerTestFunction", str(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 is 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