[coverage] Remplace tabulation indentation by spaces
BZ: 115218
The coding style request that file should be indented with spaces not
tabs.
Replaces each tab by 4 spaces.
Change-Id: I15c665bf9a4feeff5512fba9e8c883c378f106a7
Signed-off-by: Kevin Rocard <kevinx.rocard@intel.com>
Reviewed-on: http://android.intel.com:8080/115316
Reviewed-by: Denneulin, Guillaume <guillaume.denneulin@intel.com>
Reviewed-by: De Chivre, Renaud <renaud.de.chivre@intel.com>
Reviewed-by: cactus <cactus@intel.com>
Tested-by: Dixon, CharlesX <charlesx.dixon@intel.com>
Reviewed-by: buildbot <buildbot@intel.com>
Tested-by: buildbot <buildbot@intel.com>
diff --git a/tools/coverage/coverage.py b/tools/coverage/coverage.py
index df79b5b..d6e8916 100755
--- a/tools/coverage/coverage.py
+++ b/tools/coverage/coverage.py
@@ -41,837 +41,837 @@
logger = logging.getLogger("Coverage")
class CustomError(Exception):
- pass
+ pass
class ChildError(CustomError):
- def __init__(self, parent, child):
- self.parent = parent
- self.child = child
+ def __init__(self, parent, child):
+ self.parent = parent
+ self.child = child
class ChildNotFoundError(ChildError):
- def __str__(self):
- return "Unable to find the child %s in %s" % (self.child, self.parent)
+ def __str__(self):
+ return "Unable to find the child %s in %s" % (self.child, self.parent)
class DuplicatedChildError(ChildError):
- def __str__(self):
- return "Add existing child %s in %s." % (self.child, self.parent)
+ def __str__(self):
+ return "Add existing child %s in %s." % (self.child, self.parent)
class Element():
- """Root class for all coverage elements"""
- tag = "element"
+ """Root class for all coverage elements"""
+ tag = "element"
- def __init__(self, name):
+ def __init__(self, name):
- self.parent = None
- self.children = []
+ self.parent = None
+ self.children = []
- self.nbUse = 0
+ self.nbUse = 0
- self.name = name
+ self.name = name
- self.debug("New element")
+ self.debug("New element")
- def __str__(self):
- return "%s (%s)" % (self.name, self.tag)
+ def __str__(self):
+ return "%s (%s)" % (self.name, self.tag)
- def __eq__(self, compared):
- return (self.name == compared.name) and (self.children == compared.children)
+ def __eq__(self, compared):
+ return (self.name == compared.name) and (self.children == compared.children)
- def getName(self, default=""):
- return self.name or default
+ def getName(self, default=""):
+ return self.name or default
- def hasChildren(self):
- return bool(self.children)
+ def hasChildren(self):
+ return bool(self.children)
- def getChildren(self):
- return self.children
+ def getChildren(self):
+ return self.children
- def _getDescendants(self):
- for child in self.children:
- yield child
- for descendant in child._getDescendants() :
- yield descendant
+ def _getDescendants(self):
+ for child in self.children:
+ yield child
+ for descendant in child._getDescendants() :
+ yield descendant
- def getChildFromName(self, childName):
+ def getChildFromName(self, childName):
- for child in self.children :
+ for child in self.children :
- if child.getName() == childName :
- return child
+ if child.getName() == childName :
+ return child
- self.debug("Child %s not found" % childName, logging.ERROR)
+ self.debug("Child %s not found" % childName, logging.ERROR)
- self.debug("Child list :")
+ self.debug("Child list :")
- for child in self.children :
- self.debug(" - %s" % child)
+ for child in self.children :
+ self.debug(" - %s" % child)
- raise ChildNotFoundError(self, childName)
+ raise ChildNotFoundError(self, childName)
- def addChild(self, child):
- self.debug("new child: " + child.name)
- self.children.append(child)
- child._adoptedBy(self)
+ def addChild(self, child):
+ self.debug("new child: " + child.name)
+ self.children.append(child)
+ child._adoptedBy(self)
- def _adoptedBy(self, parent):
- assert(not self.parent)
- self.parent = parent
+ def _adoptedBy(self, parent):
+ assert(not self.parent)
+ self.parent = parent
- def _getElementNames(self, elementList):
- return (substate.name for substate in elementList)
+ def _getElementNames(self, elementList):
+ return (substate.name for substate in elementList)
- def _description(self, withCoverage, withNbUse):
- description = self.name
+ def _description(self, withCoverage, withNbUse):
+ description = self.name
- if withNbUse or withCoverage :
- description += " has been used " + str(self.nbUse) + " time"
+ if withNbUse or withCoverage :
+ description += " has been used " + str(self.nbUse) + " time"
- if withCoverage :
- description += self._coverageFormating(self._getCoverage())
+ if withCoverage :
+ description += self._coverageFormating(self._getCoverage())
- return description
+ return description
- def _getCoverage(self):
- """Return the coverage of the element between 0 and 1
+ def _getCoverage(self):
+ """Return the coverage of the element between 0 and 1
- If the element has no coverage dependency (usually child) return 0 or 1.
- otherwise the element coverage is the dependency coverage average"""
- coverageDependanceElements = list(self._getCoverageDependanceElements())
+ If the element has no coverage dependency (usually child) return 0 or 1.
+ otherwise the element coverage is the dependency coverage average"""
+ coverageDependanceElements = list(self._getCoverageDependanceElements())
- nbcoverageDependence = len(coverageDependanceElements)
+ nbcoverageDependence = len(coverageDependanceElements)
- if nbcoverageDependence == 0:
- if self.nbUse == 0:
- return 0
- else:
- return 1
+ if nbcoverageDependence == 0:
+ if self.nbUse == 0:
+ return 0
+ else:
+ return 1
- coverageDependenceValues = (depElement._getCoverage()
- for depElement in coverageDependanceElements)
+ coverageDependenceValues = (depElement._getCoverage()
+ for depElement in coverageDependanceElements)
- return sum(coverageDependenceValues) / nbcoverageDependence
+ return sum(coverageDependenceValues) / nbcoverageDependence
- def _getCoverageDependanceElements(self):
- return self.children
+ def _getCoverageDependanceElements(self):
+ return self.children
- def _coverageFormating(self, coverage):
- # If no coverage provided
- if not coverage :
- return ""
+ def _coverageFormating(self, coverage):
+ # If no coverage provided
+ if not coverage :
+ return ""
- # Calculate coverage
- return " (%s coverage)" % self._number2percent(coverage)
+ # Calculate coverage
+ return " (%s coverage)" % self._number2percent(coverage)
- @staticmethod
- def _number2percent(number):
- """Format a number to a integer % string
+ @staticmethod
+ def _number2percent(number):
+ """Format a number to a integer % string
- example: _number2percent(0.6666) -> "67%"
- """
- return "{0:.0f}%".format(100 * number)
+ example: _number2percent(0.6666) -> "67%"
+ """
+ return "{0:.0f}%".format(100 * number)
- def _dumpDescription(self, withCoverage, withNbUse):
+ def _dumpDescription(self, withCoverage, withNbUse):
- self.debug("yelding description")
- yield RankedLine(self._description(withCoverage, withNbUse), lineSuffix="")
+ self.debug("yelding description")
+ yield RankedLine(self._description(withCoverage, withNbUse), lineSuffix="")
- for dumped in self._dumpPropagate(withCoverage, withNbUse) :
- yield dumped
+ for dumped in self._dumpPropagate(withCoverage, withNbUse) :
+ yield dumped
- def _dumpPropagate(self, withCoverage, withNbUse):
+ def _dumpPropagate(self, withCoverage, withNbUse):
- for child in self.children :
- for dumpedDescription in child._dumpDescription(withCoverage, withNbUse) :
- yield dumpedDescription.increasedRank()
+ for child in self.children :
+ for dumpedDescription in child._dumpDescription(withCoverage, withNbUse) :
+ yield dumpedDescription.increasedRank()
- def dump(self, withCoverage=False, withNbUse=True):
+ def dump(self, withCoverage=False, withNbUse=True):
- return "\n".join(
- str(dumpedDescription) for dumpedDescription in
- self._dumpDescription(withCoverage, withNbUse))
+ return "\n".join(
+ str(dumpedDescription) for dumpedDescription in
+ self._dumpDescription(withCoverage, withNbUse))
- def exportToXML(self, domElement=None):
- if domElement == None:
- domElement = xml.dom.minidom.Element(self.tag)
+ def exportToXML(self, domElement=None):
+ if domElement == None:
+ domElement = xml.dom.minidom.Element(self.tag)
- self._XMLaddAttributes(domElement)
+ self._XMLaddAttributes(domElement)
- for child in self.children :
- domElement.appendChild(child.exportToXML())
+ for child in self.children :
+ domElement.appendChild(child.exportToXML())
- return domElement
+ return domElement
- def _XMLaddAttributes(self, domElement):
- attributes = self._getXMLAttributes()
+ def _XMLaddAttributes(self, domElement):
+ attributes = self._getXMLAttributes()
- coverage = self._getCoverage()
- if coverage != None :
- attributes["Coverage"] = self._number2percent(coverage)
+ coverage = self._getCoverage()
+ if coverage != None :
+ attributes["Coverage"] = self._number2percent(coverage)
- for key, value in attributes.items():
- domElement.setAttribute(key, value)
+ for key, value in attributes.items():
+ domElement.setAttribute(key, value)
- def _getXMLAttributes(self):
- return {
- "Name": self.name,
- "NbUse": str(self.nbUse)
- }
+ def _getXMLAttributes(self):
+ return {
+ "Name": self.name,
+ "NbUse": str(self.nbUse)
+ }
- def _incNbUse(self):
- self.nbUse += 1
+ def _incNbUse(self):
+ self.nbUse += 1
- def childUsed(self, child):
- self._incNbUse()
- # Propagate to parent
- self._tellParentThatChildUsed()
+ def childUsed(self, child):
+ self._incNbUse()
+ # Propagate to parent
+ self._tellParentThatChildUsed()
- def _tellParentThatChildUsed(self):
- if self.parent :
- self.parent.childUsed(self)
+ def _tellParentThatChildUsed(self):
+ if self.parent :
+ self.parent.childUsed(self)
- def parentUsed(self):
- self._incNbUse()
- # Propagate to children
- for child in self.children :
- child.parentUsed()
+ def parentUsed(self):
+ self._incNbUse()
+ # Propagate to children
+ for child in self.children :
+ child.parentUsed()
- def hasBeenUsed(self):
- return self.nbUse > 0
+ def hasBeenUsed(self):
+ return self.nbUse > 0
- def operationOnChild(self, path, operation):
+ def operationOnChild(self, path, operation):
- if path:
- return self._operationPropagate(path, operation)
- else :
- self.debug("operating on self")
- return operation(self)
+ if path:
+ return self._operationPropagate(path, operation)
+ else :
+ self.debug("operating on self")
+ return operation(self)
- def _operationPropagate(self, path, operation):
+ def _operationPropagate(self, path, operation):
- childName = path.pop(0)
- child = self.getChildFromName(childName)
+ childName = path.pop(0)
+ child = self.getChildFromName(childName)
- return child.operationOnChild(path, operation)
+ return child.operationOnChild(path, operation)
- def debug(self, stringOrFunction, level=logging.DEBUG):
- """Print a debug line on stderr in tree form
+ def debug(self, stringOrFunction, level=logging.DEBUG):
+ """Print a debug line on stderr in tree form
- If the debug line is expensive to generate, provide callable
- object, it will be called if log is enable for this level.
- This callable object should return the logline string.
- """
- if logger.isEnabledFor(level):
+ If the debug line is expensive to generate, provide callable
+ object, it will be called if log is enable for this level.
+ This callable object should return the logline string.
+ """
+ if logger.isEnabledFor(level):
- # TODO: use buildin callable if python >= 3.2
- if hasattr(stringOrFunction, "__call__"):
- string = stringOrFunction()
- else:
- string = stringOrFunction
+ # TODO: use buildin callable if python >= 3.2
+ if hasattr(stringOrFunction, "__call__"):
+ string = stringOrFunction()
+ else:
+ string = stringOrFunction
- rankedLine = DebugRankedLine("%s: %s" % (self, string))
- self._logDebug(rankedLine, level)
+ rankedLine = DebugRankedLine("%s: %s" % (self, string))
+ self._logDebug(rankedLine, level)
- def _logDebug(self, rankedLine, level):
+ def _logDebug(self, rankedLine, level):
- if self.parent:
- self.parent._logDebug(rankedLine.increasedRank(), level)
- else :
- logger.log(level, str(rankedLine))
+ if self.parent:
+ self.parent._logDebug(rankedLine.increasedRank(), level)
+ else :
+ logger.log(level, str(rankedLine))
class FromDomElement(Element):
- def __init__(self, DomElement):
- self._initFromDom(DomElement)
- super().__init__(self.name)
+ def __init__(self, DomElement):
+ self._initFromDom(DomElement)
+ super().__init__(self.name)
- def _initFromDom(self, DomElement):
- self.name = DomElement.getAttribute("Name")
+ def _initFromDom(self, DomElement):
+ self.name = DomElement.getAttribute("Name")
class DomElementLocation():
- def __init__(self, classConstructor, path=None):
- self.classConstructor = classConstructor
- if path :
- self.path = path
- else :
- self.path = []
+ def __init__(self, classConstructor, path=None):
+ self.classConstructor = classConstructor
+ if path :
+ self.path = path
+ else :
+ self.path = []
- self.path.append(classConstructor.tag)
+ self.path.append(classConstructor.tag)
class DomPopulatedElement(Element):
- """Default child populate
+ """Default child populate
- Look for each dom element with tag specified in self.tag
- and instantiate it with the dom element
- """
- childClasses = []
+ Look for each dom element with tag specified in self.tag
+ and instantiate it with the dom element
+ """
+ childClasses = []
- def populate(self, dom):
+ def populate(self, dom):
- for childDomElementLocation in self.childClasses :
+ for childDomElementLocation in self.childClasses :
- self.debug("Looking for child %s in path %s" % (
- childDomElementLocation.path[-1], childDomElementLocation.path))
+ self.debug("Looking for child %s in path %s" % (
+ childDomElementLocation.path[-1], childDomElementLocation.path))
- for childDomElement in self._findChildFromTagPath(dom, childDomElementLocation.path) :
+ for childDomElement in self._findChildFromTagPath(dom, childDomElementLocation.path) :
- childElement = childDomElementLocation.classConstructor(childDomElement)
- self.addChild(childElement)
+ childElement = childDomElementLocation.classConstructor(childDomElement)
+ self.addChild(childElement)
- childElement.populate(childDomElement)
+ childElement.populate(childDomElement)
- def _findChildFromTagPath(self, dom, path):
- if not path :
- yield dom
- else :
- # Copy list
- path = list(path)
+ def _findChildFromTagPath(self, dom, path):
+ if not path :
+ yield dom
+ else :
+ # Copy list
+ path = list(path)
- tag = path.pop(0)
+ tag = path.pop(0)
- # Find element with tag
- self.debug("Going to find elements with tag %s in %s" % (tag, dom))
- self.debug(lambda: "Nb of solutions: %s" % len(dom.getElementsByTagName(tag)))
+ # Find element with tag
+ self.debug("Going to find elements with tag %s in %s" % (tag, dom))
+ self.debug(lambda: "Nb of solutions: %s" % len(dom.getElementsByTagName(tag)))
- for elementByTag in dom.getElementsByTagName(tag) :
+ for elementByTag in dom.getElementsByTagName(tag) :
- self.debug("Found element: %s" % elementByTag)
+ self.debug("Found element: %s" % elementByTag)
- # If the same tag is found
- if elementByTag in dom.childNodes :
+ # If the same tag is found
+ if elementByTag in dom.childNodes :
- # Yield next level
- for element in self._findChildFromTagPath(elementByTag, path) :
- yield element
+ # Yield next level
+ for element in self._findChildFromTagPath(elementByTag, path) :
+ yield element
class Rule(Element):
- def usedIfApplicable(self, criteria):
- childApplicability = (child.usedIfApplicable(criteria)
- for child in self.children)
+ def usedIfApplicable(self, criteria):
+ childApplicability = (child.usedIfApplicable(criteria)
+ for child in self.children)
- isApplicable = self._isApplicable(criteria, childApplicability)
+ isApplicable = self._isApplicable(criteria, childApplicability)
- if isApplicable :
- self._incNbUse()
+ if isApplicable :
+ self._incNbUse()
- self.debug("Rule applicability: %s" % isApplicable)
- assert(isApplicable == True or isApplicable == False)
+ self.debug("Rule applicability: %s" % isApplicable)
+ assert(isApplicable == True or isApplicable == False)
- return isApplicable
+ return isApplicable
- def _isApplicable(self, criteria, childApplicability):
- """Return the rule applicability depending on children applicability.
+ def _isApplicable(self, criteria, childApplicability):
+ """Return the rule applicability depending on children applicability.
- If at least one child is applicable, return true"""
- # Lazy evaluation as in the PFW
- return all(childApplicability)
+ If at least one child is applicable, return true"""
+ # Lazy evaluation as in the PFW
+ return all(childApplicability)
class CriterionRule(FromDomElement, DomPopulatedElement, Rule):
- tag = "SelectionCriterionRule"
- childClasses = []
- isApplicableOperations = {
- "Includes" : lambda criterion, value: criterion.stateIncludes(value),
- "Excludes" : lambda criterion, value: not criterion.stateIncludes(value),
- "Is" : lambda criterion, value: criterion.stateIs(value),
- "IsNot" : lambda criterion, value: not criterion.stateIs(value)
- }
+ tag = "SelectionCriterionRule"
+ childClasses = []
+ isApplicableOperations = {
+ "Includes" : lambda criterion, value: criterion.stateIncludes(value),
+ "Excludes" : lambda criterion, value: not criterion.stateIncludes(value),
+ "Is" : lambda criterion, value: criterion.stateIs(value),
+ "IsNot" : lambda criterion, value: not criterion.stateIs(value)
+ }
- def _initFromDom(self, DomElement):
- self.selectionCriterion = DomElement.getAttribute("SelectionCriterion")
- self.matchesWhen = DomElement.getAttribute("MatchesWhen")
- self.value = DomElement.getAttribute("Value")
- self.name = "%s %s %s" % (self.selectionCriterion, self.matchesWhen, self.value)
+ def _initFromDom(self, DomElement):
+ self.selectionCriterion = DomElement.getAttribute("SelectionCriterion")
+ self.matchesWhen = DomElement.getAttribute("MatchesWhen")
+ self.value = DomElement.getAttribute("Value")
+ self.name = "%s %s %s" % (self.selectionCriterion, self.matchesWhen, self.value)
- applicableOperationWithoutValue = self.isApplicableOperations[self.matchesWhen]
- self.isApplicableOperation = lambda criterion: applicableOperationWithoutValue(criterion, self.value)
+ applicableOperationWithoutValue = self.isApplicableOperations[self.matchesWhen]
+ self.isApplicableOperation = lambda criterion: applicableOperationWithoutValue(criterion, self.value)
- def _isApplicable(self, criteria, childApplicability):
+ def _isApplicable(self, criteria, childApplicability):
- return criteria.operationOnChild([self.selectionCriterion],
- self.isApplicableOperation)
+ return criteria.operationOnChild([self.selectionCriterion],
+ self.isApplicableOperation)
class CompoundRule(FromDomElement, DomPopulatedElement, Rule):
- """CompoundRule can be of type ALL or ANY"""
- tag = "CompoundRule"
- # Declare childClasses but define it at first class instantiation
- childClasses = None
+ """CompoundRule can be of type ALL or ANY"""
+ tag = "CompoundRule"
+ # Declare childClasses but define it at first class instantiation
+ childClasses = None
- def __init__(self, dom):
- # Define childClasses at first class instantiation
- if self.childClasses == None :
- self.childClasses = [DomElementLocation(CriterionRule),
- DomElementLocation(CompoundRule)]
- super().__init__(dom)
+ def __init__(self, dom):
+ # Define childClasses at first class instantiation
+ if self.childClasses == None :
+ self.childClasses = [DomElementLocation(CriterionRule),
+ DomElementLocation(CompoundRule)]
+ super().__init__(dom)
- def _initFromDom(self, DomElement):
+ def _initFromDom(self, DomElement):
- type = DomElement.getAttribute("Type")
- self.ofTypeAll = {"All" : True, "Any" : False}[type]
- self.name = type
+ type = DomElement.getAttribute("Type")
+ self.ofTypeAll = {"All" : True, "Any" : False}[type]
+ self.name = type
- def _isApplicable(self, criteria, childApplicability):
- if self.ofTypeAll :
- applicability = super()._isApplicable(criteria, childApplicability)
- else:
- # Lazy evaluation as in the PFW
- applicability = any(childApplicability)
+ def _isApplicable(self, criteria, childApplicability):
+ if self.ofTypeAll :
+ applicability = super()._isApplicable(criteria, childApplicability)
+ else:
+ # Lazy evaluation as in the PFW
+ applicability = any(childApplicability)
- return applicability
+ return applicability
class RootRule(DomPopulatedElement, Rule):
- tag = "RootRule"
- childClasses = [DomElementLocation(CompoundRule)]
+ tag = "RootRule"
+ childClasses = [DomElementLocation(CompoundRule)]
- def populate(self, dom):
- super().populate(dom)
- self.debug("Children: %s" % self.children)
- # A configuration can only have one or no rule
- assert(len(self.children) <= 1)
+ def populate(self, dom):
+ super().populate(dom)
+ self.debug("Children: %s" % self.children)
+ # A configuration can only have one or no rule
+ assert(len(self.children) <= 1)
- def _getCoverageDependanceElements(self):
- return self._getDescendants()
+ def _getCoverageDependanceElements(self):
+ return self._getDescendants()
class CriteronStates(Element):
- """Root of configuration application criterion state"""
- tag = "CriterionStates"
+ """Root of configuration application criterion state"""
+ tag = "CriterionStates"
- def parentUsed(self, criteria):
- """Add criteria to child if not exist, if exist increase it's nbUse"""
- self._incNbUse()
+ def parentUsed(self, criteria):
+ """Add criteria to child if not exist, if exist increase it's nbUse"""
+ self._incNbUse()
- matches = [child for child in self.children if child == criteria]
+ matches = [child for child in self.children if child == criteria]
- assert(len(matches) <= 1)
+ assert(len(matches) <= 1)
- if matches :
- self.debug("Criteria state has already been encounter")
- currentcriteria = matches[0]
- else :
- self.debug("Criteria state has never been encounter, saving it")
- currentcriteria = criteria
- self.addChild(criteria)
+ if matches :
+ self.debug("Criteria state has already been encounter")
+ currentcriteria = matches[0]
+ else :
+ self.debug("Criteria state has never been encounter, saving it")
+ currentcriteria = criteria
+ self.addChild(criteria)
- currentcriteria.parentUsed()
+ currentcriteria.parentUsed()
class Configuration(FromDomElement, DomPopulatedElement):
- tag = "Configuration"
- childClasses = []
+ tag = "Configuration"
+ childClasses = []
- class IneligibleConfigurationAppliedError(CustomError):
+ class IneligibleConfigurationAppliedError(CustomError):
- def __init__(self, configuration, criteria):
- self.configuration = configuration
- self.criteria = criteria
+ def __init__(self, configuration, criteria):
+ self.configuration = configuration
+ self.criteria = criteria
- def __str__(self):
+ def __str__(self):
- return ("Applying ineligible %s, "
- "rule:\n%s\n"
- "Criteria current state:\n%s" % (
- self.configuration,
- self.configuration.rootRule.dump(withCoverage=False, withNbUse=False),
- self.criteria.dump(withCoverage=False, withNbUse=False)
- ))
+ return ("Applying ineligible %s, "
+ "rule:\n%s\n"
+ "Criteria current state:\n%s" % (
+ self.configuration,
+ self.configuration.rootRule.dump(withCoverage=False, withNbUse=False),
+ self.criteria.dump(withCoverage=False, withNbUse=False)
+ ))
- def __init__(self, DomElement):
- super().__init__(DomElement)
+ def __init__(self, DomElement):
+ super().__init__(DomElement)
- self.rootRule = RootRule("RootRule")
- self.addChild(self.rootRule)
+ self.rootRule = RootRule("RootRule")
+ self.addChild(self.rootRule)
- self.criteronStates = CriteronStates("CriterionStates")
- self.addChild(self.criteronStates)
+ self.criteronStates = CriteronStates("CriterionStates")
+ self.addChild(self.criteronStates)
- def populate(self, dom):
- # Delegate to rootRule
- self.rootRule.populate(dom)
+ def populate(self, dom):
+ # Delegate to rootRule
+ self.rootRule.populate(dom)
- def _getCoverage(self):
- # Delegate to rootRule
- return self.rootRule._getCoverage()
+ def _getCoverage(self):
+ # Delegate to rootRule
+ return self.rootRule._getCoverage()
- def used(self, criteria):
+ def used(self, criteria):
- self._incNbUse()
+ self._incNbUse()
- # Propagate use to parents
- self._tellParentThatChildUsed()
+ # Propagate use to parents
+ self._tellParentThatChildUsed()
- # Propagate to criterion coverage
- self.criteronStates.parentUsed(criteria.export())
+ # Propagate to criterion coverage
+ self.criteronStates.parentUsed(criteria.export())
- # Propagate to rules
- if not self.rootRule.usedIfApplicable(criteria) :
+ # Propagate to rules
+ if not self.rootRule.usedIfApplicable(criteria) :
- self.debug("Applied but rule does not match current "
+ self.debug("Applied but rule does not match current "
"criteria (parent: %s) " % self.parent.name,
- logging.ERROR)
+ logging.ERROR)
- raise self.IneligibleConfigurationAppliedError(self, criteria.export())
+ raise self.IneligibleConfigurationAppliedError(self, criteria.export())
- def _dumpPropagate(self, withCoverage, withNbUse):
- self.debug("Going to ask %s for description" % self.rootRule)
- for dumpedDescription in self.rootRule._dumpDescription(
- withCoverage=withCoverage,
- withNbUse=withNbUse) :
- yield dumpedDescription.increasedRank()
+ def _dumpPropagate(self, withCoverage, withNbUse):
+ self.debug("Going to ask %s for description" % self.rootRule)
+ for dumpedDescription in self.rootRule._dumpDescription(
+ withCoverage=withCoverage,
+ withNbUse=withNbUse) :
+ yield dumpedDescription.increasedRank()
- self.debug("Going to ask %s for description" % self.criteronStates)
- for dumpedDescription in self.criteronStates._dumpDescription(
- withCoverage=False,
- withNbUse=withNbUse) :
- yield dumpedDescription.increasedRank()
+ self.debug("Going to ask %s for description" % self.criteronStates)
+ for dumpedDescription in self.criteronStates._dumpDescription(
+ withCoverage=False,
+ withNbUse=withNbUse) :
+ yield dumpedDescription.increasedRank()
class Domain(FromDomElement, DomPopulatedElement):
- tag = "ConfigurableDomain"
- childClasses = [DomElementLocation(Configuration, ["Configurations"])]
+ tag = "ConfigurableDomain"
+ childClasses = [DomElementLocation(Configuration, ["Configurations"])]
class Domains(DomPopulatedElement):
- tag = "Domains"
- childClasses = [DomElementLocation(Domain, ["ConfigurableDomains"])]
+ tag = "Domains"
+ childClasses = [DomElementLocation(Domain, ["ConfigurableDomains"])]
class RankedLine():
- def __init__(self, string,
- stringPrefix="|-- ",
- rankString="| ",
- linePrefix="",
- lineSuffix="\n"):
- self.string = string
- self.rank = 0
- self.stringPrefix = stringPrefix
- self.rankString = rankString
- self.linePrefix = linePrefix
- self.lineSuffix = lineSuffix
+ def __init__(self, string,
+ stringPrefix="|-- ",
+ rankString="| ",
+ linePrefix="",
+ lineSuffix="\n"):
+ self.string = string
+ self.rank = 0
+ self.stringPrefix = stringPrefix
+ self.rankString = rankString
+ self.linePrefix = linePrefix
+ self.lineSuffix = lineSuffix
- def increasedRank(self):
- self.rank += 1
- return self
+ def increasedRank(self):
+ self.rank += 1
+ return self
- def __str__(self):
- return self.linePrefix + \
- self.rank * self.rankString + \
- self.stringPrefix + \
- self.string + \
- self.lineSuffix
+ def __str__(self):
+ return self.linePrefix + \
+ self.rank * self.rankString + \
+ self.stringPrefix + \
+ self.string + \
+ self.lineSuffix
class DebugRankedLine(RankedLine):
- def __init__(self, string, lineSuffix=""):
- super().__init__(string,
- stringPrefix="",
- rankString=" ",
- linePrefix="",
- lineSuffix=lineSuffix)
+ def __init__(self, string, lineSuffix=""):
+ super().__init__(string,
+ stringPrefix="",
+ rankString=" ",
+ linePrefix="",
+ lineSuffix=lineSuffix)
class CriterionState(Element):
- tag = "CriterionState"
- def used(self):
- self._incNbUse()
+ tag = "CriterionState"
+ def used(self):
+ self._incNbUse()
class Criterion(Element):
- tag = "Criterion"
- inclusivenessTranslate = {True: "Inclusive", False: "Exclusive"}
+ tag = "Criterion"
+ inclusivenessTranslate = {True: "Inclusive", False: "Exclusive"}
- class ChangeRequestToNonAccessibleState(CustomError):
- def __init__(self, requestedState, detail):
- self.requestedState = requestedState
- self.detail = detail
+ class ChangeRequestToNonAccessibleState(CustomError):
+ def __init__(self, requestedState, detail):
+ self.requestedState = requestedState
+ self.detail = detail
- def __str__(self):
- return ("Change request to non accessible state %s. Detail: %s" %
- (self.requestedState, self.detail))
+ def __str__(self):
+ return ("Change request to non accessible state %s. Detail: %s" %
+ (self.requestedState, self.detail))
- def __init__(self, name, isInclusif,
- stateNamesList, currentStateNamesList,
- ignoreIntegrity=False):
- super().__init__(name)
- self.isInclusif = isInclusif
+ def __init__(self, name, isInclusif,
+ stateNamesList, currentStateNamesList,
+ ignoreIntegrity=False):
+ super().__init__(name)
+ self.isInclusif = isInclusif
- for state in stateNamesList :
- self.addChild(CriterionState(state))
+ for state in stateNamesList :
+ self.addChild(CriterionState(state))
- self.currentState = []
- self.initStateNamesList = list(currentStateNamesList)
- self.changeState(self.initStateNamesList, ignoreIntegrity)
+ self.currentState = []
+ self.initStateNamesList = list(currentStateNamesList)
+ self.changeState(self.initStateNamesList, ignoreIntegrity)
- def reset(self):
- # Set current state as provided at initialisation
- self.changeState(self.initStateNamesList, ignoreIntegrity=True)
+ def reset(self):
+ # Set current state as provided at initialisation
+ self.changeState(self.initStateNamesList, ignoreIntegrity=True)
- def changeState(self, subStateNames, ignoreIntegrity=False):
- self.debug("Changing state from: %s to: %s" % (
- list(self._getElementNames(self.currentState)),
- subStateNames))
+ def changeState(self, subStateNames, ignoreIntegrity=False):
+ self.debug("Changing state from: %s to: %s" % (
+ list(self._getElementNames(self.currentState)),
+ subStateNames))
- if not ignoreIntegrity and not self.isIntegre(subStateNames):
- raise self.ChangeRequestToNonAccessibleState(subStateNames,
- "An exclusive criterion must have a non empty state")
+ if not ignoreIntegrity and not self.isIntegre(subStateNames):
+ raise self.ChangeRequestToNonAccessibleState(subStateNames,
+ "An exclusive criterion must have a non empty state")
- newCurrentState = []
- for subStateName in subStateNames :
- subState = self.getChildFromName(subStateName)
- subState.used()
- newCurrentState.append(subState)
+ newCurrentState = []
+ for subStateName in subStateNames :
+ subState = self.getChildFromName(subStateName)
+ subState.used()
+ newCurrentState.append(subState)
- self.currentState = newCurrentState
+ self.currentState = newCurrentState
- self._incNbUse()
- self._tellParentThatChildUsed()
+ self._incNbUse()
+ self._tellParentThatChildUsed()
- def isIntegre(self, subStateNames):
- return self.isInclusif or len(subStateNames) == 1
+ def isIntegre(self, subStateNames):
+ return self.isInclusif or len(subStateNames) == 1
- def childUsed(self, child):
- self.currentState = child
- super().childUsed(child)
+ def childUsed(self, child):
+ self.currentState = child
+ super().childUsed(child)
- def export(self):
- subStateNames = self._getElementNames(self.currentState)
- return Criterion(self.name, self.isInclusif, subStateNames, subStateNames,
- ignoreIntegrity=True)
+ def export(self):
+ subStateNames = self._getElementNames(self.currentState)
+ return Criterion(self.name, self.isInclusif, subStateNames, subStateNames,
+ ignoreIntegrity=True)
- def stateIncludes(self, subStateName):
- subStateCurrentNames = list(self._getElementNames(self.currentState))
+ def stateIncludes(self, subStateName):
+ subStateCurrentNames = list(self._getElementNames(self.currentState))
- self.debug("Testing if %s is included in %s" % (subStateName, subStateCurrentNames))
+ self.debug("Testing if %s is included in %s" % (subStateName, subStateCurrentNames))
- isIncluded = subStateName in subStateCurrentNames
- self.debug("IsIncluded: %s" % isIncluded)
+ isIncluded = subStateName in subStateCurrentNames
+ self.debug("IsIncluded: %s" % isIncluded)
- return isIncluded
+ return isIncluded
- def stateIs(self, subStateNames):
- if len(self.currentState) != 1 :
- return False
- else :
- return self.stateIncludes(subStateNames)
+ def stateIs(self, subStateNames):
+ if len(self.currentState) != 1 :
+ return False
+ else :
+ return self.stateIncludes(subStateNames)
- def _getXMLAttributes(self):
- attributes = super()._getXMLAttributes()
- attributes["Type"] = self.inclusivenessTranslate[self.isInclusif]
- return attributes
+ def _getXMLAttributes(self):
+ attributes = super()._getXMLAttributes()
+ attributes["Type"] = self.inclusivenessTranslate[self.isInclusif]
+ return attributes
class Criteria(Element):
- tag = "Criteria"
+ tag = "Criteria"
- class DuplicatedCriterionError(DuplicatedChildError):
- pass
+ class DuplicatedCriterionError(DuplicatedChildError):
+ pass
- def export(self):
- self.debug("Exporting criteria")
- assert(self.children)
+ def export(self):
+ self.debug("Exporting criteria")
+ assert(self.children)
- exported = Criteria(self.name)
- for child in self.children :
- exported.addChild(child.export())
- return exported
+ exported = Criteria(self.name)
+ for child in self.children :
+ exported.addChild(child.export())
+ return exported
- def addChild(self, child):
- if child in self.children:
- raise self.DuplicatedCriterionError(self, child)
- super().addChild(child)
+ def addChild(self, child):
+ if child in self.children:
+ raise self.DuplicatedCriterionError(self, child)
+ super().addChild(child)
class ConfigAppliedWithoutCriteriaError(CustomError):
- def __init__(self, configurationName, domainName):
- self.configurationName = configurationName
- self.domainName = domainName
- def __str__(self):
- return ('Applying configuration "%s" from domain "%s" before declaring criteria' %
- (self.configurationName, self.domainName))
+ def __init__(self, configurationName, domainName):
+ self.configurationName = configurationName
+ self.domainName = domainName
+ def __str__(self):
+ return ('Applying configuration "%s" from domain "%s" before declaring criteria' %
+ (self.configurationName, self.domainName))
class ParsePFWlog():
- MATCH = "match"
- ACTION = "action"
+ MATCH = "match"
+ ACTION = "action"
- def __init__(self, domains, criteria, ErrorsToIgnore=()):
+ def __init__(self, domains, criteria, ErrorsToIgnore=()):
- self.domains = domains;
- self.criteria = criteria;
- self.ErrorsToIgnore = ErrorsToIgnore
+ self.domains = domains;
+ self.criteria = criteria;
+ self.ErrorsToIgnore = ErrorsToIgnore
- configApplicationRegext = r""".*Applying configuration "(.*)" from domain "([^"]*)"""
- matchConfigApplicationLine = re.compile(configApplicationRegext).match
+ configApplicationRegext = r""".*Applying configuration "(.*)" from domain "([^"]*)"""
+ matchConfigApplicationLine = re.compile(configApplicationRegext).match
- criterionCreationRegext = ", ".join([
- r""".*Criterion name: (.*)""",
- r"""type kind: (.*)""",
- r"""current state: (.*)""",
- r"""states: {(.*)}"""
- ])
- matchCriterionCreationLine = re.compile(criterionCreationRegext).match
+ criterionCreationRegext = ", ".join([
+ r""".*Criterion name: (.*)""",
+ r"""type kind: (.*)""",
+ r"""current state: (.*)""",
+ r"""states: {(.*)}"""
+ ])
+ matchCriterionCreationLine = re.compile(criterionCreationRegext).match
- changingCriterionRegext = r""".*Selection criterion changed event: Criterion name: (.*), current state: ([^\n\r]*)"""
- matchChangingCriterionLine = re.compile(changingCriterionRegext).match
+ changingCriterionRegext = r""".*Selection criterion changed event: Criterion name: (.*), current state: ([^\n\r]*)"""
+ matchChangingCriterionLine = re.compile(changingCriterionRegext).match
- self.lineLogTypes = [
- {
- self.MATCH: matchConfigApplicationLine,
- self.ACTION: self._configApplication
- }, {
- self.MATCH: matchCriterionCreationLine,
- self.ACTION: self._criterionCreation
- }, {
- self.MATCH: matchChangingCriterionLine,
- self.ACTION: self._changingCriterion
- }
- ]
+ self.lineLogTypes = [
+ {
+ self.MATCH: matchConfigApplicationLine,
+ self.ACTION: self._configApplication
+ }, {
+ self.MATCH: matchCriterionCreationLine,
+ self.ACTION: self._criterionCreation
+ }, {
+ self.MATCH: matchChangingCriterionLine,
+ self.ACTION: self._changingCriterion
+ }
+ ]
- @staticmethod
- def _formatCriterionList(liststring, separator):
- list = liststring.split(separator)
- if len(list) == 1 and list[0] == "<none>":
- list = []
- return list
+ @staticmethod
+ def _formatCriterionList(liststring, separator):
+ list = liststring.split(separator)
+ if len(list) == 1 and list[0] == "<none>":
+ list = []
+ return list
- def _criterionCreation(self, matchCriterionCreation):
- # Unpack
- criterionName, criterionType, currentCriterionStates, criterionStates = matchCriterionCreation.group(1, 2, 3, 4)
+ def _criterionCreation(self, matchCriterionCreation):
+ # Unpack
+ criterionName, criterionType, currentCriterionStates, criterionStates = matchCriterionCreation.group(1, 2, 3, 4)
- criterionStateList = self._formatCriterionList(criterionStates, ", ")
+ criterionStateList = self._formatCriterionList(criterionStates, ", ")
- criterionIsInclusif = {"exclusive" : False, "inclusive" : True}[criterionType]
+ criterionIsInclusif = {"exclusive" : False, "inclusive" : True}[criterionType]
- currentcriterionStateList = self._formatCriterionList(currentCriterionStates, "|")
+ currentcriterionStateList = self._formatCriterionList(currentCriterionStates, "|")
- logger.info("Creating criterion: " + criterionName +
- " (" + criterionType + ") " +
- " with current state: " + str(currentcriterionStateList) +
- ", possible states:" + str(criterionStateList))
+ logger.info("Creating criterion: " + criterionName +
+ " (" + criterionType + ") " +
+ " with current state: " + str(currentcriterionStateList) +
+ ", possible states:" + str(criterionStateList))
- try:
- self.criteria.addChild(Criterion(
- criterionName,
- criterionIsInclusif,
- criterionStateList,
- currentcriterionStateList
- ))
- except self.criteria.DuplicatedCriterionError as ex:
- logger.debug(ex)
- logger.warning("Reseting criterion %s. Did you reset the PFW ?" % criterionName)
- self.criteria.operationOnChild(
- [criterionName],
- lambda criterion: criterion.reset()
- )
+ try:
+ self.criteria.addChild(Criterion(
+ criterionName,
+ criterionIsInclusif,
+ criterionStateList,
+ currentcriterionStateList
+ ))
+ except self.criteria.DuplicatedCriterionError as ex:
+ logger.debug(ex)
+ logger.warning("Reseting criterion %s. Did you reset the PFW ?" % criterionName)
+ self.criteria.operationOnChild(
+ [criterionName],
+ lambda criterion: criterion.reset()
+ )
- def _changingCriterion(self, matchChangingCriterion):
- # Unpack
- criterionName, newCriterionSubStateNames = matchChangingCriterion.group(1, 2)
+ def _changingCriterion(self, matchChangingCriterion):
+ # Unpack
+ criterionName, newCriterionSubStateNames = matchChangingCriterion.group(1, 2)
- newCriterionState = self._formatCriterionList(newCriterionSubStateNames, "|")
+ newCriterionState = self._formatCriterionList(newCriterionSubStateNames, "|")
- logger.info("Changing criterion %s to %s" % (criterionName , newCriterionState))
+ logger.info("Changing criterion %s to %s" % (criterionName , newCriterionState))
- path = [criterionName]
- changeCriterionOperation = lambda criterion : criterion.changeState(newCriterionState)
- self.criteria.operationOnChild(path, changeCriterionOperation)
+ path = [criterionName]
+ changeCriterionOperation = lambda criterion : criterion.changeState(newCriterionState)
+ self.criteria.operationOnChild(path, changeCriterionOperation)
- def _configApplication(self, matchConfig):
- # Unpack
- configurationName, domainName = matchConfig.group(1, 2)
+ def _configApplication(self, matchConfig):
+ # Unpack
+ configurationName, domainName = matchConfig.group(1, 2)
- # Check that at least one criterion exist
- if not self.criteria.hasChildren() :
- logger.error("Applying configuration before declaring criteria")
- logger.info("Is the log starting at PFW boot ?")
- raise ConfigAppliedWithoutCriteriaError(configurationName, domainName)
+ # Check that at least one criterion exist
+ if not self.criteria.hasChildren() :
+ logger.error("Applying configuration before declaring criteria")
+ logger.info("Is the log starting at PFW boot ?")
+ raise ConfigAppliedWithoutCriteriaError(configurationName, domainName)
- # Change criterion state
- path = [domainName, configurationName]
- usedOperation = lambda element : element.used(self.criteria)
+ # Change criterion state
+ path = [domainName, configurationName]
+ usedOperation = lambda element : element.used(self.criteria)
- logger.info("Applying configuration %s from domain %s" % (
- configurationName, domainName))
+ logger.info("Applying configuration %s from domain %s" % (
+ configurationName, domainName))
- self.domains.operationOnChild(path, usedOperation)
+ self.domains.operationOnChild(path, usedOperation)
- def _digest(self, lineLogType, lineLog):
+ def _digest(self, lineLogType, lineLog):
- match = lineLogType[self.MATCH](lineLog)
- if match :
- lineLogType[self.ACTION](match)
- return True
- return False
+ match = lineLogType[self.MATCH](lineLog)
+ if match :
+ lineLogType[self.ACTION](match)
+ return True
+ return False
- def parsePFWlog(self, lines):
- for lineNb, lineLog in enumerate(lines):
+ def parsePFWlog(self, lines):
+ for lineNb, lineLog in enumerate(lines):
- logger.debug("Parsing line :%s" % lineLog.rstrip())
+ logger.debug("Parsing line :%s" % lineLog.rstrip())
- digested = (self._digest(lineLogType, lineLog)
- for lineLogType in self.lineLogTypes)
+ digested = (self._digest(lineLogType, lineLog)
+ for lineLogType in self.lineLogTypes)
- try:
- success = any(digested)
+ try:
+ success = any(digested)
- # Catch some exception in order to print the current parsing line,
- # then raise the exception again if not continue of error
- except CustomError as ex:
- logger.error('Error raised while parsing line %s: "%s"' %
- (lineNb, repr(lineLog)))
+ # Catch some exception in order to print the current parsing line,
+ # then raise the exception again if not continue of error
+ except CustomError as ex:
+ logger.error('Error raised while parsing line %s: "%s"' %
+ (lineNb, repr(lineLog)))
- # If exception is a subclass of ErrorsToIgnore, log it and continue
- # otherwise raise it again.
- if not issubclass(type(ex), self.ErrorsToIgnore):
- raise ex
- else:
- logger.error('Ignoring exception:"%s", '
- 'can not guarantee database integrity' % ex)
- else:
- if not success:
- logger.debug("Line does not match, dropped")
+ # If exception is a subclass of ErrorsToIgnore, log it and continue
+ # otherwise raise it again.
+ if not issubclass(type(ex), self.ErrorsToIgnore):
+ raise ex
+ else:
+ logger.error('Ignoring exception:"%s", '
+ 'can not guarantee database integrity' % ex)
+ else:
+ if not success:
+ logger.debug("Line does not match, dropped")
class Root(Element):
- tag = "CoverageReport"
- def __init__(self, name, dom):
- super().__init__(name)
- # Create domain tree
- self.domains = Domains("Domains")
- self.domains.populate(dom)
- self.addChild(self.domains)
- # Create criterion list
- self.criteria = Criteria("CriterionRoot")
- self.addChild(self.criteria)
+ tag = "CoverageReport"
+ def __init__(self, name, dom):
+ super().__init__(name)
+ # Create domain tree
+ self.domains = Domains("Domains")
+ self.domains.populate(dom)
+ self.addChild(self.domains)
+ # Create criterion list
+ self.criteria = Criteria("CriterionRoot")
+ self.addChild(self.criteria)
- def exportToXML(self):
- """Export tree to an xml document"""
- impl = xml.dom.minidom.getDOMImplementation()
- newdoc = impl.createDocument(namespaceURI=None, qualifiedName=self.tag, doctype=None)
- super().exportToXML(newdoc.documentElement)
+ def exportToXML(self):
+ """Export tree to an xml document"""
+ impl = xml.dom.minidom.getDOMImplementation()
+ newdoc = impl.createDocument(namespaceURI=None, qualifiedName=self.tag, doctype=None)
+ super().exportToXML(newdoc.documentElement)
- return newdoc
+ return newdoc
# ============================
# Command line argument parser
@@ -879,170 +879,170 @@
class ArgumentParser:
- """class that parse command line arguments with argparse library
+ """class that parse command line arguments with argparse library
- Result of parsing are the class attributes.
- """
- levelTranslate = [logging.ERROR, logging.WARNING, logging.INFO, logging.DEBUG]
+ Result of parsing are the class attributes.
+ """
+ levelTranslate = [logging.ERROR, logging.WARNING, logging.INFO, logging.DEBUG]
- def __init__(self):
+ def __init__(self):
- try:
- # As argparse is only in the stdlib since python 3.2,
- # testing its availability
- import argparse
+ try:
+ # As argparse is only in the stdlib since python 3.2,
+ # testing its availability
+ import argparse
- except ImportError:
- logger.warning("Unable to import argparse "
- "(parser for command-line options and arguments), "
- "using default argument values:")
+ except ImportError:
+ logger.warning("Unable to import argparse "
+ "(parser for command-line options and arguments), "
+ "using default argument values:")
- logger.warning(" - InputFile: stdin")
- self.inputFile = sys.stdin
+ logger.warning(" - InputFile: stdin")
+ self.inputFile = sys.stdin
- logger.warning(" - OutputFile: stdout")
- self.outputFile = sys.stdout
+ logger.warning(" - OutputFile: stdout")
+ self.outputFile = sys.stdout
- try:
- self.domainsFile = sys.argv[1]
- except IndexError as ex:
- logger.fatal("No domain file provided (first argument)")
- raise ex
- else:
- logger.warning(" - Domain file: " + self.domainsFile)
+ try:
+ self.domainsFile = sys.argv[1]
+ except IndexError as ex:
+ logger.fatal("No domain file provided (first argument)")
+ raise ex
+ else:
+ logger.warning(" - Domain file: " + self.domainsFile)
- logger.warning(" - Output format: xml")
- self.XMLreport = True
+ logger.warning(" - Output format: xml")
+ self.XMLreport = True
- logger.warning(" - Debug level: error")
- self.debugLevel = logging.ERROR
- else :
+ logger.warning(" - Debug level: error")
+ self.debugLevel = logging.ERROR
+ else :
- myArgParser = argparse.ArgumentParser(description='Generate PFW report')
+ myArgParser = argparse.ArgumentParser(description='Generate PFW report')
- myArgParser.add_argument(
- 'domainsFile',
- type=argparse.FileType('r'),
- help="the PFW domain XML file"
- )
- myArgParser.add_argument(
- 'pfwlog', nargs='?',
- type=argparse.FileType('r'), default=sys.stdin,
- help="the PFW log file, default stdin"
- )
- myArgParser.add_argument(
- '-o', '--output',
- dest="outputFile",
- type=argparse.FileType('w'), default=sys.stdout,
- help="the coverage report output file, default stdout"
- )
- myArgParser.add_argument(
- '-v', '--verbose',
- dest="debugLevel", default=0,
- action='count',
- help="print debug warnings from warning (default) to debug (-vv)"
- )
+ myArgParser.add_argument(
+ 'domainsFile',
+ type=argparse.FileType('r'),
+ help="the PFW domain XML file"
+ )
+ myArgParser.add_argument(
+ 'pfwlog', nargs='?',
+ type=argparse.FileType('r'), default=sys.stdin,
+ help="the PFW log file, default stdin"
+ )
+ myArgParser.add_argument(
+ '-o', '--output',
+ dest="outputFile",
+ type=argparse.FileType('w'), default=sys.stdout,
+ help="the coverage report output file, default stdout"
+ )
+ myArgParser.add_argument(
+ '-v', '--verbose',
+ dest="debugLevel", default=0,
+ action='count',
+ help="print debug warnings from warning (default) to debug (-vv)"
+ )
- outputFormatGroupe = myArgParser.add_mutually_exclusive_group(required=False)
+ outputFormatGroupe = myArgParser.add_mutually_exclusive_group(required=False)
- outputFormatGroupe.add_argument(
- '--xml',
- dest="xmlFlag",
- action='store_true',
- help=" XML coverage output report"
- )
- outputFormatGroupe.add_argument(
- '--raw',
- dest="rawFlag",
- action='store_true',
- help="raw coverage output report"
- )
+ outputFormatGroupe.add_argument(
+ '--xml',
+ dest="xmlFlag",
+ action='store_true',
+ help=" XML coverage output report"
+ )
+ outputFormatGroupe.add_argument(
+ '--raw',
+ dest="rawFlag",
+ action='store_true',
+ help="raw coverage output report"
+ )
- myArgParser.add_argument(
- '--ignore-incoherent-criterion-state',
- dest="incoherentCriterionFlag",
- action='store_true',
- help="ignore criterion transition to incoherent state"
- )
+ myArgParser.add_argument(
+ '--ignore-incoherent-criterion-state',
+ dest="incoherentCriterionFlag",
+ action='store_true',
+ help="ignore criterion transition to incoherent state"
+ )
- myArgParser.add_argument(
- '--ignore-ineligible-configuration-application',
- dest="ineligibleConfigurationApplicationFlag",
- action='store_true',
- help="ignore application of configuration with a false rule "
- "(not applicable configuration)"
- )
+ myArgParser.add_argument(
+ '--ignore-ineligible-configuration-application',
+ dest="ineligibleConfigurationApplicationFlag",
+ action='store_true',
+ help="ignore application of configuration with a false rule "
+ "(not applicable configuration)"
+ )
- # Process command line arguments
- options = myArgParser.parse_args()
+ # Process command line arguments
+ options = myArgParser.parse_args()
- # Mapping to attributes
- self.inputFile = options.pfwlog
- self.outputFile = options.outputFile
- self.domainsFile = options.domainsFile
+ # Mapping to attributes
+ self.inputFile = options.pfwlog
+ self.outputFile = options.outputFile
+ self.domainsFile = options.domainsFile
- # Output report in xml if flag not set
- self.XMLreport = not options.rawFlag
+ # Output report in xml if flag not set
+ self.XMLreport = not options.rawFlag
- # Setting logger level
- levelCapped = min(options.debugLevel, len(self.levelTranslate) - 1)
- self.debugLevel = self.levelTranslate[levelCapped]
+ # Setting logger level
+ levelCapped = min(options.debugLevel, len(self.levelTranslate) - 1)
+ self.debugLevel = self.levelTranslate[levelCapped]
- # Setting ignore options
- errorToIgnore = []
- if options.ineligibleConfigurationApplicationFlag :
- errorToIgnore.append(Configuration.IneligibleConfigurationAppliedError)
+ # Setting ignore options
+ errorToIgnore = []
+ if options.ineligibleConfigurationApplicationFlag :
+ errorToIgnore.append(Configuration.IneligibleConfigurationAppliedError)
- if options.incoherentCriterionFlag:
- errorToIgnore.append(Criterion.ChangeRequestToNonAccessibleState)
+ if options.incoherentCriterionFlag:
+ errorToIgnore.append(Criterion.ChangeRequestToNonAccessibleState)
- self.errorToIgnore = tuple(errorToIgnore)
+ self.errorToIgnore = tuple(errorToIgnore)
def main():
- errorDuringLogParsing = -1
- errorDuringArgumentParsing = 1
+ errorDuringLogParsing = -1
+ errorDuringArgumentParsing = 1
- try:
- commandLineArguments = ArgumentParser()
- except LookupError as ex:
- logger.error("Error during argument parsing")
- logger.debug(str(ex))
- sys.exit(errorDuringArgumentParsing)
+ try:
+ commandLineArguments = ArgumentParser()
+ except LookupError as ex:
+ logger.error("Error during argument parsing")
+ logger.debug(str(ex))
+ sys.exit(errorDuringArgumentParsing)
- # Setting logger level
- logger.setLevel(commandLineArguments.debugLevel)
- logger.info("Log level set to: %s" %
- logging.getLevelName(commandLineArguments.debugLevel))
+ # Setting logger level
+ logger.setLevel(commandLineArguments.debugLevel)
+ logger.info("Log level set to: %s" %
+ logging.getLevelName(commandLineArguments.debugLevel))
- # Create tree from XML
- dom = xml.dom.minidom.parse(commandLineArguments.domainsFile)
+ # Create tree from XML
+ dom = xml.dom.minidom.parse(commandLineArguments.domainsFile)
- # Create element tree
- root = Root("DomainCoverage", dom)
+ # Create element tree
+ root = Root("DomainCoverage", dom)
- # Parse PFW events
- parser = ParsePFWlog(root.domains, root.criteria, commandLineArguments.errorToIgnore)
+ # Parse PFW events
+ parser = ParsePFWlog(root.domains, root.criteria, commandLineArguments.errorToIgnore)
- try:
- parser.parsePFWlog(commandLineArguments.inputFile.readlines())
- except CustomError as ex:
- logger.fatal("Error during parsing log file %s: %s" %
- (commandLineArguments.inputFile, ex))
- sys.exit(errorDuringLogParsing)
+ try:
+ parser.parsePFWlog(commandLineArguments.inputFile.readlines())
+ except CustomError as ex:
+ logger.fatal("Error during parsing log file %s: %s" %
+ (commandLineArguments.inputFile, ex))
+ sys.exit(errorDuringLogParsing)
- # Output report
- outputFile = commandLineArguments.outputFile
+ # Output report
+ outputFile = commandLineArguments.outputFile
- if not commandLineArguments.XMLreport :
- outputFile.write("%s\n" % root.dump(withCoverage=True, withNbUse=True))
- else :
- outputFile.write(root.exportToXML().toprettyxml())
+ if not commandLineArguments.XMLreport :
+ outputFile.write("%s\n" % root.dump(withCoverage=True, withNbUse=True))
+ else :
+ outputFile.write(root.exportToXML().toprettyxml())
if __name__ == "__main__" :
- """ Execute main if the python interpreter is running this module as the main program """
- main()
+ """ Execute main if the python interpreter is running this module as the main program """
+ main()