private MarkdownFile GenerateTableOfContents(DotNetDocumentationFile xmlDocumentation, DotNetQualifiedClassNameTreeNode node)
{
List <DotNetType> types = xmlDocumentation.Types.Where(t => t.Name.FullNamespace == node.Value).ToList();
List <DotNetDelegate> _delegates = xmlDocumentation.Delegates.Where(d => d.Name.FullNamespace == node.Value).ToList();
MarkdownFile markdown = new MarkdownFile();
string header = "Contents of " + node.Value.FullName;
if (node.Parent != null)
{
header = String.Format("Contents of [{0}]({1}).{2}", node.Parent.Value.FullName, TableOfContentsFilename(node.Parent.Value), node.Value.LocalName);
}
MarkdownSection section = markdown.AddSection(header);
if (node.Children.Count > 0)
{
MarkdownSection childNamespacesSection = section.AddSection("Namespaces");
foreach (DotNetQualifiedClassNameTreeNode child in node.Children)
{
section.AddInLine(new MarkdownInlineLink(MarkdownText.Bold(child.Value.FullName), TableOfContentsFilename(child.Value)));
}
}
AddTableOfContentsSection(section, "Concrete Types", types.Where(t => t.Category == TypeCategory.Normal).ToList());
AddTableOfContentsSection(section, "Static Types", types.Where(t => t.Category == TypeCategory.Static).ToList());
AddTableOfContentsSection(section, "Abstract Types", types.Where(t => t.Category == TypeCategory.Abstract).ToList());
AddTableOfContentsSection(section, "Interfaces", types.Where(t => t.Category == TypeCategory.Interface).ToList());
AddTableOfContentsSection(section, "Enums", types.Where(t => t.Category == TypeCategory.Enum).ToList());
AddTableOfContentsSection(section, "Structs", types.Where(t => t.Category == TypeCategory.Struct).ToList());
AddTableOfContentsSection(section, "Delegates", _delegates);
AddTableOfContentsSection(section, "Exceptions", types.Where(t => t.Category == TypeCategory.Exception).ToList());
return(markdown);
}
public Program()
{
//Test DotNet namespace
string outputFolder = Path.Combine(GetMainDirectory(), "DataFiles");
outputFolder = Path.Combine(outputFolder, "bin");
outputFolder = Path.Combine(outputFolder, "Release");
outputFolder = Path.Combine(outputFolder, Properties.Settings.Default.NetVersion);
string xmlFilename = Path.Combine(outputFolder, "WithoutHaste.DataFiles.XML");
string dllFilename = Path.Combine(outputFolder, "WithoutHaste.DataFiles.dll");
DotNetDocumentationFile docFile = new DotNetDocumentationFile(xmlFilename);
docFile.AddAssemblyInfo(dllFilename);
Console.WriteLine("Found {0} types in assembly", docFile.Types.Count);
//Test Markdown namespace
MarkdownFile mdFile = new MarkdownFile();
mdFile.AddSection("A Header");
string mdText = mdFile.ToMarkdownString();
Console.WriteLine("Some markdown: {0}", mdText);
Console.WriteLine("Done");
Console.ReadLine();
}
internal static DotNetDocumentationFile LoadXmlAndAssembly(string dllFilename, string xmlDocumentationFilename, string[] includeDlls)
{
DotNetDocumentationFile xmlDocumentation = new DotNetDocumentationFile(xmlDocumentationFilename);
xmlDocumentation.AddAssemblyInfo(dllFilename, includeDlls);
return(xmlDocumentation);
}
public void DotNetDocumentationFile_InheritComments_OneLevelDeep()
{
//arrange
string xmlDocumentationFilename = Utilities.GetPathTo("data/DotNetDocumentationFile_InheritComments_OneLevelDeep.xml");
//act
DotNetDocumentationFile xmlDocumentation = new DotNetDocumentationFile(xmlDocumentationFilename);
DotNetType inheritanceTypeA = xmlDocumentation.Types.First(t => t.Name.LocalName == "InheritanceClassA");
inheritanceTypeA.AddAssemblyInfo(typeof(InheritanceClassA), inheritanceTypeA.Name);
DotNetType inheritanceTypeB = xmlDocumentation.Types.First(t => t.Name.LocalName == "InheritanceClassB");
inheritanceTypeB.AddAssemblyInfo(typeof(InheritanceClassB), inheritanceTypeB.Name);
DotNetType inheritanceTypeC = xmlDocumentation.Types.First(t => t.Name.LocalName == "InheritanceInterfaceC");
inheritanceTypeC.AddAssemblyInfo(typeof(InheritanceInterfaceC), inheritanceTypeC.Name);
xmlDocumentation.ResolveInheritedComments();
//assert
Assert.AreEqual(inheritanceTypeA.SummaryComments[0], inheritanceTypeB.SummaryComments[0]);
Assert.AreEqual(inheritanceTypeA.Fields[0].SummaryComments[0], inheritanceTypeB.Fields[0].SummaryComments[0]);
Assert.AreEqual(inheritanceTypeA.Properties[0].SummaryComments[0], inheritanceTypeB.Properties.First(p => p.Name.LocalName == "PropertyA").SummaryComments[0]);
Assert.AreEqual(inheritanceTypeA.Events[0].SummaryComments[0], inheritanceTypeB.Events[0].SummaryComments[0]);
Assert.AreEqual(inheritanceTypeA.Methods[0].SummaryComments[0], inheritanceTypeB.Methods.First(p => p.Name.LocalName == "MethodA").SummaryComments[0]);
Assert.AreEqual(inheritanceTypeC.Properties[0].SummaryComments[0], inheritanceTypeB.Properties.First(p => p.Name.LocalName == "PropertyC").SummaryComments[0]);
Assert.AreEqual(inheritanceTypeC.Methods[0].SummaryComments[0], inheritanceTypeB.Methods.First(p => p.Name.LocalName == "MethodC").SummaryComments[0]);
}
public void DotNetDocumentationFile_DuplicateComments_OneLevelDeep()
{
//arrange
string filename = Utilities.GetPathTo("data/DotNetDocumentationFile_DuplicateComments_OneLevelDeep.xml");
//act
DotNetDocumentationFile file = new DotNetDocumentationFile(filename);
List <DotNetMember> members = new List <DotNetMember>();
foreach (DotNetType type in file.Types)
{
members.Add(type);
members.AddRange(type.Methods);
members.AddRange(type.Fields);
members.AddRange(type.Properties);
members.AddRange(type.Events);
}
DotNetMember typeA = members.OfType <DotNetType>().FirstOrDefault(m => m.Name.LocalName == "TypeA");
DotNetMember methodA = members.OfType <DotNetMethod>().FirstOrDefault(m => m.Name.LocalName == "MethodA");
DotNetMember fieldA = members.OfType <DotNetField>().FirstOrDefault(m => m.Name.LocalName == "FieldA");
DotNetMember propertyA = members.OfType <DotNetProperty>().FirstOrDefault(m => m.Name.LocalName == "PropertyA");
DotNetMember eventA = members.OfType <DotNetEvent>().FirstOrDefault(m => m.Name.LocalName == "EventA");
//assert
int count = 0;
foreach (DotNetMember member in members)
{
if (member.Name.LocalName.EndsWith("FromTypeA"))
{
Assert.AreEqual(typeA.SummaryComments[0], member.SummaryComments[0]);
}
else if (member.Name.LocalName.EndsWith("FromMethodA"))
{
Assert.AreEqual(methodA.SummaryComments[0], member.SummaryComments[0]);
}
else if (member.Name.LocalName.EndsWith("FromFieldA"))
{
Assert.AreEqual(fieldA.SummaryComments[0], member.SummaryComments[0]);
}
else if (member.Name.LocalName.EndsWith("FromPropertyA"))
{
Assert.AreEqual(propertyA.SummaryComments[0], member.SummaryComments[0]);
}
else if (member.Name.LocalName.EndsWith("FromEventA"))
{
Assert.AreEqual(eventA.SummaryComments[0], member.SummaryComments[0]);
}
else
{
continue;
}
count++;
}
Assert.AreEqual(25, count);
}
public void DotNetDocumentationFile_LoadFromFile()
{
//arrange
string filename = Utilities.GetPathTo("data/DotNetDocumentationFile_Assembly.xml");
//act
DotNetDocumentationFile file = new DotNetDocumentationFile(filename);
//assert
Assert.AreEqual(ASSEMBLY_NAME, file.AssemblyName);
}
public void DotNetDocumentationFile_OrphanedMember_Ignore()
{
//arrange
string filename = Utilities.GetPathTo("data/DotNetDocumentationFile_OrphanedMember.xml");
//act
DotNetDocumentationFile file = new DotNetDocumentationFile(filename);
//assert
Assert.AreEqual(0, file.Types.Count);
}
public void DotNetDocumentationFile_LoadFromXDocument()
{
//arrange
XDocument document = XDocument.Load(Utilities.GetPathTo("data/DotNetDocumentationFile_Assembly.xml"), LoadOptions.PreserveWhitespace);
//act
DotNetDocumentationFile file = new DotNetDocumentationFile(document);
//assert
Assert.AreEqual(ASSEMBLY_NAME, file.AssemblyName);
}
public void DotNetDocumentationFile_AddAssemblyInfo_LaterTargetFramework()
{
//arrange
XDocument document = XDocument.Load(Utilities.GetPathTo("data/DotNetDocumentationFile_Assembly.xml"), LoadOptions.PreserveWhitespace);
DotNetDocumentationFile file = new DotNetDocumentationFile(document);
string laterFrameworkDllFilename = Path.Combine(Utilities.GetProjectDirectory(), "../LaterFrameworkTest/bin/Debug/LaterFrameworkTest.dll");
//act
file.AddAssemblyInfo(laterFrameworkDllFilename);
//assert exception
}
private void GenerateAndSaveTableOfContents(DotNetDocumentationFile xmlDocumentation, DotNetQualifiedClassNameTreeNode node, string directory)
{
if (node.Value != null)
{
Save(GenerateTableOfContents(xmlDocumentation, node), directory, TableOfContentsFilename(node.Value));
}
foreach (DotNetQualifiedClassNameTreeNode child in node.Children)
{
GenerateAndSaveTableOfContents(xmlDocumentation, child, directory);
}
}
public void DotNetDocumentationFile_SmokeTest_Windows_GUI()
{
//arrange
string xmlDocumentationFilename = Path.Combine(Utilities.GetProjectDirectory(), "../../WithoutHaste.Windows.GUI/GUI/bin/Debug/WithoutHaste.Windows.GUI.XML");
string dllFilename = Path.Combine(Utilities.GetProjectDirectory(), "../../WithoutHaste.Windows.GUI/GUI/bin/Debug/WithoutHaste.Windows.GUI.dll");
//act
DotNetDocumentationFile xmlDocumentation = new DotNetDocumentationFile(xmlDocumentationFilename);
xmlDocumentation.AddAssemblyInfo(dllFilename);
//assert
Assert.IsTrue(xmlDocumentation.Types.Count(t => t.Category != TypeCategory.Unknown) > 0);
}
public void DotNetDocumentationFile_SmokeTest_EarlyDocsTest()
{
//arrange
string xmlDocumentationFilename = Path.Combine(Utilities.GetProjectDirectory(), "../../EarlyDocs/Test/bin/Debug/Test.XML");
string dllFilename = Path.Combine(Utilities.GetProjectDirectory(), "../../EarlyDocs/Test/bin/Debug/Test.dll");
//act
DotNetDocumentationFile xmlDocumentation = new DotNetDocumentationFile(xmlDocumentationFilename);
xmlDocumentation.AddAssemblyInfo(dllFilename);
//assert
Assert.IsTrue(xmlDocumentation.Types.Count(t => t.Category != TypeCategory.Unknown) > 0);
}
public void DotNetDocumentationFile_AddAssemblyInfo_ThirdParty_LaterTargetFramework()
{
//arrange
string xmlDocumentationFilename = Path.Combine(Utilities.GetProjectDirectory(), "../DataFiles/bin/Debug/WithoutHaste.DataFiles.XML");
string dllFilename = Path.Combine(Utilities.GetProjectDirectory(), "../DataFiles/bin/Debug/WithoutHaste.DataFiles.dll");
string laterFrameworkDllFilename = Path.Combine(Utilities.GetProjectDirectory(), "../LaterFrameworkTest/bin/Debug/LaterFrameworkTest.dll");
//act
DotNetDocumentationFile xmlDocumentation = new DotNetDocumentationFile(xmlDocumentationFilename);
xmlDocumentation.AddAssemblyInfo(dllFilename, laterFrameworkDllFilename);
//assert exception
}
public void DotNetDocumentationFile_SmokeTest_DataFiles()
{
//arrange
string xmlDocumentationFilename = Path.Combine(Utilities.GetProjectDirectory(), "../DataFiles/bin/Debug/WithoutHaste.DataFiles.XML");
string dllFilename = Path.Combine(Utilities.GetProjectDirectory(), "../DataFiles/bin/Debug/WithoutHaste.DataFiles.dll");
//act
DotNetDocumentationFile xmlDocumentation = new DotNetDocumentationFile(xmlDocumentationFilename);
//xmlDocumentation.AddAssemblyForReference("System.Xml");
xmlDocumentation.AddAssemblyInfo(dllFilename);
//assert
Assert.IsTrue(xmlDocumentation.Types.Count(t => t.Category != TypeCategory.Unknown) > 0);
}
public void DotNetDocumentationFile_InheritComments_NoBaseType()
{
//arrange
string xmlDocumentationFilename = Utilities.GetPathTo("data/DotNetDocumentationFile_InheritComments_NoBaseType.xml");
//act
DotNetDocumentationFile xmlDocumentation = new DotNetDocumentationFile(xmlDocumentationFilename);
DotNetType inheritanceTypeA = xmlDocumentation.Types.First(t => t.Name.LocalName == "InheritanceClassA");
inheritanceTypeA.AddAssemblyInfo(typeof(InheritanceClassA), inheritanceTypeA.Name);
xmlDocumentation.ResolveInheritedComments();
//assert
Assert.AreEqual(CommentTag.InheritDoc, inheritanceTypeA.FloatingComments[0].Tag);
}
public void DotNetCommentInherit_FromAssembly_MethodFromBaseType()
{
//arrange
string filename = Utilities.GetPathTo("data/DotNetCommentInherit_TypeFromBaseType.xml");
//act
DotNetDocumentationFile file = new DotNetDocumentationFile(filename);
file.Types.First(t => t.Name.LocalName == "DerivedType").AddAssemblyInfo(typeof(DerivedType), new DotNetQualifiedName("DataFilesTest", "DotNetCommentInheritTests", "DerivedType"));
file.ResolveInheritedComments();
//assert
Assert.AreEqual(2, file.Types.Count);
Assert.AreEqual(file.Types[0].Methods.First(m => m.Name.LocalName == "MethodA" && m.MethodName.Parameters.Count == 0).SummaryComments.Comments[0], file.Types[1].Methods.First(m => m.Name.LocalName == "MethodA" && m.MethodName.Parameters.Count == 0).SummaryComments.Comments[0]);
}
public void MiscTests_GenericParameters()
{
//arrange
//act
DotNetDocumentationFile file = EarlyDocs.ConvertXML.LoadXmlAndAssembly("../../../Test/bin/Debug/Test.dll", "../../../Test/bin/Debug/Test.XML", new string[] { });
DotNetType genericType = file.Types.First(t => t.Name.LocalName == "ClassExceptionGeneric<Apple>");
string markdown = EarlyDocs.DotNetExtensions.ToMarkdownFile(genericType).ToMarkdownString();
//assert
Assert.IsTrue(markdown.Contains("Apple { public get; protected set; }"));
Assert.IsTrue(markdown.Contains("ClassExceptionGeneric<Apple>(Apple value)"));
Assert.IsTrue(markdown.Contains("MethodA(Apple value)"));
}
internal ConvertXML(string dllFilename, string xmlDocumentationFilename, string outputDirectory, string[] includeDlls, bool emptyOutputDirectoryFirst)
{
DotNetDocumentationFile xmlDocumentation = LoadXmlAndAssembly(dllFilename, xmlDocumentationFilename, includeDlls);
DotNetExtensions.TurnQualifiedNameConverterOn();
PrepareOutputDirectory(outputDirectory, emptyOutputDirectoryFirst);
BuildInternalFullNames(xmlDocumentation.Types);
BuildInternalFullNames(xmlDocumentation.Delegates);
BuildInterfaceImplementedByTypes(xmlDocumentation.Types);
BuildTypeDerivedBy(xmlDocumentation.Types);
GenerateTypePages(xmlDocumentation.Types, outputDirectory);
GenerateDelegatePages(xmlDocumentation.Delegates, outputDirectory);
GenerateTableOfContents(xmlDocumentation, outputDirectory);
}
public void DotNetDocumentationFile_DuplicateComments_Loop()
{
//arrange
string filename = Utilities.GetPathTo("data/DotNetDocumentationFile_DuplicateComments_Loop.xml");
//act
DotNetDocumentationFile file = new DotNetDocumentationFile(filename);
DotNetType typeA = file.Types.FirstOrDefault(m => m.Name.LocalName == "TypeA");
DotNetType typeB = file.Types.FirstOrDefault(m => m.Name.LocalName == "TypeB");
DotNetType typeC = file.Types.FirstOrDefault(m => m.Name.LocalName == "TypeC");
//assert
Assert.AreNotEqual(typeA.FloatingComments[0], typeB.FloatingComments[0]);
Assert.AreNotEqual(typeB.FloatingComments[0], typeC.FloatingComments[0]);
Assert.AreNotEqual(typeC.FloatingComments[0], typeA.FloatingComments[0]);
}
public void DotNetDocumentationFile_InheritComments_DifferentGenericAliases()
{
//arrange
string xmlDocumentationFilename = Utilities.GetPathTo("data/DotNetDocumentationFile_InheritComments_DifferentGenericAliases.xml");
//act
DotNetDocumentationFile xmlDocumentation = new DotNetDocumentationFile(xmlDocumentationFilename);
DotNetType inheritanceTypeI = xmlDocumentation.Types.First(t => t.Name.LocalName == "InheritanceClassI");
inheritanceTypeI.AddAssemblyInfo(typeof(InheritanceClassI), inheritanceTypeI.Name);
DotNetType inheritanceTypeJ = xmlDocumentation.Types.First(t => t.Name.LocalName == "InheritanceClassJ");
inheritanceTypeJ.AddAssemblyInfo(typeof(InheritanceClassJ), inheritanceTypeJ.Name);
xmlDocumentation.ResolveInheritedComments();
//assert
Assert.AreEqual(inheritanceTypeI.Methods[0].SummaryComments[0], inheritanceTypeJ.Methods[0].SummaryComments[0]);
}
public void DotNetDocumentationFile_InheritComments_OrderOfInterfaces()
{
//arrange
string xmlDocumentationFilename = Utilities.GetPathTo("data/DotNetDocumentationFile_InheritComments_OrderOfInterfaces.xml");
//act
DotNetDocumentationFile xmlDocumentation = new DotNetDocumentationFile(xmlDocumentationFilename);
DotNetType inheritanceTypeF = xmlDocumentation.Types.First(t => t.Name.LocalName == "InheritanceInterfaceF");
inheritanceTypeF.AddAssemblyInfo(typeof(InheritanceInterfaceF), inheritanceTypeF.Name);
DotNetType inheritanceTypeG = xmlDocumentation.Types.First(t => t.Name.LocalName == "InheritanceInterfaceG");
inheritanceTypeG.AddAssemblyInfo(typeof(InheritanceInterfaceG), inheritanceTypeG.Name);
DotNetType inheritanceTypeH = xmlDocumentation.Types.First(t => t.Name.LocalName == "InheritanceClassH");
inheritanceTypeH.AddAssemblyInfo(typeof(InheritanceClassH), inheritanceTypeH.Name);
xmlDocumentation.ResolveInheritedComments();
//assert
Assert.AreEqual(inheritanceTypeG.Properties[0].SummaryComments[0], inheritanceTypeH.Properties.First(p => p.Name.LocalName == "PropertyA").SummaryComments[0]);
}
public void DotNetDocumentationFile_DuplicateComments_MultipleLevelsDeep()
{
//arrange
string filename = Utilities.GetPathTo("data/DotNetDocumentationFile_DuplicateComments_MultipleLevelsDeep.xml");
//act
DotNetDocumentationFile file = new DotNetDocumentationFile(filename);
DotNetType typeA = file.Types.FirstOrDefault(m => m.Name.LocalName == "TypeA");
//assert
int count = 0;
foreach (DotNetType type in file.Types)
{
if (type == typeA)
{
continue;
}
Assert.AreEqual(typeA.SummaryComments[0], type.SummaryComments[0]);
count++;
}
Assert.AreEqual(5, count);
}
private MarkdownSection BuildMasterSummary(DotNetDocumentationFile xmlDocumentation, DotNetQualifiedClassNameTreeNode node)
{
string header = (new MarkdownInlineLink(node.Value, TableOfContentsFilename(node.Value))).ToMarkdownString(null);
MarkdownSection section = new MarkdownSection(header);
List <DotNetType> types = xmlDocumentation.Types.Where(t => t.Name.FullNamespace == node.Value).ToList();
foreach (DotNetType type in types.OrderBy(t => t.Name))
{
section.Add(new MarkdownLine(new MarkdownInlineLink(type.Name, FormatFilename(type.Name + Ext.MD))));
}
List <DotNetDelegate> _delegates = xmlDocumentation.Delegates.Where(d => d.Name.FullNamespace == node.Value).ToList();
foreach (DotNetDelegate _delegate in _delegates.OrderBy(d => d.Name))
{
section.Add(new MarkdownLine(new MarkdownInlineLink(_delegate.Name, FormatFilename(_delegate.Name + Ext.MD))));
}
foreach (DotNetQualifiedClassNameTreeNode child in node.Children.OrderBy(c => c.Value))
{
section.AddSection(BuildMasterSummary(xmlDocumentation, child));
}
return(section);
}
private void GenerateTableOfContents(DotNetDocumentationFile xmlDocumentation, string directory)
{
List <DotNetQualifiedClassName> _namespaces = new List <DotNetQualifiedClassName>();
foreach (DotNetType type in xmlDocumentation.Types)
{
_namespaces.Add(type.ClassName.FullClassNamespace);
}
foreach (DotNetDelegate _delegate in xmlDocumentation.Delegates)
{
_namespaces.Add(_delegate.MethodName.FullClassNamespace);
}
_namespaces = _namespaces.Distinct().ToList();
DotNetQualifiedClassNameTreeNode root = DotNetQualifiedClassNameTreeNode.Generate(_namespaces);
GenerateAndSaveTableOfContents(xmlDocumentation, root, directory);
//master table of contents
MarkdownFile markdown = new MarkdownFile();
MarkdownSection section = markdown.AddSection("Table of Contents");
if (root.Value == null)
{
foreach (DotNetQualifiedClassNameTreeNode node in root.Children)
{
MarkdownSection subsection = BuildMasterSummary(xmlDocumentation, node);
section.AddSection(subsection);
}
}
else
{
MarkdownSection subsection = BuildMasterSummary(xmlDocumentation, root);
section.AddSection(subsection);
}
Save(markdown, directory, "TableOfContents" + Ext.MD);
}
public void DotNetDocumentationFile_CommentFromXml_Full()
{
//arrange
XDocument document = XDocument.Load(Utilities.GetPathTo("data/DotNetDocumentationFile_Full.xml"), LoadOptions.PreserveWhitespace);
//act
DotNetDocumentationFile file = new DotNetDocumentationFile(document);
//assert
Assert.AreEqual(5, file.TypeCount);
DotNetType typeA = file.Types[0];
Assert.AreEqual(2, typeA.NestedTypeCount);
Assert.AreEqual("Test.TypeA", typeA.Name.FullName);
Assert.AreEqual(true, typeA.HasComments);
Assert.AreEqual(1, typeA.Methods.Count);
Assert.AreEqual(2, typeA.Fields.Count);
Assert.AreEqual(3, typeA.Properties.Count);
Assert.AreEqual(1, typeA.Events.Count);
DotNetType typeB = typeA.NestedTypes[0];
Assert.AreEqual(1, typeB.NestedTypeCount);
Assert.AreEqual("Test.TypeA.NestedTypeB", typeB.Name.FullName);
Assert.AreEqual(true, typeB.HasComments);
Assert.AreEqual(1, typeB.Methods.Count);
DotNetType typeC = typeB.NestedTypes[0];
Assert.AreEqual(0, typeC.NestedTypeCount);
Assert.AreEqual("Test.TypeA.NestedTypeB.SubNestedTypeC", typeC.Name.FullName);
Assert.AreEqual(true, typeC.HasComments);
Assert.AreEqual(2, typeC.Methods.Count);
DotNetType typeD = file.Types[1];
Assert.AreEqual("Test.SingleGenericTypeD<T>", typeD.Name.FullName);
Assert.AreEqual(false, typeD.HasComments);
Assert.AreEqual(1, typeD.Methods.Count);
DotNetType typeE = file.Types[2];
Assert.AreEqual("Test.DoubleGenericTypeE<T,U>", typeE.Name.FullName);
Assert.AreEqual(false, typeE.HasComments);
Assert.AreEqual(3, typeE.Methods.Count);
DotNetMethod methodAA = typeA.Methods[0];
Assert.AreEqual("Test.TypeA.MethodAA", methodAA.Name.FullName);
Assert.AreEqual(true, methodAA.HasComments);
Assert.AreEqual(false, methodAA is DotNetMethodConstructor);
Assert.AreEqual(false, methodAA is DotNetMethodOperator);
Assert.AreEqual(0, methodAA.MethodName.Parameters.Count);
DotNetMethod methodBA = typeB.Methods[0];
Assert.AreEqual("Test.TypeA.NestedTypeB.MethodBA", methodBA.Name.FullName);
Assert.AreEqual(false, methodBA.HasComments);
Assert.AreEqual(false, methodBA is DotNetMethodConstructor);
Assert.AreEqual(false, methodBA is DotNetMethodOperator);
Assert.AreEqual(2, methodBA.MethodName.Parameters.Count);
DotNetMethod methodCA = typeC.Methods[0];
Assert.AreEqual("Test.TypeA.NestedTypeB.SubNestedTypeC.MethodCA", methodCA.Name.FullName);
Assert.AreEqual(false, methodCA.HasComments);
Assert.AreEqual(false, methodCA is DotNetMethodConstructor);
Assert.AreEqual(false, methodCA is DotNetMethodOperator);
Assert.AreEqual(1, methodCA.MethodName.Parameters.Count);
DotNetMethod methodCConstructor = typeC.Methods[1];
Assert.AreEqual("Test.TypeA.NestedTypeB.SubNestedTypeC.#ctor", methodCConstructor.Name.FullName);
Assert.AreEqual(false, methodCConstructor.HasComments);
Assert.AreEqual(true, methodCConstructor is DotNetMethodConstructor);
Assert.AreEqual(false, methodCConstructor is DotNetMethodOperator);
Assert.AreEqual(0, methodCConstructor.MethodName.Parameters.Count);
DotNetMethod methodDAddition = typeD.Methods[0];
Assert.AreEqual("Test.SingleGenericTypeD<T>.op_Addition", methodDAddition.Name.FullName);
Assert.AreEqual(false, methodDAddition.HasComments);
Assert.AreEqual(false, methodDAddition is DotNetMethodConstructor);
Assert.AreEqual(true, methodDAddition is DotNetMethodOperator);
Assert.AreEqual(2, methodDAddition.MethodName.Parameters.Count);
Assert.AreEqual("T", methodDAddition.MethodName.Parameters[0].FullTypeName);
Assert.AreEqual("Test.SingleGenericTypeD<T>", methodDAddition.MethodName.Parameters[1].FullTypeName);
DotNetMethod methodEConstructor = typeE.Methods[0];
Assert.AreEqual("Test.DoubleGenericTypeE<T,U>.#ctor", methodEConstructor.Name.FullName);
Assert.AreEqual(false, methodEConstructor.HasComments);
Assert.AreEqual(true, methodEConstructor is DotNetMethodConstructor);
Assert.AreEqual(false, methodEConstructor is DotNetMethodOperator);
Assert.AreEqual(2, methodEConstructor.MethodName.Parameters.Count);
Assert.AreEqual("U", methodEConstructor.MethodName.Parameters[0].FullTypeName);
Assert.AreEqual("T", methodEConstructor.MethodName.Parameters[1].FullTypeName);
DotNetMethod methodEA = typeE.Methods[1];
Assert.AreEqual("Test.DoubleGenericTypeE<T,U>.MethodEA<A>", methodEA.Name.FullName);
Assert.AreEqual(false, methodEA.HasComments);
Assert.AreEqual(false, methodEA is DotNetMethodConstructor);
Assert.AreEqual(false, methodEA is DotNetMethodOperator);
Assert.AreEqual(3, methodEA.MethodName.Parameters.Count);
Assert.AreEqual("System.String", methodEA.MethodName.Parameters[0].FullTypeName);
Assert.AreEqual("A", methodEA.MethodName.Parameters[1].FullTypeName);
Assert.AreEqual("U", methodEA.MethodName.Parameters[2].FullTypeName);
DotNetMethod methodEB = typeE.Methods[2];
Assert.AreEqual("Test.DoubleGenericTypeE<T,U>.MethodEB<A>", methodEB.Name.FullName);
Assert.AreEqual(false, methodEB.HasComments);
Assert.AreEqual(false, methodEB is DotNetMethodConstructor);
Assert.AreEqual(false, methodEB is DotNetMethodOperator);
Assert.AreEqual(1, methodEB.MethodName.Parameters.Count);
Assert.AreEqual("System.Collections.Generic.List<Test.SingleGenericTypeD<T>>", methodEB.MethodName.Parameters[0].FullTypeName);
}
