Add support for Opencover format based on opencover plugin

Signed-off-by: Valentin Delaye <jonesbusy@gmail.com>

src/main/java/edu/hm/hafner/coverage/parser/OpenCoverParser.java

@@ -0,0 +1,168 @@
+package edu.hm.hafner.coverage.parser;
+
+import java.io.Reader;
+import java.nio.file.Paths;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.UUID;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLEventReader;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.events.StartElement;
+import javax.xml.stream.events.XMLEvent;
+
+import edu.hm.hafner.coverage.CoverageParser;
+import edu.hm.hafner.coverage.FileNode;
+import edu.hm.hafner.coverage.ModuleNode;
+import edu.hm.hafner.coverage.Node;
+import edu.hm.hafner.coverage.PackageNode;
+import edu.hm.hafner.util.FilteredLog;
+import edu.hm.hafner.util.PathUtil;
+import edu.hm.hafner.util.SecureXmlParserFactory;
+import edu.hm.hafner.util.SecureXmlParserFactory.ParsingException;
+
+/**
+ * A parser which parses reports made by OpenCover into a Java Object Model.
+ *
+ */
+public class OpenCoverParser extends CoverageParser {
+
+    private static final long serialVersionUID = 1L;
+
+    private static final PathUtil PATH_UTIL = new PathUtil();
+
+    /** XML elements. */
+    private static final QName MODULE = new QName("Module");
+    private static final QName CLASS = new QName("Class");
+    private static final QName METHOD = new QName("Method");
+    private static final QName CLASS_NAME = new QName("FullName");
+    private static final QName METHOD_NAME = new QName("Name");
+    private static final QName MODULE_NAME = new QName("ModuleName");
+    private static final QName FILE = new QName("File");
+
+    private static final QName UID = new QName("uid");
+    private static final QName FULL_PATH = new QName("fullPath");
+    private static final QName CLASS_COMPLEXITY = new QName("maxCyclomaticComplexity");
+    private static final QName METHOD_COMPLEXITY = new QName("cyclomaticComplexity");
+
+    @Override
+    protected ModuleNode parseReport(final Reader reader, final FilteredLog log) {
+        try {
+            var eventReader = new SecureXmlParserFactory().createXmlEventReader(reader);
+            var root = new ModuleNode("-");
+            boolean isEmpty = true;
+            while (eventReader.hasNext()) {
+                XMLEvent event = eventReader.nextEvent();
+                if (event.isStartElement()) {
+                    var startElement = event.asStartElement();
+                    var tagName = startElement.getName();
+                    if (MODULE.equals(tagName)) {
+                        readPackage(eventReader, root, startElement, log);
+                        isEmpty = false;
+                    }
+                }
+            }
+            if (isEmpty) {
+                throw new NoSuchElementException("No coverage information found in the specified file.");
+            }
+            return root;
+        }
+        catch (XMLStreamException exception) {
+            throw new ParsingException(exception);
+        }
+    }
+
+    private void readPackage(final XMLEventReader reader, final ModuleNode root,
+            final StartElement currentStartElement, final FilteredLog log) throws XMLStreamException {
+
+        Map<String, String> files = new LinkedHashMap<>();
+        PackageNode packageNode = null;
+        while (reader.hasNext()) {
+            XMLEvent event = reader.nextEvent();
+            if (event.isStartElement()) {
+                var nextElement = event.asStartElement();
+                if (CLASS.equals(nextElement.getName())) {
+                    readClass(reader, nextElement, log);
+                }
+                else if (FILE.equals(nextElement.getName())) {
+                    var fileName = getValueOf(nextElement, FULL_PATH);
+                    var uid = getValueOf(nextElement, UID);
+                    var relativePath = PATH_UTIL.getRelativePath(fileName);
+                    files.put(uid, relativePath);
+                }
+                else if (MODULE_NAME.equals(nextElement.getName())) {
+                    String packageName = reader.nextEvent().asCharacters().getData();
+                    packageNode = root.findOrCreatePackageNode(packageName);
+                }
+            }
+        }
+
+        // Creating all file nodes
+        for (var entry : files.entrySet()) {
+            packageNode.findOrCreateFileNode(getFileName(entry.getValue()), getTreeStringBuilder().intern(entry.getValue()));
+        }
+
+    }
+
+    private void readFile(final XMLEventReader reader, final ModuleNode root,
+            final StartElement currentStartElement, final FilteredLog log) throws XMLStreamException {
+
+        PackageNode packageNode = null;
+        while (reader.hasNext()) {
+            XMLEvent event = reader.nextEvent();
+            if (event.isStartElement()) {
+                var nextElement = event.asStartElement();
+                if (CLASS.equals(nextElement.getName())) {
+                    readClass(reader, nextElement, log);
+                }
+                else if (MODULE_NAME.equals(nextElement.getName())) {
+                    String packageName = reader.nextEvent().asCharacters().getData();
+                    packageNode = root.findOrCreatePackageNode(packageName);
+                }
+            }
+        }
+    }
+
+    private void readClass(final XMLEventReader reader, final StartElement parentElement, final FilteredLog log) throws XMLStreamException {
+        while (reader.hasNext()) {
+            XMLEvent event = reader.nextEvent();
+            if (event.isStartElement()) {
+                var nextElement = event.asStartElement();
+                if (CLASS_NAME.equals(nextElement.getName())) {
+                    String className = reader.nextEvent().asCharacters().getData();
+                }
+            }
+        }
+    }
+
+    private int readComplexity(final String c) {
+        try {
+            return Math.round(Float.parseFloat(c)); // some reports use float values
+        }
+        catch (NumberFormatException ignore) {
+            return 0;
+        }
+    }
+
+    private Node createClassNode(final FileNode file, final StartElement parentElement) {
+        // Read summary has name
+        return file.createClassNode(UUID.randomUUID().toString());
+    }
+
+    protected static String getValueOf(final StartElement element, final QName attribute) {
+        return getOptionalValueOf(element, attribute).orElseThrow(
+                () -> new NoSuchElementException(String.format(
+                        "Could not obtain attribute '%s' from element '%s'", attribute, element)));
+    }
+
+    private String getFileName(final String relativePath) {
+        var path = Paths.get(PATH_UTIL.getAbsolutePath(relativePath)).getFileName();
+        if (path == null) {
+            return relativePath;
+        }
+        return path.toString();
+    }
+
+}

