public void Test()
        {
             var gen = new XmlResultsGenerator(null,null,null, null, null);

            var muSession = new MutationTestingSession();
            
            var mutar = new MutationTarget(new MutationVariant());


            var ass = new AssemblyNode("Assembly");
            muSession.MutantsGrouped.Add(ass);
            var nodeNamespace = new TypeNamespaceNode(ass, "Namespace");
            ass.Children.Add(nodeNamespace);
            var nodeType = new TypeNode(nodeNamespace, "Type");
            nodeNamespace.Children.Add(nodeType);
            var nodeMethod = new MethodNode(nodeType, "Method", null, true);
            nodeType.Children.Add(nodeMethod);
            var nodeGroup = new MutantGroup("Gr1", nodeMethod);
            nodeMethod.Children.Add(nodeGroup);
            var nodeMutant = new Mutant("m1", nodeGroup, mutar);
            nodeGroup.Children.Add(nodeMutant);

            XDocument generateResults = gen.GenerateResults(muSession, false, false, ProgressCounter.Inactive(), CancellationToken.None).Result;

            Console.WriteLine(generateResults.ToString());
            //gen.
        }

        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);
        }

		public void DrawTree(AssemblyNode module)
		{
			var leftCol = leftTree.Items.SourceCollection as INotifyCollectionChanged;
			leftCol.CollectionChanged += BuildLeftINodeList;
			
			var topCol = topTree.Items.SourceCollection as INotifyCollectionChanged;
			topCol.CollectionChanged += BuildTopINodeList;
			
			leftTree.MouseMove += LeftTree_MouseMove;
			topTree.MouseMove += TopTree_MouseMove;
			
			Helper.FillTree(leftTree, module);
			Helper.FillTree(topTree, module);
		}

        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;
        }

		public MetricsReader(string fileName)
		{
			loader = new CecilLoader(true) { IncludeInternalMembers = true };
			namespaceMappings = new Dictionary<string, NamespaceNode>();
			typeMappings = new Dictionary<ITypeDefinition, TypeNode>();
			methodMappings = new Dictionary<IMethod, MethodNode>();
			fieldMappings = new Dictionary<IField, FieldNode>();
			cecilMappings = new Dictionary<MemberReference, IEntity>();
			
			compilation = new SimpleCompilation(loader.LoadAssemblyFile(fileName));
			
			// TODO load referenced assemblies into compilation.
			
			Assembly = new AssemblyNode(compilation.MainAssembly.AssemblyName);
			assemblyDefinition = loader.GetCecilObject(compilation.MainAssembly.UnresolvedAssembly);
			
			foreach (var type in compilation.MainAssembly.GetAllTypeDefinitions()) {
				ReadType(type);
				
				foreach (IMethod method in type.Methods) {
					ReadMethod(method);
				}
				
				foreach (IProperty property in type.Properties) {
					if (property.CanGet)
						ReadMethod(property.Getter);
					if (property.CanSet)
						ReadMethod(property.Setter);
				}
				
				foreach (IField field in type.Fields) {
					ReadField(field);
				}
			}
			
			foreach (var method in methodMappings.Values) {
				ReadInstructions(method, method.Method, loader.GetCecilObject((IUnresolvedMethod)method.Method.UnresolvedMember));
			}
			
			Assembly.namespaces = namespaceMappings.Values;
		}

 public Mutant CreateEquivalentMutant(out AssemblyNode assemblyNode)
 {
     
     assemblyNode = new AssemblyNode("All modules");
     var nsNode = new TypeNamespaceNode(assemblyNode, "");
     assemblyNode.Children.Add(nsNode);
     var typeNode = new TypeNode(nsNode, "");
     nsNode.Children.Add(typeNode);
     var methodNode = new MethodNode(typeNode, "", null, true);
     typeNode.Children.Add(methodNode);
     var group = new MutantGroup("Testing original program", methodNode);
     var target = new MutationTarget(new MutationVariant())
                  {
                      Name = "Original program",
                  };
     var mutant = new Mutant("0", group, target);
    
     group.Children.Add(mutant);
     methodNode.Children.Add(group);
     group.UpdateDisplayedText();
     return mutant;
 }

 public virtual AttributeNode VisitUnknownAssemblyAttribute(TypeNode attrType, AttributeNode attr, AssemblyNode target) {
   return attr;
 }

 public override Compilation VisitCompilation(Compilation compilation) {
   if (compilation == null) return null;
   this.currentOptions = compilation.CompilerParameters as CompilerOptions;
   Module module = this.currentModule = compilation.TargetModule;
   if (module != null) {
     AssemblyNode assem = module as AssemblyNode;
     if (assem != null) {
       this.currentAssembly = assem;
       if (this.currentOptions.IsContractAssembly) { // handle compiler option /shadow:<assembly>
         this.shadowedAssembly = AssemblyNode.GetAssembly(this.currentOptions.ShadowedAssembly);
         if (this.shadowedAssembly == null) {
           this.HandleError(compilation, Error.CannotLoadShadowedAssembly, this.currentOptions.ShadowedAssembly);
           return compilation;
         }
         assem.Attributes.Add(ShadowedAssemblyAttribute());
         this.isCompilingAContractAssembly = true;
       }
       assem.Attributes = this.VisitAttributeList(assem.Attributes, assem);
       assem.ModuleAttributes = this.VisitModuleAttributes(assem.ModuleAttributes);
     } else {
       this.currentAssembly = module.ContainingAssembly;
       module.Attributes = this.VisitModuleAttributes(module.Attributes);
     }
   }
   return base.VisitCompilation(compilation);
 }

 private TypeNode GetType(AssemblyNode assembly, string ns, string name)
 {
     var res = assembly.GetType(Identifier.For(ns), Identifier.For(name));
     if (res == null)
     {
         Log(new InvalidInteropMessage(null, "can't load required type: " + ns + "." + name));
         throw new ExitException();
     }
     return res;
 }

        private static TypeNode GetTypeNode(AssemblyNode assembly, string ns, string name)
        {
            Contract.Assert(assembly != null);

            return assembly.GetType(Identifier.For(ns), Identifier.For(name));
        }

        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 virtual AssemblyNode VisitAssembly(AssemblyNode assembly){
   if (assembly == null) return null;
   this.VisitModule(assembly);
   assembly.ModuleAttributes = this.VisitAttributeList(assembly.ModuleAttributes);
   assembly.SecurityAttributes = this.VisitSecurityAttributeList(assembly.SecurityAttributes);
   return assembly;
 }

		public virtual void VisitAssembly (AssemblyNode node)
		{
			if (node == null)
				return;

			VisitModuleList (node.Modules);
		}

 public virtual void VisitAssembly(AssemblyNode assembly)
 {
   if (assembly == null) return;
   this.VisitModule(assembly);
   this.VisitAttributeList(assembly.ModuleAttributes);
   this.VisitSecurityAttributeList(assembly.SecurityAttributes);
 }

		public BaseQuery(AssemblyNode mainModule)
		{
			MainModule = mainModule;
		}

 public override AssemblyNode VisitAssembly(AssemblyNode assembly)
 {
   throw new ApplicationException("unimplemented");
 }

        public void Setup(AssemblyNode mscorlib, AssemblyNode jsTypes, AssemblyNode rewriteAssembly)
        {
            NumWarnings = 0;
            NumErrors = 0;

            MsCorLib = mscorlib;

            AssemblyDelaySignAttributeType = GetType(mscorlib, "System.Reflection", "AssemblyDelaySignAttribute");

            VoidType = GetType(mscorlib, "System", "Void");
            ObjectType = GetType(mscorlib, "System", "Object");
            StringType = GetType(mscorlib, "System", "String");
            IntType = GetType(mscorlib, "System", "Int32");
            BooleanType = GetType(mscorlib, "System", "Boolean");
            MethodBaseType = GetType(mscorlib, "System.Reflection", "MethodBase");
            RuntimeTypeHandleType = GetType(mscorlib, "System", "RuntimeTypeHandle");
            NullableTypeConstructor = GetType(mscorlib, "System", "Nullable`1");
            CompilerGeneratedAttributeType = GetType
                (mscorlib, "System.Runtime.CompilerServices", "CompilerGeneratedAttribute");
            DllImportAttributeType = GetType(mscorlib, "System.Runtime.InteropServices", "DllImportAttribute");

            TypeType = GetType(mscorlib, "System", "Type");
            Type_GetMethodMethod = GetMethod(TypeType, "GetMethod", StringType, TypeType.GetArrayType(1));
            Type_GetMemberMethod = GetMethod(TypeType, "GetMember", StringType);
            Type_GetConstructorMethod = GetMethod(TypeType, "GetConstructor", TypeType.GetArrayType(1));
            Type_GetTypeFromHandleMethod = GetMethod(TypeType, "GetTypeFromHandle", RuntimeTypeHandleType);
            Type_GetGenericArgumentsMethod = GetMethod(TypeType, "GetGenericArguments");
            Type_MakeArrayTypeMethod = GetMethod(TypeType, "MakeArrayType");
            Type_MakeGenericTypeMethod = GetMethod(TypeType, "MakeGenericType", TypeType.GetArrayType(1));

            InteropTypes = new InteropTypes(this);
            InteropManager = new InteropManager(this);

            IgnoreAttributeType = GetType(jsTypes, Constants.JSTypesIL2JSNS, "IgnoreAttribute");
            InteropAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "InteropAttribute");
            NamingAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "NamingAttribute");
            ImportAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "ImportAttribute");
            ImportKeyAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "ImportKeyAttribute");
            ExportAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "ExportAttribute");
            NotExportedAttributeType = GetType(jsTypes, Constants.JSTypesInteropNS, "NotExportedAttribute");
            InteropGeneratedAttributeType = GetType(jsTypes, Constants.JSTypesIL2JSNS, "InteropGeneratedAttribute");

            JSTypes = jsTypes;

            JSContextType = GetType(jsTypes, Constants.JSTypesInteropNS, "JSContext");

            InteropContextManagerType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "InteropContextManager");
            InteropContextManager_GetDatabaseMethod = GetMethod(InteropContextManagerType, "get_Database");
            InteropContextManager_GetCurrentRuntimeMethod = GetMethod(InteropContextManagerType, "get_CurrentRuntime");
            InteropContextManager_GetRuntimeForObjectMethod = GetMethod
                (InteropContextManagerType, "GetRuntimeForObject", ObjectType);

            InteropDatabaseType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "InteropDatabase");
            InteropDatabase_RegisterRootExpression = GetMethod(InteropDatabaseType, "RegisterRootExpression", StringType);
            InteropDatabase_RegisterDelegateShimMethod = GetMethod
                (InteropDatabaseType, "RegisterDelegateShim", TypeType);
            InteropDatabase_RegisterTypeMethod = GetMethod
                (InteropDatabaseType,
                 "RegisterType",
                 TypeType,
                 IntType,
                 StringType,
                 StringType,
                 IntType,
                 BooleanType,
                 BooleanType,
                 BooleanType);
            InteropDatabase_RegisterExportMethod = GetMethod
                (InteropDatabaseType, "RegisterExport", MethodBaseType, BooleanType, StringType);

            SimpleMethodBaseType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "SimpleMethodBase");

            SimpleMethodInfoType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "SimpleMethodInfo");
            SimpleMethodInfo_Ctor = GetConstructor
                (SimpleMethodInfoType, BooleanType, StringType, TypeType, TypeType.GetArrayType(1), TypeType);

            SimpleConstructorInfoType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "SimpleConstructorInfo");
            SimpleConstructorInfo_Ctor = GetConstructor(SimpleConstructorInfoType, TypeType, TypeType.GetArrayType(1));

            RuntimeType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "Runtime");
            Runtime_CompleteConstructionMethod = GetMethod
                (RuntimeType, "CompleteConstruction", SimpleMethodBaseType, ObjectType, JSContextType);
            Runtime_CallImportedMethodMethod = GetMethod
                (RuntimeType, "CallImportedMethod", SimpleMethodBaseType, StringType, ObjectType.GetArrayType(1));

            UniversalDelegateType = GetType(jsTypes, Constants.JSTypesManagedInteropNS, "UniversalDelegate");
            UniversalDelegate_InvokeMethod = GetUniqueMethod(UniversalDelegateType, "Invoke");

            MethodBase_GetGenericArgumentsMethod = GetMethod(MethodBaseType, "GetGenericArguments");

            ModuleType = GetType(rewriteAssembly, "", "<Module>");
            foreach (var member in ModuleType.Members)
            {
                var cctor = member as StaticInitializer;
                if (cctor != null)
                    ModuleCCtorMethod = cctor;
            }
        }

 public override AssemblyNode VisitAssembly(AssemblyNode assembly)
 {
     if (assembly == null) return null;
     this.FindTypesToBeDuplicated(assembly.Types);
     return base.VisitAssembly((AssemblyNode)assembly.Clone());
 }

 public override AssemblyNode VisitAssembly(AssemblyNode assembly){
   this.currentModule = this.currentAssembly = assembly;
   return base.VisitAssembly(assembly);
 }

		public virtual AssemblyNode VisitAssembly (AssemblyNode node)
		{
			if (node == null)
				return null;

			VisitModuleList (node.Modules);


			return node;
		}