xref: /external/parameter-framework/upstream/tools/coverage/coverage.py

#!/usr/bin/env python3

# Copyright (c) 2011-2014, Intel Corporation
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation and/or
# other materials provided with the distribution.
#
# 3. Neither the name of the copyright holder nor the names of its contributors
# may be used to endorse or promote products derived from this software without
# specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


"""
Generate a coverage report by parsing parameter framework log.

The coverage report contains the:
 - domain
 - configuration
 - rule
 - criterion
basic coverage statistics.
"""

import xml.dom.minidom
import sys
import re
import logging

FORMAT = '%(levelname)s: %(message)s'
logging.basicConfig(stream=sys.stderr, level=logging.WARNING, format=FORMAT)
logger = logging.getLogger("Coverage")

class CustomError(Exception):
    pass

class ChildError(CustomError):
    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)

class DuplicatedChildError(ChildError):
    def __str__(self):
        return 'Add existing child "%s" in "%s".' % (self.child, self.parent)

class Element():
    """Root class for all coverage elements"""
    tag = "element"

    def __init__(self, name):

        self.parent = None
        self.children = []

        self.nbUse = 0

        self.name = name

        self.debug("New element")


    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 getName(self, default=""):
        return self.name or default

    def hasChildren(self):
        return bool(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 getChildFromName(self, childName):

        for child in self.children :

            if child.getName() == childName :
                return child

        self.debug('Child "%s" not found' % childName, logging.ERROR)

        self.debug("Child list :")

        for child in self.children :
            self.debug("  - %s" % child)

        raise ChildNotFoundError(self, childName)


    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 _getElementNames(self, elementList):
        return (substate.name for substate in elementList)

    def _description(self, withCoverage, withNbUse):
        description = self.name

        if withNbUse or withCoverage :
            description += " has been used " + str(self.nbUse) + " time"

        if withCoverage :
            description += self._coverageFormating(self._getCoverage())

        return description


    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())

        nbcoverageDependence = len(coverageDependanceElements)

        if nbcoverageDependence == 0:
            if self.nbUse == 0:
                return 0
            else:
                return 1

        coverageDependenceValues = (depElement._getCoverage()
                for depElement in coverageDependanceElements)

        return sum(coverageDependenceValues) / nbcoverageDependence

    def _getCoverageDependanceElements(self):
        return self.children

    def _coverageFormating(self, coverage):
        # If no coverage provided
        if not coverage :
            return ""

        # Calculate coverage
        return " (%s coverage)" % self._number2percent(coverage)

    @staticmethod
    def _number2percent(number):
        """Format a number to a integer % string

        example: _number2percent(0.6666) -> "67%"
        """
        return "{0:.0f}%".format(100 * number)


    def _dumpDescription(self, withCoverage, withNbUse):

        self.debug("yelding description")
        yield RankedLine(self._description(withCoverage, withNbUse), lineSuffix="")

        for dumped in self._dumpPropagate(withCoverage, withNbUse) :
            yield dumped

    def _dumpPropagate(self, withCoverage, withNbUse):

        for child in self.children :
            for dumpedDescription in child._dumpDescription(withCoverage, withNbUse) :
                yield dumpedDescription.increasedRank()


    def dump(self, withCoverage=False, withNbUse=True):

        return "\n".join(
                str(dumpedDescription) for dumpedDescription in
                        self._dumpDescription(withCoverage, withNbUse))

    def exportToXML(self, document, domElement=None):
        if domElement == None:
            domElement = document.createElement(self.tag)

        self._XMLaddAttributes(domElement)

        for child in self.children :
            domElement.appendChild(child.exportToXML(document))

        return domElement

    def _XMLaddAttributes(self, domElement):
        attributes = self._getXMLAttributes()

        coverage = self._getCoverage()
        if coverage != None :
            attributes["Coverage"] = self._number2percent(coverage)

        for key, value in attributes.items():
            domElement.setAttribute(key, value)

    def _getXMLAttributes(self):
        return {
                "Name": self.name,
                "NbUse": str(self.nbUse)
                }

    def _incNbUse(self):
        self.nbUse += 1

    def childUsed(self, child):
        self._incNbUse()
        # Propagate to parent
        self._tellParentThatChildUsed()

    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 hasBeenUsed(self):
        return self.nbUse > 0

    def operationOnChild(self, path, operation):

        if path:
            return self._operationPropagate(path, operation)
        else :
            self.debug("operating on self")
            return operation(self)

    def _operationPropagate(self, path, operation):

        childName = path.pop(0)
        child = self.getChildFromName(childName)

        return child.operationOnChild(path, operation)



    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):

            # 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)

    def _logDebug(self, rankedLine, level):

        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 _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 = []

        self.path.append(classConstructor.tag)


class DomPopulatedElement(Element):
    """Default child populate

    Look for each dom element with tag specified in self.tag
    and instantiate it with the dom element
    """
    childClasses = []

    def populate(self, dom):

        for childDomElementLocation in self.childClasses :

            self.debug("Looking for child %s in path %s" % (
                childDomElementLocation.path[-1], childDomElementLocation.path))

            for childDomElement in self._findChildFromTagPath(dom, childDomElementLocation.path) :

                childElement = childDomElementLocation.classConstructor(childDomElement)
                self.addChild(childElement)

                childElement.populate(childDomElement)

    def _findChildFromTagPath(self, dom, path):
        if not path :
            yield dom
        else :
            # Copy list
            path = list(path)

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

            for elementByTag in dom.getElementsByTagName(tag) :

                self.debug("Found element: %s" % elementByTag)

                # If the same tag is found
                if elementByTag in dom.childNodes :

                    # 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)

        isApplicable = self._isApplicable(criteria, childApplicability)

        if isApplicable :
            self._incNbUse()

        self.debug("Rule applicability: %s" % isApplicable)
        assert(isApplicable == True or isApplicable == False)

        return isApplicable


    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)


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)
            }

    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)

    def _isApplicable(self, criteria, childApplicability):

        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

    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):

        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)

        return applicability

