public CoveragePrepareResult PrepareModules()
{
string[] modules = _instrumentationHelper.GetCoverableModules(_moduleOrAppDirectory, _includeDirectories, _includeTestAssembly);
Array.ForEach(_excludeFilters ?? Array.Empty <string>(), filter => _logger.LogVerbose($"Excluded module filter '{filter}'"));
Array.ForEach(_includeFilters ?? Array.Empty <string>(), filter => _logger.LogVerbose($"Included module filter '{filter}'"));
Array.ForEach(_excludedSourceFiles ?? Array.Empty <string>(), filter => _logger.LogVerbose($"Excluded source files filter '{FileSystem.EscapeFileName(filter)}'"));
_excludeFilters = _excludeFilters?.Where(f => _instrumentationHelper.IsValidFilterExpression(f)).ToArray();
_includeFilters = _includeFilters?.Where(f => _instrumentationHelper.IsValidFilterExpression(f)).ToArray();
foreach (var module in modules)
{
if (_instrumentationHelper.IsModuleExcluded(module, _excludeFilters) ||
!_instrumentationHelper.IsModuleIncluded(module, _includeFilters))
{
_logger.LogVerbose($"Excluded module: '{module}'");
continue;
}
var instrumenter = new Instrumenter(module,
_identifier,
_excludeFilters,
_includeFilters,
_excludedSourceFiles,
_excludeAttributes,
_doesNotReturnAttributes,
_singleHit,
_skipAutoProps,
_logger,
_instrumentationHelper,
_fileSystem,
_sourceRootTranslator,
_cecilSymbolHelper);
if (instrumenter.CanInstrument())
{
_instrumentationHelper.BackupOriginalModule(module, _identifier);
// Guard code path and restore if instrumentation fails.
try
{
InstrumenterResult result = instrumenter.Instrument();
if (!instrumenter.SkipModule)
{
_results.Add(result);
_logger.LogVerbose($"Instrumented module: '{module}'");
}
}
catch (Exception ex)
{
_logger.LogWarning($"Unable to instrument module: {module} because : {ex.Message}");
_instrumentationHelper.RestoreOriginalModule(module, _identifier);
}
}
}
return(new CoveragePrepareResult()
{
Identifier = _identifier,
ModuleOrDirectory = _moduleOrAppDirectory,
MergeWith = _mergeWith,
UseSourceLink = _useSourceLink,
Results = _results.ToArray()
});
}
public void CoveragePrepareResult_SerializationRoundTrip()
{
var cpr = new CoveragePrepareResult();
cpr.Identifier = "Identifier";
cpr.MergeWith = "MergeWith";
cpr.ModuleOrDirectory = "Module";
cpr.UseSourceLink = true;
var ir = new InstrumenterResult();
ir.HitsFilePath = "HitsFilePath";
ir.Module = "Module";
ir.ModulePath = "ModulePath";
ir.SourceLink = "SourceLink";
ir.HitCandidates.Add(new HitCandidate(true, 1, 2, 3));
ir.HitCandidates.Add(new HitCandidate(false, 4, 5, 6));
var doc = new Document()
{
Index = 0,
Path = "Path0"
};
doc.Lines.Add(0, new Line()
{
Class = "Class0",
Hits = 0,
Method = "Method0",
Number = 0
});
doc.Branches.Add(new BranchKey(0, 0),
new Branch()
{
Class = "Class0",
EndOffset = 0,
Hits = 0,
Method = "Method",
Number = 0,
Offset = 0,
Ordinal = 0,
Path = 0
});
var doc2 = new Document()
{
Index = 1,
Path = "Path1"
};
doc2.Lines.Add(1, new Line()
{
Class = "Class1",
Hits = 1,
Method = "Method1",
Number = 1
});
doc2.Branches.Add(new BranchKey(1, 1),
new Branch()
{
Class = "Class1",
EndOffset = 1,
Hits = 1,
Method = "Method1",
Number = 1,
Offset = 1,
Ordinal = 1,
Path = 1
});
ir.Documents.Add("key", doc);
ir.Documents.Add("key2", doc2);
cpr.Results = new InstrumenterResult[] { ir };
var roundTrip = CoveragePrepareResult.Deserialize(CoveragePrepareResult.Serialize(cpr));
Assert.Equal(cpr.Identifier, roundTrip.Identifier);
Assert.Equal(cpr.MergeWith, roundTrip.MergeWith);
Assert.Equal(cpr.ModuleOrDirectory, roundTrip.ModuleOrDirectory);
Assert.Equal(cpr.UseSourceLink, roundTrip.UseSourceLink);
for (int i = 0; i < cpr.Results.Length; i++)
{
Assert.Equal(cpr.Results[i].HitsFilePath, roundTrip.Results[i].HitsFilePath);
Assert.Equal(cpr.Results[i].Module, roundTrip.Results[i].Module);
Assert.Equal(cpr.Results[i].ModulePath, roundTrip.Results[i].ModulePath);
Assert.Equal(cpr.Results[i].SourceLink, roundTrip.Results[i].SourceLink);
for (int k = 0; k < cpr.Results[i].HitCandidates.Count; k++)
{
Assert.Equal(cpr.Results[i].HitCandidates[k].start, roundTrip.Results[i].HitCandidates[k].start);
Assert.Equal(cpr.Results[i].HitCandidates[k].isBranch, roundTrip.Results[i].HitCandidates[k].isBranch);
Assert.Equal(cpr.Results[i].HitCandidates[k].end, roundTrip.Results[i].HitCandidates[k].end);
Assert.Equal(cpr.Results[i].HitCandidates[k].docIndex, roundTrip.Results[i].HitCandidates[k].docIndex);
}
for (int k = 0; k < cpr.Results[i].Documents.Count; k++)
{
System.Collections.Generic.KeyValuePair <string, Document>[] documents = cpr.Results[i].Documents.ToArray();
System.Collections.Generic.KeyValuePair <string, Document>[] documentsRoundTrip = roundTrip.Results[i].Documents.ToArray();
for (int j = 0; j < documents.Length; j++)
{
Assert.Equal(documents[j].Key, documentsRoundTrip[j].Key);
Assert.Equal(documents[j].Value.Index, documentsRoundTrip[j].Value.Index);
Assert.Equal(documents[j].Value.Path, documentsRoundTrip[j].Value.Path);
for (int v = 0; v < documents[j].Value.Lines.Count; v++)
{
System.Collections.Generic.KeyValuePair <int, Line>[] lines = documents[j].Value.Lines.ToArray();
System.Collections.Generic.KeyValuePair <int, Line>[] linesRoundTrip = documentsRoundTrip[j].Value.Lines.ToArray();
Assert.Equal(lines[v].Key, linesRoundTrip[v].Key);
Assert.Equal(lines[v].Value.Class, lines[v].Value.Class);
Assert.Equal(lines[v].Value.Hits, lines[v].Value.Hits);
Assert.Equal(lines[v].Value.Method, lines[v].Value.Method);
Assert.Equal(lines[v].Value.Number, lines[v].Value.Number);
}
for (int v = 0; v < documents[j].Value.Branches.Count; v++)
{
System.Collections.Generic.KeyValuePair <BranchKey, Branch>[] branches = documents[j].Value.Branches.ToArray();
System.Collections.Generic.KeyValuePair <BranchKey, Branch>[] branchesRoundTrip = documentsRoundTrip[j].Value.Branches.ToArray();
Assert.Equal(branches[v].Key, branchesRoundTrip[v].Key);
Assert.Equal(branches[v].Value.Class, branchesRoundTrip[v].Value.Class);
Assert.Equal(branches[v].Value.EndOffset, branchesRoundTrip[v].Value.EndOffset);
Assert.Equal(branches[v].Value.Hits, branchesRoundTrip[v].Value.Hits);
Assert.Equal(branches[v].Value.Method, branchesRoundTrip[v].Value.Method);
Assert.Equal(branches[v].Value.Number, branchesRoundTrip[v].Value.Number);
Assert.Equal(branches[v].Value.Offset, branchesRoundTrip[v].Value.Offset);
Assert.Equal(branches[v].Value.Ordinal, branchesRoundTrip[v].Value.Ordinal);
Assert.Equal(branches[v].Value.Path, branchesRoundTrip[v].Value.Path);
}
}
}
}
}
public void TestCoreLibInstrumentation()
{
DirectoryInfo directory = Directory.CreateDirectory(Path.Combine(Directory.GetCurrentDirectory(), nameof(TestCoreLibInstrumentation)));
string[] files = new[]
{
"System.Private.CoreLib.dll",
"System.Private.CoreLib.pdb"
};
foreach (var file in files)
{
File.Copy(Path.Combine(Directory.GetCurrentDirectory(), "TestAssets", file), Path.Combine(directory.FullName, file), overwrite: true);
}
Mock <FileSystem> partialMockFileSystem = new Mock <FileSystem>();
partialMockFileSystem.CallBase = true;
partialMockFileSystem.Setup(fs => fs.OpenRead(It.IsAny <string>())).Returns((string path) =>
{
if (Path.GetFileName(path) == files[1])
{
return(File.OpenRead(Path.Combine(Path.Combine(Directory.GetCurrentDirectory(), "TestAssets"), files[1])));
}
else
{
return(File.OpenRead(path));
}
});
partialMockFileSystem.Setup(fs => fs.Exists(It.IsAny <string>())).Returns((string path) =>
{
if (Path.GetFileName(path) == files[1])
{
return(File.Exists(Path.Combine(Path.Combine(Directory.GetCurrentDirectory(), "TestAssets"), files[1])));
}
else
{
if (path.Contains(@":\git\runtime"))
{
return(true);
}
else
{
return(File.Exists(path));
}
}
});
var sourceRootTranslator = new SourceRootTranslator(_mockLogger.Object, new FileSystem());
InstrumentationHelper instrumentationHelper =
new InstrumentationHelper(new ProcessExitHandler(), new RetryHelper(), partialMockFileSystem.Object, _mockLogger.Object, sourceRootTranslator);
Instrumenter instrumenter = new Instrumenter(Path.Combine(directory.FullName, files[0]), "_coverlet_instrumented", Array.Empty <string>(), Array.Empty <string>(), Array.Empty <string>(),
Array.Empty <string>(), Array.Empty <string>(), false, false, _mockLogger.Object, instrumentationHelper, partialMockFileSystem.Object, sourceRootTranslator, new CecilSymbolHelper());
Assert.True(instrumenter.CanInstrument());
InstrumenterResult result = instrumenter.Instrument();
Assert.NotNull(result);
Assert.Equal(1052, result.Documents.Count);
foreach ((string docName, Document _) in result.Documents)
{
Assert.False(docName.EndsWith(@"System.Private.CoreLib\src\System\Threading\Interlocked.cs"));
}
directory.Delete(true);
}
public void TestEnsureDocumentsPropertyNotNull()
{
var result = new InstrumenterResult();
Assert.NotNull(result.Documents);
}
