public AssemblyNode CreateAssemblyNode(IModuleInfo module,
CciMethodMatcher methodMatcher)
{
var matcher = methodMatcher.Join(new SolutionTypesManager.ProperlyNamedMatcher());
var assemblyNode = new AssemblyNode(module.Name);
assemblyNode.AssemblyPath = module.Module.Location.ToFilePathAbs();
System.Action <CheckedNode, ICollection <INamedTypeDefinition> > typeNodeCreator = (parent, leafTypes) =>
{
foreach (INamedTypeDefinition typeDefinition in leafTypes)
{
if (matcher.Matches(typeDefinition))
{
var type = new TypeNode(parent, typeDefinition.Name.Value);
foreach (var method in typeDefinition.Methods)
{
if (matcher.Matches(method))
{
type.Children.Add(new MethodNode(type, method.Name.Value, method, false));
return;
}
}
parent.Children.Add(type);
}
}
};
Func <INamedTypeDefinition, string> namespaceExtractor = typeDef =>
TypeHelper.GetDefiningNamespace(typeDef).Name.Value;
NamespaceGrouper <INamespaceTypeDefinition, CheckedNode> .
GroupTypes(assemblyNode,
namespaceExtractor,
(parent, name) => new TypeNamespaceNode(parent, name),
typeNodeCreator,
module.Module.GetAllTypes().ToList());
//remove empty amespaces.
//TODO to refactor...
List <TypeNamespaceNode> checkedNodes = assemblyNode.Children.OfType <TypeNamespaceNode>().ToList();
foreach (TypeNamespaceNode node in checkedNodes)
{
RemoveFromParentIfEmpty(node);
}
return(assemblyNode);
}
private AssemblyNode BuildMutantsTree(string moduleName,
MultiDictionary <IMutationOperator, MutationTarget> mutationTargets)
{
var assemblyNode = new AssemblyNode(moduleName);
System.Action <CheckedNode, ICollection <MutationTarget> > typeNodeCreator = (parent, targets) =>
{
var typeNodes =
from t in targets
orderby t.TypeName
group t by t.TypeName
into byTypeGrouping
select new TypeNode(parent, byTypeGrouping.Key,
from gr in byTypeGrouping
group gr by gr.MethodRaw.Name.Value
into byMethodGrouping
orderby byMethodGrouping.Key
let md = byMethodGrouping.First().MethodRaw
select new MethodNode(md.Name.Value, md,
from gr in byMethodGrouping
group gr by gr.GroupName
into byGroupGrouping
orderby byGroupGrouping.Key
select GroupOrMutant(byGroupGrouping)
)
);
parent.Children.AddRange(typeNodes);
};
Func <MutationTarget, string> namespaceExtractor = target => target.NamespaceName;
NamespaceGrouper <MutationTarget, CheckedNode> .GroupTypes(assemblyNode,
namespaceExtractor,
(parent, name) => new TypeNamespaceNode(parent, name),
typeNodeCreator,
mutationTargets.Values.SelectMany(a => a).ToList());
foreach (var node in assemblyNode.Children.Where(n => n.Children.Count == 0).ToList())
{
assemblyNode.Children.Remove(node);
}
return(assemblyNode);
}
public void Test1()
{
System.Action <CheckedNode, ICollection <MutationTarget> > typeNodeCreator = (parent, targets) =>
{
};
Func <MutationTarget, string> namespaceExtractor = target => target.NamespaceName;
var mt1 = new MutationTarget(null);
mt1.NamespaceName = "Root.NamespaceName1";
var mt2 = new MutationTarget(null);
mt2.NamespaceName = "Root.NamespaceName2";
var mt3 = new MutationTarget(null);
mt3.NamespaceName = "Another.NamespaceName3";
var mt4 = new MutationTarget(null);
mt4.NamespaceName = "Another.NamespaceName3";
var ass = new AssemblyNode("");
NamespaceGrouper <MutationTarget, CheckedNode> .
GroupTypes(ass, namespaceExtractor,
(parent, name) => new TypeNamespaceNode(parent, name), typeNodeCreator,
new List <MutationTarget> {
mt1, mt2, mt3
});
ass.Children.Count.ShouldEqual(2);
ass.Children.Single(c => c.Name == "Root").Children.Count.ShouldEqual(2);
ass.Children.Single(c => c.Name == "Another.NamespaceName3").Children.Count.ShouldEqual(0);
}
