private XDocument LoadXDocumentForTestfile(SchemaCorrectorTestFile testFile)
{
using (var fileStream = TestFilesFactory.GetStreamForTestFile(testFile))
{
var xDoc = XDocument.Load(fileStream);
return(xDoc);
}
}
public void CanParseFile()
{
using (var xsdStream = TestFilesFactory.GetStreamForTestFile(_testFile))
{
var schemaParser = new XmlSchemaParser(xsdStream);
var parsedFile = schemaParser.GetSchema();
Assert.NotNull(parsedFile);
}
}
private XmlSchema ParseSchema()
{
using (var xsdStream = TestFilesFactory.GetStreamForTestFile(_testFile))
{
var schemaParser = new XmlSchemaParser(xsdStream);
var parsedFile = schemaParser.GetSchema();
return(parsedFile);
}
}
public void CanParseDotCoverFiles(TestFile dotCoverTestFile)
{
using (var xmlStream = TestFilesFactory.GetTestFileStream(dotCoverTestFile))
{
var parser = new DotCoverParser(xmlStream);
var dotCoverReport = parser.ParseDotCoverReport();
Assert.NotNull(dotCoverReport);
Assert.NotEmpty(dotCoverReport.Assemblies);
}
}
public void ThrowsExceptionDueToInvalidSchema()
{
// A simpleContent element may not have elements defined within itself
var xsdStream = TestFilesFactory.GetStreamForTestFile(InvalidParserTestFile.SchemaWithComplexTypeWithSimpleContentButAlsoElementDefinition);
var schemaParser = new XmlSchemaParser(xsdStream);
Assert.Throws <InvalidDataException>(() =>
{
// ReSharper disable once UnusedVariable
var parsedFile = schemaParser.GetSchema();
});
}
public void InvalidDataExceptionWhenNoRootElementDefinedInSchema()
{
using (var stream = TestFilesFactory.GetStreamForTestFile(InvalidParserTestFile.SchemaWithoutRootElement))
{
Assert.Throws <InvalidDataException>(() =>
{
var schemaParser = new XmlSchemaParser(stream);
// ReSharper disable once UnusedVariable
var parsedSchema = schemaParser.GetSchema();
});
}
}
public void CanConvertDotCoverFiles(TestFile dotCoverTestFile)
{
using (var xmlStream = TestFilesFactory.GetTestFileStream(dotCoverTestFile))
{
var parser = new DotCoverParser(xmlStream);
var dotCoverReport = parser.ParseDotCoverReport();
var converter = new DotCoverToCoberturaConverter(dotCoverReport);
var conversionResult = converter.ConvertToCobertura();
Assert.NotNull(conversionResult);
Assert.NotEmpty(conversionResult.Packages);
}
}
public static string GetSchemaCorrectorCode(ParserTestFile testFile)
{
using (var schemaStream = TestFilesFactory.GetStreamForTestFile(testFile))
{
var xmlSchema = new XmlTools.Parser.XmlSchemaParser(schemaStream).GetSchema();
var codeGenOptions = new XmlTools.CodeGenerator.CodeGeneratorOptions
{
Namespace = GENERATED_CODE_NAMESPACE
};
var codeGen = new XmlTools.CodeGenerator.XmlSchemaCorrectorGenerator(xmlSchema, codeGenOptions);
var generatedCode = codeGen.GenerateCode();
return(generatedCode);
}
}
public void CanRead()
{
using (var xmlStream = TestFilesFactory.GetTestFileStream(DotCoverConverter.Core.Tests.TestFile.RegressionDotCoverMethodInfoExtractor))
{
var parser = new DotCoverParser(xmlStream);
var dotCoverReport = parser.ParseDotCoverReport();
Assert.NotNull(dotCoverReport);
Assert.NotEmpty(dotCoverReport.Assemblies);
Assert.NotEmpty(dotCoverReport.Assemblies
.SelectMany(a => a.Namespaces)
.SelectMany(n => n.Types)
.SelectMany(t => t.Methods));
}
}
public void ParsesFileCorrect()
{
var testFile = TestFile.DanglCalculatorDotCover;
using (var xmlStream = TestFilesFactory.GetTestFileStream(testFile))
{
var parser = new DotCoverParser(xmlStream);
var dotCoverReport = parser.ParseDotCoverReport();
Assert.Equal(6, dotCoverReport.Files.Count);
Assert.Equal(2, dotCoverReport.Assemblies.Count);
Assert.Equal("Dangl.Calculator", dotCoverReport.Assemblies.First().Name);
Assert.Equal(203, dotCoverReport.Assemblies.First().CoveredStatements);
Assert.Single(dotCoverReport.Assemblies.First().Namespaces);
}
}
public void UseCoveredStatementsForLinesCoveredInCobertura()
{
using (var xmlStream = TestFilesFactory.GetTestFileStream(DotCoverConverter.Core.Tests.TestFile.DanglCommonDotCover))
{
using (var convertedCoberturaStream = CoberturaConverter.ConvertDotCoverToCobertura(xmlStream))
{
var coberturaXml = XDocument.Load(convertedCoberturaStream);
var actualLinesCovered = coberturaXml.Descendants()
.Where(d => d.Name.LocalName == "coverage")
.Select(d => d.Attribute("lines-covered"))
.Select(a => a.Value)
.Single();
var expected = "492"; // 500 TotalStatements in dotCover report
Assert.Equal(expected, actualLinesCovered);
}
}
}
public void PutsFilenameOnNestedType()
{
using (var xmlStream = TestFilesFactory.GetTestFileStream(TestFile.NestedClassesDotCover))
{
var parser = new DotCoverParser(xmlStream);
var dotCoverReport = parser.ParseDotCoverReport();
var converter = new DotCoverToCoberturaConverter(dotCoverReport);
var conversionResult = converter.ConvertToCobertura();
var classes = conversionResult.Packages
.SelectMany(p => p.Classes)
.ToList();
Assert.All(classes, c => Assert.False(string.IsNullOrWhiteSpace(c.FileName)));
Assert.Equal(2, classes.Count);
Assert.All(classes, c => Assert.NotEqual("TypeWithoutStatements", c.Name)); // This type should not be in the Cobertura report due to missing filename
}
}
public void ParsesFileWithNestedClasses()
{
var testFile = TestFile.NestedClassesDotCover;
using (var xmlStream = TestFilesFactory.GetTestFileStream(testFile))
{
var parser = new DotCoverParser(xmlStream);
var dotCoverReport = parser.ParseDotCoverReport();
Assert.Single(dotCoverReport.Files);
var assembly = dotCoverReport.Assemblies.Single();
var @namespace = assembly.Namespaces.Single();
var types = @namespace.Types;
Assert.Equal(3, types.Count);
var typeWithoutStatements = types.First(t => t.Name == "TypeWithoutStatements");
Assert.Empty(typeWithoutStatements.Methods.SelectMany(m => m.Statements));
}
}
