Modified result parsing to meet OpenCover's format.

src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageMethod.cs

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Reflection;
 using System.Xml;
+using System.Xml.Linq;
 using ICSharpCode.Core;
 
 namespace ICSharpCode.CodeCoverage
@@ -39,34 +40,34 @@ namespace ICSharpCode.CodeCoverage
 			}
 		}
 		
-		public CodeCoverageMethod(string className, XmlReader reader)
+		public CodeCoverageMethod(string className, XElement reader)
 			: this(GetMethodName(reader), className, GetMethodAttributes(reader))
 		{
 			ReadMethodBodySize(reader);
 		}
 		
-		static string GetMethodName(XmlReader reader)
+		static string GetMethodName(XElement reader)
 		{
-			return reader.GetAttribute("name");
+			return reader.Element("Name").Value;
 		}
 		
-		static MethodAttributes GetMethodAttributes(XmlReader reader)
+		static MethodAttributes GetMethodAttributes(XElement reader)
 		{
-			string flags = reader.GetAttribute("flags");
+			//string flags = reader.GetAttribute("flags");
-			if (flags != null) {
+			//if (flags != null) {
-				try {
+			//    try {
-					return (MethodAttributes)Enum.Parse(typeof(MethodAttributes), flags);
+			//        return (MethodAttributes)Enum.Parse(typeof(MethodAttributes), flags);
-				} catch (ArgumentException) { }
+			//    } catch (ArgumentException) { }
-			}
+			//}
 			return MethodAttributes.Public;
 		}
 		
-		void ReadMethodBodySize(XmlReader reader)
+		void ReadMethodBodySize(XElement reader)
 		{
-			string bodySizeAsString = reader.GetAttribute("bodysize");
+			//string bodySizeAsString = reader.GetAttribute("bodysize");
-			if (bodySizeAsString != null) {
+			//if (bodySizeAsString != null) {
-				methodBodySize = Int32.Parse(bodySizeAsString);
+			//    methodBodySize = Int32.Parse(bodySizeAsString);
-			}
+			//}
 		}
 		
 		/// <summary>

src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageResults.cs

@@ -3,9 +3,13 @@
 
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
+using System.Linq;
 using System.Reflection;
+using System.Threading.Tasks;
 using System.Xml;
+using System.Xml.Linq;
 
 namespace ICSharpCode.CodeCoverage
 {
@@ -23,13 +27,13 @@ namespace ICSharpCode.CodeCoverage
 		{
 		}
 		
-		public CodeCoverageResults(XmlReader reader)
+		public CodeCoverageResults(XContainer reader)
 		{
 			ReadResults(reader);
 		}
 		
 		public CodeCoverageResults(TextReader reader)
-			: this(new XmlTextReader(reader))
+			: this(XDocument.Load(reader))
 		{
 		}
 		
@@ -46,60 +50,59 @@ namespace ICSharpCode.CodeCoverage
 			get { return modules; }
 		}
 		
