private void ProcessSequencePoints(List <LineCoverageInfo> coveredLines, Module module,
IEnumerable <TrackedMethod> tests, Class modelClass, Method method, string fileName)
{
List <SequencePoint> sequencePoints = method.SequencePoints;
List <BranchPoint> branchPoints = method.BranchPoints;
foreach (SequencePoint sequencePoint in sequencePoints)
{
var branchPoint = branchPoints.FirstOrDefault(x => x.StartLine == sequencePoint.StartLine);
var coveredLine = new LineCoverageInfo
{
IsCode = true,
LineNumber = sequencePoint.StartLine,
IsCovered = (sequencePoint.VisitCount > 0),
ModuleName = module.ModuleName,
ClassName = modelClass.FullName,
MethodName = method.Name,
FileName = fileName,
UnitTests = new List <UnitTest>(),
IsBranch = branchPoint != null
};
if (tests.Any())
{
foreach (var trackedMethodRef in sequencePoint.TrackedMethodRefs)
{
TrackedMethod trackedMethod =
tests.FirstOrDefault(y => y.UniqueId.Equals(trackedMethodRef.UniqueId));
coveredLine.IsCode = true;
coveredLine.IsCovered = (sequencePoint.VisitCount > 0);
coveredLine.FileName = fileName;
coveredLine.TrackedMethods.Add(new Poco.TrackedMethod
{
UniqueId = (int)trackedMethod.UniqueId,
UnitTestId = trackedMethod.UnitTestId,
Strategy = trackedMethod.Strategy,
Name = trackedMethod.Name,
MetadataToken = trackedMethod.MetadataToken
});
}
}
coveredLines.Add(coveredLine);
}
}
public List <LineCoverageInfo> GetRetestedLinesFromCoverageSession(CoverageSession coverageSession,
string projectAssemblyName, List <int> uniqueIds)
{
/// todo need to figure out how to remove a CoveredLine if an Edit has made it uncovered,
/// without removing all lines that were not covered by the subset of tests that were run
/// One option: check all previously covered lines from this group of tests with the current covered lines list from this group.
///
//todo Handle case where a line that was "Code" and was covered is now not "Code"
var coveredLines = new List <LineCoverageInfo>();
List <Module> sessionModules = coverageSession.Modules;
Module module = sessionModules.FirstOrDefault(x => x.ModuleName.Equals(projectAssemblyName));
Module testModule = sessionModules.FirstOrDefault(x => x.ModuleName.Equals(projectAssemblyName + ".Test"));
IEnumerable <TrackedMethod> tests =
sessionModules.Where(x => x.TrackedMethods.Any()).SelectMany(y => y.TrackedMethods);
var testsRun = tests.Where(x => uniqueIds.Contains((int)x.UniqueId));
var methodsTested = module.Classes.SelectMany(m => m.Methods).Where(x => x.SequenceCoverage > 0);
if (module != null)
{
var codeModule = new CodeModule
{
Name = module.FullName,
Summary = new Summary(module.Summary)
};
List <Class> classes = module.Classes;
_log.DebugFormat("First Module Name: {0}", module.ModuleName);
_log.DebugFormat("Number of Classes: {0}", classes.Count());
foreach (Method method in methodsTested)
{
string methodName = method.Name.ToString();
if (!methodName.Contains("_") &&
!methodName.StartsWith("get_") &&
!methodName.StartsWith("set_"))
{
var codeMethod = new CodeMethod
{
Name = method.Name,
Summary = new Summary(method.Summary)
};
string modifiedMethodName = methodName;
if (method.IsConstructor)
{
modifiedMethodName = ConvertTrackedMethodFormatToUnitTestFormat(methodName);
modifiedMethodName = modifiedMethodName.Replace("..", "::.");
}
var modelClass = module.Classes.FirstOrDefault(x => x.Methods.Any(y => y.Name.Contains(modifiedMethodName)));
var codeClass = new CodeClass
{
Name = modelClass.FullName,
Summary = new Summary(modelClass.Summary)
};
List <SequencePoint> sequencePoints = method.SequencePoints;
foreach (SequencePoint sequencePoint in sequencePoints)
{
if (testsRun.Any())
{
var coveredLine = new LineCoverageInfo
{
IsCode = true,
LineNumber = sequencePoint.StartLine,
IsCovered = (sequencePoint.VisitCount > 0),
Module = codeModule,
Class = codeClass,
ClassName = modelClass.FullName,
Method = codeMethod,
FileName = module.Files.FirstOrDefault(x => x.UniqueId == method.FileRef.UniqueId).FullPath,
MethodName = method.Name
// UnitTests = testsRun.ToList()
};
foreach (TrackedMethodRef trackedMethodRef in sequencePoint.TrackedMethodRefs)
{
IEnumerable <TrackedMethod> testsThatCoverLine =
testsRun.Where(y => y.UniqueId.Equals(trackedMethodRef.UniqueId));
var fileNames = module.Files.Where(x => x.UniqueId == method.FileRef.UniqueId).ToList();
foreach (TrackedMethod test in testsThatCoverLine)
{
coveredLine.IsCode = true;
coveredLine.IsCovered = (sequencePoint.VisitCount > 0);
coveredLine.TrackedMethods.Add(new Poco.TrackedMethod
{
UniqueId = (int)test.UniqueId,
MetadataToken = method.MetadataToken,
Strategy = test.Strategy,
Name = test.Name
});
}
}
if (coveredLine.Class == null)
{
_log.ErrorFormat("CoveredLine.Class is null for method:{0}", method.Name);
}
coveredLines.Add(coveredLine);
}
}
}
}
}
return(coveredLines);
}
