generating tests as separated classes, updated nunit to 3.2.1.0

Author: maca88

src/NHibernate.AsyncGenerator/App.config

@@ -1,10 +1,10 @@
-<?xml version="1.0" encoding="utf-8" ?>
+<?xml version="1.0" encoding="utf-8"?>
 <configuration>
 	<configSections>
 		<section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net"/>
 	</configSections>
 	<startup>
-		<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
+		<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2"/>
 	</startup>
 
 	<log4net>
@@ -14,21 +14,21 @@
 			</layout>
 		</appender>
 		<appender name="FileAppender" type="log4net.Appender.FileAppender">
-			<file value="Log.txt" />
-			<appendToFile value="true" />
-			<lockingModel type="log4net.Appender.FileAppender+MinimalLock" />
+			<file value="Log.txt"/>
+			<appendToFile value="true"/>
+			<lockingModel type="log4net.Appender.FileAppender+MinimalLock"/>
 			<layout type="log4net.Layout.PatternLayout">
-				<conversionPattern value="%level - %message%newline" />
+				<conversionPattern value="%level - %message%newline"/>
 			</layout>
 			<filter type="log4net.Filter.LevelRangeFilter">
-				<levelMin value="INFO" />
-				<levelMax value="FATAL" />
+				<levelMin value="INFO"/>
+				<levelMax value="FATAL"/>
 			</filter>
 		</appender>
 		<root>
 			<level value="INFO"/>
 			<appender-ref ref="FileAppender"/>
-			<appender-ref ref="ConsoleAppender" />
+			<appender-ref ref="ConsoleAppender"/>
 		</root>
 	</log4net>
-</configuration>
+</configuration>

src/NHibernate.AsyncGenerator/DocumentInfo.cs

@@ -4,20 +4,28 @@
 using System.Text;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.FindSymbols;
 using NHibernate.AsyncGenerator.Extensions;
 
 namespace NHibernate.AsyncGenerator
 {
-	public class DocumentInfo : Dictionary<string, NamespaceInfo>
+	public class DocumentInfo : Dictionary<NamespaceDeclarationSyntax, NamespaceInfo>
 	{
 		public DocumentInfo(ProjectInfo projectInfo, Document document)
 		{
 			ProjectInfo = projectInfo;
 			Document = document;
 		}
 
+		public async Task Initialize()
+		{
+			RootNode = (CompilationUnitSyntax) await Document.GetSyntaxRootAsync().ConfigureAwait(false);
+			SemanticModel = await Document.GetSemanticModelAsync().ConfigureAwait(false);
+			GlobalNamespaceInfo = new NamespaceInfo(this, SemanticModel.Compilation.GlobalNamespace, null);
+		}
+
 		public ProjectInfo ProjectInfo { get; }
 
 		public Document Document { get; }
@@ -28,21 +36,18 @@ public DocumentInfo(ProjectInfo projectInfo, Document document)
 
 		public string Path => Document.FilePath;
 
-		public CompilationUnitSyntax RootNode { get; set; }
+		public CompilationUnitSyntax RootNode { get; private set; }
 
-		public SemanticModel SemanticModel { get; set; }
+		public SemanticModel SemanticModel { get; private set; }
+
+		public NamespaceInfo GlobalNamespaceInfo { get; private set; }
 
 		public NamespaceInfo GetNamespaceInfo(ISymbol symbol, bool create = false)
 		{
 			var namespaceSymbol = symbol.ContainingNamespace;
-			var namespaceName = namespaceSymbol.Name;
-			if (ContainsKey(namespaceName))
+			if (namespaceSymbol.IsGlobalNamespace)
 			{
-				return this[namespaceName];
-			}
-			if (!create)
-			{
-				return null;
+				return GlobalNamespaceInfo;
 			}
 
 			var location = namespaceSymbol.Locations.Single(o => o.SourceTree.FilePath == Path);
@@ -62,8 +67,40 @@ public NamespaceInfo GetNamespaceInfo(ISymbol symbol, bool create = false)
 			{
 				node = RootNode.DescendantNodes().OfType<NamespaceDeclarationSyntax>().Single(o => o.FullSpan.End == location.SourceSpan.End);
 			}
-			var docNamespace = new NamespaceInfo(this, namespaceSymbol, node);
-			Add(namespaceName, docNamespace);
+			return GetNamespaceInfo(node, namespaceSymbol, create);
+		}
+
+		public NamespaceInfo GetNamespaceInfo(SyntaxNode node, bool create = false)
+		{
+			if (node == null)
+			{
+				return GlobalNamespaceInfo;
+			}
+			var namespaceNode = node.AncestorsAndSelf().OfType<NamespaceDeclarationSyntax>().FirstOrDefault();
+			if (namespaceNode == null)
+			{
+				return GlobalNamespaceInfo;
+			}
+			var namespaceSymbol =  SemanticModel.GetDeclaredSymbol(namespaceNode);
+			return GetNamespaceInfo(namespaceNode, namespaceSymbol, create);
+		}
+
+		public NamespaceInfo GetNamespaceInfo(NamespaceDeclarationSyntax namespaceNode, INamespaceSymbol namespaceSymbol, bool create = false)
+		{
+			if (ContainsKey(namespaceNode))
+			{
+				return this[namespaceNode];
+			}
+			if (!create)
+			{
+				return null;
+			}
+			var docNamespace = new NamespaceInfo(this, namespaceSymbol, namespaceNode);
+			Add(namespaceNode, docNamespace);
+			if (Keys.GroupBy(o => o.Name).Any(o => o.Count() > 1)) //TODO REMOVE
+			{
+
+			}
 			return docNamespace;
 		}
 
@@ -72,25 +109,35 @@ public MethodInfo GetOrCreateMethodInfo(IMethodSymbol symbol)
 			return GetNamespaceInfo(symbol, true).GetTypeInfo(symbol, true).GetMethodInfo(symbol, true);
 		}
 
+		public MethodInfo GetOrCreateMethodInfo(MethodDeclarationSyntax node)
+		{
+			return GetNamespaceInfo(node, true).GetTypeInfo(node, true).GetMethodInfo(node, true);
+		}
+
 		public MethodInfo GetMethodInfo(IMethodSymbol symbol)
 		{
-			return GetNamespaceInfo(symbol).GetTypeInfo(symbol).GetMethodInfo(symbol);
+			return GetNamespaceInfo(symbol)?.GetTypeInfo(symbol)?.GetMethodInfo(symbol);
 		}
 
 		public TypeInfo GetTypeInfo(INamedTypeSymbol symbol)
 		{
 			return GetNamespaceInfo(symbol).GetTypeInfo(symbol);
 		}
 
+		public TypeInfo GetOrCreateTypeInfo(TypeDeclarationSyntax node)
+		{
+			return GetNamespaceInfo(node, true).GetTypeInfo(node, true);
+		}
+
 		public bool ContainsReference(IMethodSymbol symbol, ReferenceLocation reference)
 		{
 			return GetNamespaceInfo(symbol)?.GetTypeInfo(symbol)?.GetMethodInfo(symbol)?.References?.Contains(reference) == true;
 		}
-
+		/*
 		public bool ContainsBodyToAsyncMethodReference(IMethodSymbol symbol, ReferenceLocation reference)
 		{
 			return GetNamespaceInfo(symbol)?.GetTypeInfo(symbol)?.GetMethodInfo(symbol)?.BodyToAsyncMethodsReferences?.Contains(reference) == true;
-		}
+		}*/
 
 		public ISymbol GetEnclosingMethodOrPropertyOrField(ReferenceLocation reference)
 		{