[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>

1 files changed, 726 insertions, 726 deletions

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 @@ logging.basicConfig(stream=sys.stderr, level=logging.WARNING, format=FORMAT)
 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 increasedRank(self):
-		self.rank += 1
-		return self
-
-	def __str__(self):
-		return self.linePrefix + \
-			self.rank * self.rankString + \
-			self.stringPrefix + \
-			self.string + \
-			self.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 __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"
-
-	def __init__(self, domains, criteria, ErrorsToIgnore=()):
-
-		self.domains = domains;
-		self.criteria = criteria;
-		self.ErrorsToIgnore = ErrorsToIgnore
+    MATCH = "match"
+    ACTION = "action"
+
+    def __init__(self, domains, criteria, ErrorsToIgnore=()):
+
+        self.domains = domains;
+        self.criteria = criteria;
+        self.ErrorsToIgnore = ErrorsToIgnore
 
-		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
+        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
 
-		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
-
-	def _criterionCreation(self, matchCriterionCreation):
-		# Unpack
-		criterionName, criterionType, currentCriterionStates, criterionStates = matchCriterionCreation.group(1, 2, 3, 4)
+    @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)
 
-		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))
-
-		self.domains.operationOnChild(path, usedOperation)
+        logger.info("Applying configuration %s from domain %s" % (
+                configurationName, domainName))
+
+        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)
-
-	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
+    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)
+
+        return newdoc
 
 # ============================
 # Command line argument parser
@@ -879,170 +879,170 @@ class Root(Element):
 
 
 class ArgumentParser:
-	"""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]
-
-	def __init__(self):
-
-		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:")
-
-			logger.warning(" - InputFile: stdin")
-			self.inputFile = sys.stdin
-
-			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)
-
-			logger.warning(" - Output format: xml")
-			self.XMLreport = True
-
-			logger.warning(" - Debug level: error")
-			self.debugLevel = logging.ERROR
-		else :
-
-			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)"
-					)
-
-			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"
-					)
-
-			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)"
-					)
-
-			# Process command line arguments
-			options = myArgParser.parse_args()
-
-			# 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
-
-			# 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)
-
-			if options.incoherentCriterionFlag:
-				errorToIgnore.append(Criterion.ChangeRequestToNonAccessibleState)
-
-			self.errorToIgnore = tuple(errorToIgnore)
+    """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]
+
+    def __init__(self):
+
+        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:")
+
+            logger.warning(" - InputFile: stdin")
+            self.inputFile = sys.stdin
+
+            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)
+
+            logger.warning(" - Output format: xml")
+            self.XMLreport = True
+
+            logger.warning(" - Debug level: error")
+            self.debugLevel = logging.ERROR
+        else :
+
+            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)"
+                    )
+
+            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"
+                    )
+
+            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)"
+                    )
+
+            # Process command line arguments
+            options = myArgParser.parse_args()
+
+            # 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
+
+            # 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)
+
+            if options.incoherentCriterionFlag:
+                errorToIgnore.append(Criterion.ChangeRequestToNonAccessibleState)
+
+            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()