class RootRule(DomPopulatedElement, Rule):
    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 _getCoverageDependanceElements(self):
        return self._getDescendants()


class CriteronStates(Element):
    """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()

        matches = [child for child in self.children if child == criteria]

        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)

        currentcriteria.parentUsed()



class Configuration(FromDomElement, DomPopulatedElement):
    tag = "Configuration"
    childClasses = []

    class IneligibleConfigurationAppliedError(CustomError):

        def __init__(self, configuration, criteria):
            self.configuration = configuration
            self.criteria = criteria

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

    def __init__(self, DomElement):
        super().__init__(DomElement)

        self.rootRule = RootRule("RootRule")
        self.addChild(self.rootRule)

        self.criteronStates = CriteronStates("CriterionStates")
        self.addChild(self.criteronStates)

    def populate(self, dom):
        # Delegate to rootRule
        self.rootRule.populate(dom)

    def _getCoverage(self):
        # Delegate to rootRule
        return self.rootRule._getCoverage()

    def used(self, criteria):

        self._incNbUse()

        # Propagate use to parents
        self._tellParentThatChildUsed()

        # Propagate to criterion coverage
        self.criteronStates.parentUsed(criteria.export())

        # Propagate to rules
        if not self.rootRule.usedIfApplicable(criteria) :

            self.debug("Applied but rule does not match current "
                       "criteria (parent: %s) " % self.parent.name,
                    logging.ERROR)

            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()

        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"])]


class Domains(DomPopulatedElement):
    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

class DebugRankedLine(RankedLine):

    def __init__(self, string, lineSuffix=""):
        super().__init__(string,
                stringPrefix="",
                rankString="   ",
                linePrefix="",
                lineSuffix=lineSuffix)


class CriterionState(Element):
    tag = "CriterionState"
    def used(self):
        self._incNbUse()


class Criterion(Element):
    tag = "Criterion"
    inclusivenessTranslate = {True: "Inclusive", False: "Exclusive"}

    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 __init__(self, name, isInclusif,
                stateNamesList, currentStateNamesList,
                ignoreIntegrity=False):
        super().__init__(name)
        self.isInclusif = isInclusif

        for state in stateNamesList :
            self.addChild(CriterionState(state))

        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 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")

        newCurrentState = []
        for subStateName in subStateNames :
            subState = self.getChildFromName(subStateName)
            subState.used()
            newCurrentState.append(subState)

        self.currentState = newCurrentState

        self._incNbUse()
        self._tellParentThatChildUsed()

    def isIntegre(self, subStateNames):
        return self.isInclusif or len(subStateNames) == 1

    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 stateIncludes(self, subStateName):
        subStateCurrentNames = list(self._getElementNames(self.currentState))

        self.debug("Testing if %s is included in %s" % (subStateName, subStateCurrentNames))

        isIncluded = subStateName in subStateCurrentNames
        self.debug("IsIncluded: %s" % isIncluded)

        return isIncluded


    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


class Criteria(Element):
    tag = "Criteria"

    class DuplicatedCriterionError(DuplicatedChildError):
        pass

    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

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

class ParsePFWlog():
    MATCH = "match"
    ACTION = "action"

    class ChangeRequestOnUnknownCriterion(CustomError):
        def __init__(self, criterion):
            self.criterion = criterion

        def __str__(self):
            return ("Change request on an unknown criterion %s." %
                self.criterion)

    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

        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
                    }
                ]

    @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, ", ")

        criterionIsInclusif = {"exclusive" : False, "inclusive" : True}[criterionType]

        currentcriterionStateList = self._formatCriterionList(currentCriterionStates, "|")

        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()
            )



    def _changingCriterion(self, matchChangingCriterion):
        # Unpack
        criterionName, newCriterionSubStateNames = matchChangingCriterion.group(1, 2)

        newCriterionState = self._formatCriterionList(newCriterionSubStateNames, "|")

        logger.info("Changing criterion %s to %s" % (criterionName , newCriterionState))

        path = [criterionName]
        changeCriterionOperation = lambda criterion : criterion.changeState(newCriterionState)
        try:
            self.criteria.operationOnChild(path, changeCriterionOperation)
        except ChildNotFoundError:
            raise self.ChangeRequestOnUnknownCriterion(criterionName)

    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)

        # 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)


    def _digest(self, lineLogType, lineLog):

        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, 1): # line number starts at 1

            logger.debug("Parsing line :%s" % lineLog.rstrip())

            digested = (self._digest(lineLogType, lineLog)
                    for lineLogType in self.lineLogTypes)

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

                # 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()
        document = impl.createDocument(namespaceURI=None, qualifiedName=self.tag, doctype=None)
        super().exportToXML(document, document.documentElement)

        return document

# ============================
# Command line argument parser
# ============================


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-unknown-criterion',
                        dest="unknwonCriterionFlag",
                        action='store_true',
                        help="ignore unknown criterion"
                    )

            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)

            if options.unknwonCriterionFlag:
                errorToIgnore.append(ParsePFWlog.ChangeRequestOnUnknownCriterion)

            self.errorToIgnore = tuple(errorToIgnore)



def main():

    errorDuringLogParsing = -1
    errorDuringArgumentParsing = 1

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

    # Create tree from XML
    dom = xml.dom.minidom.parse(commandLineArguments.domainsFile)

    # Create element tree
    root = Root("DomainCoverage", dom)

    # 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)

    # 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 __name__ == "__main__" :
    """ Execute main if the python interpreter is running this module as the main program """
    main()