-		void ReadResults(XmlReader reader)
+		void ReadResults(XContainer reader)
 		{
-			CodeCoverageModule currentModule = null;
+			IEnumerable<XElement> modules = reader.Descendants("Module").Where(m => m.Attribute("skippedDueTo") == null);
-			CodeCoverageMethod currentMethod = null;
+			foreach (XElement assembly in modules) {
-			string currentClassName = String.Empty;
+				AddAssembly(assembly);
-			
-			while (reader.Read()) {
-				switch (reader.NodeType) {
-					case XmlNodeType.Element:
-						if (reader.Name == "Type") {
-							currentModule = AddModule(reader);
-							currentClassName = reader.GetAttribute("name");
-						} else if ((reader.Name == "Method") && (currentModule != null)) {
-							currentMethod = AddMethod(currentModule, currentClassName, reader);
-						} else if ((reader.Name == "pt") && (currentMethod != null)) {
-							AddSequencePoint(currentMethod, reader);
-						} else if (reader.Name == "File") {
-							AddFileName(reader);
-						} else if (reader.Name == "Assembly") {
-							AddAssembly(reader);
 			}
-						break;
+			
+			foreach (XElement file in reader.Descendants("File")) {
+				AddFileName(file);
 			}
+
+			Parallel.ForEach(modules, RegisterAssembly);
 		}
-			reader.Close();
+
+		private void RegisterAssembly(XElement assembly)
+		{
+			var classNames =
+				assembly.Elements("Classes").Elements("Class").Where(
+					c =>
+					!c.Element("FullName").Value.Contains("__") && !c.Element("FullName").Value.Contains("<") &&
+					!c.Element("FullName").Value.Contains("/") && c.Attribute("skippedDueTo") == null).Select(
+						c => c.Element("FullName").Value).Distinct().OrderBy(name => name);
+			Parallel.ForEach(classNames, className => AddModule(assembly, className));
 		}
 		
 		/// <summary>
 		/// Add module if it does not already exist.
 		/// </summary>
-		CodeCoverageModule AddModule(XmlReader reader)
+		CodeCoverageModule AddModule(XElement reader, string className)
 		{
-			string assemblyName = GetAssemblyName(reader);
+			CodeCoverageModule module = new CodeCoverageModule(className);
-			foreach (CodeCoverageModule existingModule in modules) {
-				if (existingModule.Name == assemblyName) {
-					return existingModule;
-				}
-			}
-			
-			CodeCoverageModule module = new CodeCoverageModule(assemblyName);
 			modules.Add(module);
-			return module;
-		}
 
-		string GetAssemblyName(XmlReader reader)
+			var methods = reader
-		{
+				.Elements("Classes")
-			string id = reader.GetAttribute("asmref");
+				.Elements("Class")
-			return GetAssembly(id);
+				.Where(c => c.Element("FullName").Value.StartsWith(className, StringComparison.Ordinal))
+				.Elements("Methods")
+				.Elements("Method");
+
+			Parallel.ForEach(methods, method => AddMethod(module, className, method));
+			return module;
 		}
 		
-		CodeCoverageMethod AddMethod(CodeCoverageModule module, string className, XmlReader reader)
+		CodeCoverageMethod AddMethod(CodeCoverageModule module, string className, XElement reader)
 		{
 			CodeCoverageMethod method = new CodeCoverageMethod(className, reader);
 			module.Methods.Add(method);
+			
+			var seqpntsOfFile = reader
+				.Elements("SequencePoints")
+				.Elements("SequencePoint");
+			Parallel.ForEach(seqpntsOfFile, sp => AddSequencePoint(method, sp, reader));
 			return method;
 		}
 		
@@ -109,20 +112,20 @@ namespace ICSharpCode.CodeCoverage
 		/// for types that are not part of the project but types from
 		/// the .NET framework. 
 		/// </summary>
-		void AddSequencePoint(CodeCoverageMethod method, XmlReader reader)
+		void AddSequencePoint(CodeCoverageMethod method, XElement reader, XElement methodNode)
 		{
-			string fileName = GetFileName(reader);
+			string fileName = GetFileName(methodNode);
 			
 			CodeCoverageSequencePoint sequencePoint = 
 				new CodeCoverageSequencePoint(fileName, reader);
 			method.SequencePoints.Add(sequencePoint);
 		}
 		
-		string GetFileName(XmlReader reader)
+		string GetFileName(XElement reader)
 		{
-			string fileId = reader.GetAttribute("fid");
+			XElement fileId = reader.Element("FileRef");
 			if (fileId != null) {
-				return GetFileName(fileId);
+				return GetFileName(fileId.Attribute("uid").Value);
 			}
 			return String.Empty;
 		}
@@ -156,20 +159,20 @@ namespace ICSharpCode.CodeCoverage
 		/// <summary>
 		/// Saves the filename and its associated id for reference.
 		/// </summary>
-		void AddFileName(XmlReader reader)
+		void AddFileName(XElement reader)
 		{
-			string id = reader.GetAttribute("id");
+			string id = reader.Attribute("uid").Value;
-			string fileName = reader.GetAttribute("url");
+			string fileName = reader.Attribute("fullPath").Value;
 			fileNames.Add(id, fileName);
 		}
 
 		/// <summary>
 		/// Saves the assembly and its associated id for reference.
 		/// </summary>
-		void AddAssembly(XmlReader reader)
+		void AddAssembly(XElement reader)
 		{
-			string id = reader.GetAttribute("id");
+			string id = reader.Attribute("hash").Value;
-			string name = reader.GetAttribute("name");
+			string name = reader.Element("ModuleName").Value;
 			assemblies.Add(id, name);
 		}
 	}

src/AddIns/Analysis/CodeCoverage/Project/Src/CodeCoverageSequencePoint.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Xml;
+using System.Xml.Linq;
 
 namespace ICSharpCode.CodeCoverage
 {
@@ -28,25 +29,25 @@ namespace ICSharpCode.CodeCoverage
 			this.Length = length;
 		}
 		
-		public CodeCoverageSequencePoint(string document, XmlReader reader)
+		public CodeCoverageSequencePoint(string document, XElement reader)
 		{
 			this.Document = document;
 			Read(reader);
 		}
 
-		void Read(XmlReader reader)
+		void Read(XElement reader)
 		{
-			VisitCount = GetInteger(reader, "visit");
+			VisitCount = GetInteger(reader, "vc");
 			Line = GetInteger(reader, "sl");
 			Column = GetInteger(reader, "sc");
 			EndLine = GetInteger(reader, "el");
 			EndColumn = GetInteger(reader, "ec");
-			Length = GetInteger(reader, "len");
+			Length = EndColumn - Column; //GetInteger(reader, "len");
 		}
 		
-		int GetInteger(XmlReader reader, string attributeName)
+		int GetInteger(XElement reader, string attributeName)
 		{
-			string attributeValue = reader.GetAttribute(attributeName);
+			string attributeValue = reader.Attribute(attributeName).Value;
 			return GetInteger(attributeValue);
 		}