private void WriteMethods(List <Call> calls, CoverageScope klass)
{
foreach (var child in klass.Children)
{
FunctionDefinition funcDef = child.Statement as FunctionDefinition;
if (funcDef != null)
{
List <Call> lines = new List <Call>();
lines.Add(WriteStats(child));
lines.AddRange(WriteLines(child.Lines));
calls.Add(
new Call(
string.Format(
"Function(\"{0}\",",
CoverageExporter.GetQualifiedFunctionName(child.Statement)
),
lines.ToArray()
)
);
WriteMethods(calls, child);
}
}
}
internal override void Validate(CoverageMapper mapper, CoverageScope parentScope)
{
Assert.IsTrue(
FindFunction(mapper, parentScope),
"Failed to find function: " + _name
);
}
internal override void Validate(CoverageMapper mapper, CoverageScope parentScope)
{
Assert.AreEqual(BlocksCovered, parentScope.BlocksCovered);
Assert.AreEqual(BlocksNotCovered, parentScope.BlocksNotCovered);
Assert.AreEqual(LinesCovered, parentScope.LinesCovered);
Assert.AreEqual(LinesNotCovered, parentScope.LinesNotCovered);
}
internal override void Validate(CoverageMapper mapper, CoverageScope parentScope)
{
foreach (var expected in _expected)
{
expected.Validate(mapper, parentScope);
}
}
private Call[] WriteMethods(CoverageScope klass)
{
List <Call> calls = new List <Call>();
WriteMethods(calls, klass);
return(calls.ToArray());
}
public CoverageMapper(PythonAst ast, string filename, HashSet <int> hits)
{
_ast = ast;
_filename = filename;
GlobalScope = new CoverageScope(ast);
CurScopes.Add(GlobalScope);
_blockCount++;
_hits = hits;
}
internal override void Validate(CoverageMapper mapper, CoverageScope parentScope)
{
Assert.IsTrue(parentScope.Lines.ContainsKey(_lineNo), "Line number is missing coverage information");
var covInfo = parentScope.Lines[_lineNo];
Assert.AreEqual(_startColumn, covInfo.ColumnStart);
Assert.AreEqual(_endColumn, covInfo.ColumnEnd);
Assert.AreEqual(_covered, covInfo.Covered);
}
private void AggregateStats(CoverageScope scope, ref int linesCovered, ref int linesNotCovered, ref int blocksCovered, ref int blocksNotCovered)
{
linesCovered += scope.LinesCovered;
linesNotCovered += scope.LinesNotCovered;
blocksCovered += scope.BlocksCovered;
blocksNotCovered += scope.BlocksNotCovered;
foreach (var child in scope.Children)
{
AggregateStats(child, ref linesCovered, ref linesNotCovered, ref blocksCovered, ref blocksNotCovered);
}
}
private Call WriteStats(CoverageScope scope)
{
return(new Call(
string.Format(
"Stats({0}, {1}, {2}, {3}",
scope.BlocksCovered,
scope.BlocksNotCovered,
scope.LinesCovered,
scope.LinesNotCovered
),
Array.Empty <Call>()
));
}
private void WriteMethods(CoverageScope klass)
{
foreach (var child in klass.Children)
{
FunctionDefinition funcDef = child.Statement as FunctionDefinition;
if (funcDef != null)
{
WriteMethod(child, GetQualifiedFunctionName(child.Statement));
WriteMethods(child);
}
}
}
internal override void Validate(CoverageMapper mapper, CoverageScope parentScope)
{
foreach (var scope in mapper.Classes)
{
if (CoverageExporter.GetQualifiedName(scope.Statement) == _name)
{
foreach (var expected in _expected)
{
expected.Validate(mapper, scope);
}
return;
}
}
Assert.Fail("Failed to find class: " + _name);
}
private CoverageScope WalkScope(ScopeStatement node)
{
var prevScope = CurScope;
var newScope = new CoverageScope(node);
CurScopes.Add(newScope);
var wasCovered = _blockCovered;
_blockCovered = null;
if (node.Body != null)
{
node.Body.Walk(this);
}
CurScopes.RemoveAt(CurScopes.Count - 1);
_blockCovered = wasCovered;
return(newScope);
}
private void WriteClass(string filename, CoverageScope klass, string name)
{
_writer.WriteStartElement("Class");
WriteElement("ClassKeyName", filename + "!" + name);
WriteElement("ClassName", name);
WriteElement("NamespaceKeyName", filename + "!" + name);
int linesCovered = 0, linesNotCovered = 0, blocksCovered = 0, blocksNotCovered = 0;
AggregateStats(klass, ref linesCovered, ref linesNotCovered, ref blocksCovered, ref blocksNotCovered);
WriteCoverageData(linesCovered, linesNotCovered, blocksCovered, blocksNotCovered);
WriteMethod(klass, klass.Statement.Name);
WriteMethods(klass);
_writer.WriteEndElement();
}
private void WriteMethod(CoverageScope child, string name)
{
_writer.WriteStartElement("Method");
WriteElement("MethodKeyName", "method!" + ++_methodCount);
WriteElement("MethodName", name);
WriteElement("MethodFullName", name);
WriteCoverageData(child);
foreach (var line in child.Lines)
{
var lineNo = line.Key;
var lineInfo = line.Value;
_writer.WriteStartElement("Lines");
WriteElement("LnStart", lineNo);
WriteElement("ColStart", lineInfo.ColumnStart);
WriteElement("LnEnd", lineNo);
WriteElement("ColEnd", lineInfo.ColumnEnd);
WriteElement("Coverage", (int)(lineInfo.Covered ? CoverageStatus.Covered : CoverageStatus.NotCovered));
WriteElement("SourceFileID", _curFile + 1);
WriteElement("LineID", line.Key);
_writer.WriteEndElement();
}
_writer.WriteEndElement();
}
private bool FindFunction(CoverageMapper mapper, CoverageScope parentScope)
{
foreach (var scope in parentScope.Children)
{
if (scope.Statement is FunctionDefinition)
{
if (CoverageExporter.GetQualifiedFunctionName(scope.Statement) == _name)
{
foreach (var expected in _expected)
{
expected.Validate(mapper, scope);
}
return(true);
}
if (FindFunction(mapper, scope))
{
// nested function...
return(true);
}
}
}
return(false);
}
private bool FindFunction(CoverageMapper mapper, CoverageScope parentScope) {
foreach (var scope in parentScope.Children) {
if (scope.Statement is FunctionDefinition) {
if (CoverageExporter.GetQualifiedFunctionName(scope.Statement) == _name) {
foreach (var expected in _expected) {
expected.Validate(mapper, scope);
}
return true;
}
if (FindFunction(mapper, scope)) {
// nested function...
return true;
}
}
}
return false;
}
internal override void Validate(CoverageMapper mapper, CoverageScope parentScope) {
Assert.IsTrue(
FindFunction(mapper, parentScope),
"Failed to find function: " + _name
);
}
internal override void Validate(CoverageMapper mapper, CoverageScope parentScope) {
foreach (var expected in _expected) {
expected.Validate(mapper, parentScope);
}
}
internal override void Validate(CoverageMapper mapper, CoverageScope parentScope) {
foreach (var scope in mapper.Classes) {
if (CoverageExporter.GetQualifiedName(scope.Statement) == _name) {
foreach (var expected in _expected) {
expected.Validate(mapper, scope);
}
return;
}
}
Assert.Fail("Failed to find class: " + _name);
}
internal abstract void Validate(CoverageMapper mapper, CoverageScope parentScope);
private void WriteMethods(List<Call> calls, CoverageScope klass) {
foreach (var child in klass.Children) {
FunctionDefinition funcDef = child.Statement as FunctionDefinition;
if (funcDef != null) {
List<Call> lines = new List<Call>();
lines.Add(WriteStats(child));
lines.AddRange(WriteLines(child.Lines));
calls.Add(
new Call(
string.Format(
"Function(\"{0}\",",
CoverageExporter.GetQualifiedFunctionName(child.Statement)
),
lines.ToArray()
)
);
WriteMethods(calls, child);
}
}
}
internal abstract void Validate(CoverageMapper mapper, CoverageScope parentScope);
private Call WriteStats(CoverageScope scope) {
return new Call(
string.Format(
"Stats({0}, {1}, {2}, {3}",
scope.BlocksCovered,
scope.BlocksNotCovered,
scope.LinesCovered,
scope.LinesNotCovered
),
Array.Empty<Call>()
);
}
private void WriteCoverageData(CoverageScope scope)
{
WriteCoverageData(scope.LinesCovered, scope.LinesNotCovered, scope.BlocksCovered, scope.BlocksNotCovered);
}
internal override void Validate(CoverageMapper mapper, CoverageScope parentScope) {
Assert.IsTrue(parentScope.Lines.ContainsKey(_lineNo), "Line number is missing coverage information");
var covInfo = parentScope.Lines[_lineNo];
Assert.AreEqual(_startColumn, covInfo.ColumnStart);
Assert.AreEqual(_endColumn, covInfo.ColumnEnd);
Assert.AreEqual(_covered, covInfo.Covered);
}
internal override void Validate(CoverageMapper mapper, CoverageScope parentScope) {
Assert.AreEqual(BlocksCovered, parentScope.BlocksCovered);
Assert.AreEqual(BlocksNotCovered, parentScope.BlocksNotCovered);
Assert.AreEqual(LinesCovered, parentScope.LinesCovered);
Assert.AreEqual(LinesNotCovered, parentScope.LinesNotCovered);
}
private Call[] WriteMethods(CoverageScope klass) {
List<Call> calls = new List<Call>();
WriteMethods(calls, klass);
return calls.ToArray();
}