src/main/java/edu/hm/hafner/coverage/registry/ParserRegistry.java

@@ -7,6 +7,7 @@
 import edu.hm.hafner.coverage.parser.CoberturaParser;
 import edu.hm.hafner.coverage.parser.JacocoParser;
 import edu.hm.hafner.coverage.parser.JunitParser;
+import edu.hm.hafner.coverage.parser.OpenCoverParser;
 import edu.hm.hafner.coverage.parser.PitestParser;
 
 /**
@@ -18,6 +19,7 @@ public class ParserRegistry {
     /** Supported parsers. */
     public enum CoverageParserType {
         COBERTURA,
+        OPENCOVER,
         JACOCO,
         PIT,
         JUNIT
@@ -56,6 +58,8 @@ public CoverageParser get(final CoverageParserType parser, final ProcessingMode
         switch (parser) {
             case COBERTURA:
                 return new CoberturaParser(processingMode);
+            case OPENCOVER:
+                return new OpenCoverParser();
             case JACOCO:
                 return new JacocoParser();
             case PIT:

src/test/java/edu/hm/hafner/coverage/parser/OpenCoverParserTest.java

@@ -0,0 +1,158 @@
+package edu.hm.hafner.coverage.parser;
+
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.jupiter.api.Test;
+import org.junitpioneer.jupiter.DefaultLocale;
+
+import edu.hm.hafner.coverage.ClassNode;
+import edu.hm.hafner.coverage.Coverage;
+import edu.hm.hafner.coverage.Coverage.CoverageBuilder;
+import edu.hm.hafner.coverage.CoverageParser;
+import edu.hm.hafner.coverage.CyclomaticComplexity;
+import edu.hm.hafner.coverage.FileNode;
+import edu.hm.hafner.coverage.LinesOfCode;
+import edu.hm.hafner.coverage.Metric;
+import edu.hm.hafner.coverage.ModuleNode;
+import edu.hm.hafner.coverage.Node;
+import edu.hm.hafner.coverage.PackageNode;
+import edu.hm.hafner.coverage.Percentage;
+
+import static edu.hm.hafner.coverage.Metric.CLASS;
+import static edu.hm.hafner.coverage.Metric.FILE;
+import static edu.hm.hafner.coverage.Metric.*;
+import static edu.hm.hafner.coverage.assertions.Assertions.*;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+
+@DefaultLocale("en")
+class OpenCoverParserTest extends AbstractParserTest {
+
+    private static final String PROJECT_NAME = "Java coding style";
+    private static final String EMPTY = "-";
+
+    @Override
+    CoverageParser createParser() {
+        return new OpenCoverParser();
+    }
+
+    @Test
+    void shouldReadReport() {
+        readExampleReport();
+    }
+
+    @Test
+    void shouldCreatePackageName() {
+        ModuleNode tree = readExampleReport();
+
+        String fileName = "MyLogging.FancyClass.cs";
+        assertThat(tree.find(FILE, fileName)).isNotEmpty()
+                .hasValueSatisfying(node -> assertThat(node).hasName(fileName)
+                        .hasParentName("MyLogging")
+                        .hasParent()
+                        .isNotRoot());
+
+        tree.splitPackages();
+        assertThat(tree.find(FILE, fileName)).isNotEmpty()
+                .hasValueSatisfying(node -> assertThat(node).hasName(fileName)
+                        .hasParentName("MyLogging")
+                        .hasParent()
+                        .isNotRoot());
+    }
+
+    @Test
+    void shouldSplitPackages() {
+        ModuleNode tree = readExampleReport();
+
+        tree.splitPackages();
+
+        verifyCoverageMetrics(tree);
+
+        assertThat(tree.getAll(PACKAGE)).hasSize(1);
+
+        // TODO: Assertions
+    }
+
+    @Test
+    void shouldFilterByFiles() {
+        var root = readExampleReport();
+
+        assertThat(root.getAll(MODULE)).hasSize(1);
+        assertThat(root.getAll(PACKAGE)).hasSize(1);
+        assertThat(root.getAll(FILE)).hasSize(3);
+
+        // TODO: Not yet implemented on parser
+        //assertThat(root.getAll(CLASS)).hasSize(18);
+        //assertThat(root.getAll(METHOD)).hasSize(102);
+
+        // TODO: Assertions
+    }
+
+    private void verifyCoverageMetrics(final Node tree) {
+        List<Node> nodes = tree.getAll(FILE);
+
+        long missedInstructions = 0;
+        long coveredInstructions = 0;
+        long missedBranches = 0;
+        long coveredBranches = 0;
+        long missedLines = 0;
+        long coveredLines = 0;
+        for (Node node : nodes) {
+            var instructionCoverage = (Coverage) node.getValue(INSTRUCTION).orElse(Coverage.nullObject(INSTRUCTION));
+            missedInstructions = missedInstructions + instructionCoverage.getMissed();
+            coveredInstructions = coveredInstructions + instructionCoverage.getCovered();
+            var branchCoverage = (Coverage) node.getValue(BRANCH).orElse(Coverage.nullObject(BRANCH));
+            missedBranches = missedBranches + branchCoverage.getMissed();
+            coveredBranches = coveredBranches + branchCoverage.getCovered();
+            var lineCoverage = (Coverage) node.getValue(LINE).orElse(Coverage.nullObject(LINE));
+            missedLines = missedLines + lineCoverage.getMissed();
+            coveredLines = coveredLines + lineCoverage.getCovered();
+        }
+
+        // TODO: Assertions
+    }
+
+    private PackageNode getPackage(final Node node) {
+        var children = node.getChildren();
+        assertThat(children).hasSize(1).first().isInstanceOf(PackageNode.class);
+
+        return (PackageNode) children.get(0);
+    }
+
+    private ClassNode getFirstClass(final Node node) {
+        var packageNode = getPackage(node);
+
+        var children = packageNode.getChildren();
+        assertThat(children).isNotEmpty().first().isInstanceOf(ClassNode.class);
+
+        return (ClassNode) children.get(0);
+    }
+
+    private FileNode getFileNode(final ModuleNode a) {
+        var fileNodes = a.getAllFileNodes();
+        assertThat(fileNodes).hasSize(1);
+
+        var lineRange = fileNodes.get(0);
+        assertThat(lineRange)
+                .hasName("MyLogging.FancyClass.cs")
+                .hasRelativePath("opencovertests\\MyLogging.FancyClass.cs");
+
+        return lineRange;
+    }
+
+    private static Coverage getCoverage(final Node node, final Metric metric) {
+        return (Coverage) node.getValue(metric).get();
+    }
+
+    private ModuleNode readExampleReport() {
+        return readReport("opencover.xml", new OpenCoverParser());
+    }
+
+    @Override
+    protected String getFolder() {
+        return "opencover";
+    }
+
+}

src/test/java/edu/hm/hafner/coverage/registry/ParserRegistryTest.java

@@ -7,6 +7,7 @@
 import edu.hm.hafner.coverage.parser.JacocoParser;
 import edu.hm.hafner.coverage.parser.JunitParser;
 import edu.hm.hafner.coverage.parser.PitestParser;
+import edu.hm.hafner.coverage.parser.OpenCoverParser;
 import edu.hm.hafner.coverage.registry.ParserRegistry.CoverageParserType;
 
 import static org.assertj.core.api.Assertions.*;
@@ -24,6 +25,9 @@ void shouldCreateSomeParsers() {
                 .isInstanceOf(PitestParser.class);
         assertThat(registry.get(CoverageParserType.JUNIT, ProcessingMode.IGNORE_ERRORS))
                 .isInstanceOf(JunitParser.class);
+        assertThat(registry.get(CoverageParserType.COBERTURA.name(), ProcessingMode.FAIL_FAST)).isInstanceOf(CoberturaParser.class);
+        assertThat(registry.get(CoverageParserType.JACOCO, ProcessingMode.IGNORE_ERRORS)).isInstanceOf(JacocoParser.class);
+        assertThat(registry.get(CoverageParserType.OPENCOVER, ProcessingMode.IGNORE_ERRORS)).isInstanceOf(OpenCoverParser.class);
     }
 
     @Test