public void DotNetMethod_FromAssembly_OptionalParameter()
{
//arrange
XElement xmlTypeElement = XElement.Parse("<member name='T:DataFilesTest.DotNetMethodTests.NormalClass' />", LoadOptions.PreserveWhitespace);
XElement xmlMemberElement = XElement.Parse("<member name='M:DataFilesTest.DotNetMethodTests.NormalClass.MethodOptional(System.Int32,System.String)' />", LoadOptions.PreserveWhitespace);
Type type = typeof(NormalClass);
DotNetType dotNetType = new DotNetType(new DotNetQualifiedClassName("DataFilesTest.DotNetMethodTests.NormalClass"));
dotNetType.AddMember(DotNetMethod.FromVisualStudioXml(xmlMemberElement));
//act
dotNetType.AddAssemblyInfo(type, dotNetType.Name);
DotNetMethod result = dotNetType.Methods[0];
//assert
Assert.AreEqual(2, result.MethodName.Parameters.Count);
Assert.AreEqual("System.Int32", result.MethodName.Parameters[0].FullTypeName);
Assert.AreEqual("a", result.MethodName.Parameters[0].Name);
Assert.AreEqual(ParameterCategory.Optional, result.MethodName.Parameters[0].Category);
Assert.AreEqual(5, result.MethodName.Parameters[0].DefaultValue);
Assert.AreEqual("System.String", result.MethodName.Parameters[1].FullTypeName);
Assert.AreEqual("b", result.MethodName.Parameters[1].Name);
Assert.AreEqual(ParameterCategory.Optional, result.MethodName.Parameters[1].Category);
Assert.IsNull(result.MethodName.Parameters[1].DefaultValue);
Assert.AreEqual("System.String b = null", result.MethodName.Parameters[1].SignatureWithName);
}
public void RegisterFunction(string s)
{
MethodInfo mi = GetType().GetMethod(s);
DotNetMethod m = new DotNetMethod(mi, DotNetObject.Marshal(this));
vm.AddVar(s, m);
}
public static MethodArgStack MethodPtr(DotNetMethod method)
{
return(new MethodArgStack()
{
type = StackItemType.MethodPtr, value = method
});
}
public void DotNetMethod_FromXml_GenericParameter()
{
//arrange
XElement xmlElement = XElement.Parse("<member name='M:Demo.DoubleGenericClass`2.op_Addition(`0,Demo.DoubleGenericClass{`0,`1})' />", LoadOptions.PreserveWhitespace);
string expectedFullName = "Demo.DoubleGenericClass<T,U>.op_Addition";
//act
DotNetMethod result = DotNetMethod.FromVisualStudioXml(xmlElement);
//assert
Assert.AreEqual(expectedFullName, result.Name.FullName);
}
public void DotNetMethodOperator_Equals_True()
{
//arrange
string xml = "<member name='M:MyNamespace.MyClass.op_Addition(MyNamespace.MyClass,System.Int32)' />";
XElement element = XElement.Parse(xml, LoadOptions.PreserveWhitespace);
DotNetMethodOperator a = (DotNetMethodOperator)DotNetMethod.FromVisualStudioXml(element);
DotNetMethodOperator b = (DotNetMethodOperator)DotNetMethod.FromVisualStudioXml(element);
//act
bool result = (a == b);
//assert
Assert.IsTrue(result);
}
public void DotNetMethod_FromAssembly_AbstractClassProtectedMethod()
{
//arrange
XElement xmlElement = XElement.Parse("<member name='M:DataFilesTest.DotNetMethodTests.AbstractClass.MethodProtected()'></member>", LoadOptions.PreserveWhitespace);
Type type = typeof(AbstractClass);
MethodInfo methodInfo = type.GetDeclaredMethods().First(m => m.Name == "MethodProtected");
//act
DotNetMethod result = DotNetMethod.FromVisualStudioXml(xmlElement);
result.AddAssemblyInfo(methodInfo);
//assert
Assert.AreEqual(MethodCategory.Protected, result.Category);
}
public void DotNetMethod_FromAssembly_ParamComment()
{
//arrange
XElement xmlElement = XElement.Parse("<member name='M:DataFilesTest.DotNetMethodTests.ParameterClass.MethodOneNormalParameter(System.Int32)'><param name='a'>Comments</param></member>", LoadOptions.PreserveWhitespace);
Type type = typeof(ParameterClass);
MethodInfo methodInfo = type.GetMethods().First(m => m.Name == "MethodOneNormalParameter");
//act
DotNetMethod result = DotNetMethod.FromVisualStudioXml(xmlElement);
result.AddAssemblyInfo(methodInfo);
//assert
Assert.AreEqual(1, result.ParameterComments.Count);
Assert.IsNotNull(result.ParameterComments[0]);
}
public void DotNetMethodConstructor_FromAssembly_StaticConstructor()
{
//arrange
XElement xmlElement = XElement.Parse("<member name='M:DataFilesTest.DotNetMethodConstructorTests.ClassA.#cctor' />", LoadOptions.PreserveWhitespace);
Type type = typeof(ClassA);
ConstructorInfo constructorInfo = type.GetDeclaredConstructors().First(m => m.Name == ".cctor");
//act
DotNetMethod result = DotNetMethod.FromVisualStudioXml(xmlElement);
DotNetMethodConstructor constructorResult = (result as DotNetMethodConstructor);
constructorResult.AddAssemblyInfo(constructorInfo);
//assert
Assert.AreEqual(MethodCategory.Static, constructorResult.Category);
}
public void DotNetMethod_FromAssembly_MethodOneGeneric_AddedToMethod()
{
//arrange
XElement xmlElement = XElement.Parse("<member name='M:DataFilesTest.DotNetMethodTests.NormalClass.MethodOneGeneric``1' />", LoadOptions.PreserveWhitespace);
string expectedFullName = "DataFilesTest.DotNetMethodTests.NormalClass.MethodOneGeneric<CustomA>";
Type type = typeof(NormalClass);
MethodInfo methodInfo = type.GetMethods().First(m => m.Name == "MethodOneGeneric");
//act
DotNetMethod result = DotNetMethod.FromVisualStudioXml(xmlElement);
result.AddAssemblyInfo(methodInfo);
//assert
Assert.AreEqual(expectedFullName, result.Name.FullName);
}
public void DotNetMethodOperator_FromAssembly_ExplicitOperator()
{
//arrange
XElement xmlElement = XElement.Parse("<member name='M:DataFilesTest.DotNetMethodOperatorTests.ClassA.op_Explicit(DataFilesTest.DotNetMethodOperatorTests.ClassA)~System.Int64' />", LoadOptions.PreserveWhitespace);
Type type = typeof(ClassA);
MethodInfo methodInfo = type.GetMethods().First(m => m.Name == "op_Explicit");
//act
DotNetMethod result = DotNetMethod.FromVisualStudioXml(xmlElement);
result.AddAssemblyInfo(methodInfo);
//assert
Assert.AreEqual("System.Single", result.MethodName.ReturnTypeName);
Assert.AreEqual("DataFilesTest.DotNetMethodOperatorTests.ClassA", result.MethodName.Parameters[0].TypeName);
}
public void DotNetMethod_FromAssembly_ZeroParameters()
{
//arrange
XElement xmlElement = XElement.Parse("<member name='M:DataFilesTest.DotNetMethodTests.ParameterClass.MethodZeroParameters' />", LoadOptions.PreserveWhitespace);
string expectedFullName = "DataFilesTest.DotNetMethodTests.ParameterClass.MethodZeroParameters";
Type type = typeof(ParameterClass);
MethodInfo methodInfo = type.GetMethods().First(m => m.Name == "MethodZeroParameters");
//act
DotNetMethod result = DotNetMethod.FromVisualStudioXml(xmlElement);
result.AddAssemblyInfo(methodInfo);
//assert
Assert.AreEqual(expectedFullName, result.Name.FullName);
Assert.AreEqual(0, result.MethodName.Parameters.Count);
}
public void DotNetMethodOperator_Equals_DifferentParameterCounts_False()
{
//arrange
string xmlA = "<member name='M:MyNamespace.MyClass.op_Addition(MyNamespace.MyClass,System.Int32)' />";
string xmlB = "<member name='M:MyNamespace.MyClass.op_Addition(MyNamespace.MyClass)' />";
XElement elementA = XElement.Parse(xmlA, LoadOptions.PreserveWhitespace);
XElement elementB = XElement.Parse(xmlB, LoadOptions.PreserveWhitespace);
DotNetMethodOperator a = (DotNetMethodOperator)DotNetMethod.FromVisualStudioXml(elementA);
DotNetMethodOperator b = (DotNetMethodOperator)DotNetMethod.FromVisualStudioXml(elementB);
//act
bool result = (a == b);
//assert
Assert.IsFalse(result);
}
public void DotNetMethod_FromAssembly_ReturnNestedGeneric()
{
//arrange
XElement xmlElement = XElement.Parse("<member name='M:DataFilesTest.DotNetMethodTests.NormalClass.MethodReturnNestedGeneric' />", LoadOptions.PreserveWhitespace);
string expectedFullName = "DataFilesTest.DotNetMethodTests.NormalClass.MethodReturnNestedGeneric";
string expectedReturnFullName = "DataFilesTest.DotNetMethodTests.GenericOne<System.String>.NestedGeneric<System.Int32>";
Type type = typeof(NormalClass);
MethodInfo methodInfo = type.GetMethods().First(m => m.Name == "MethodReturnNestedGeneric");
//act
DotNetMethod result = DotNetMethod.FromVisualStudioXml(xmlElement);
result.AddAssemblyInfo(methodInfo);
//assert
Assert.AreEqual(expectedFullName, result.Name.FullName);
Assert.AreEqual(expectedReturnFullName, result.MethodName.ReturnTypeName.FullName);
}
public void DotNetReferenceClassGeneric_FromAssembly_ReturnType()
{
//arrange
XElement typeXmlElement = XElement.Parse("<member name='T:DataFilesTest.DotNetReferenceClassGenericTests.ClassGeneric`1' />", LoadOptions.PreserveWhitespace);
XElement methodXmlElement = XElement.Parse("<member name='M:DataFilesTest.DotNetReferenceClassGenericTests.ClassGeneric`1.MethodA' />", LoadOptions.PreserveWhitespace);
Type type = typeof(ClassGeneric <>);
//act
DotNetType typeResult = DotNetType.FromVisualStudioXml(typeXmlElement);
DotNetMethod methodResult = DotNetMethod.FromVisualStudioXml(methodXmlElement);
typeResult.AddMember(methodResult);
typeResult.AddAssemblyInfo(type, typeResult.Name);
//assert
Assert.AreEqual(MethodCategory.Normal, methodResult.Category);
Assert.AreEqual("Apple", methodResult.MethodName.ReturnTypeName);
}
public void DotNetMethod_FromAssembly_GenericClassGenericMethodOneParameterFromMethod()
{
//arrange
XElement xmlElement = XElement.Parse("<member name='M:DataFilesTest.DotNetMethodTests.GenericOne`1.MethodMethodGeneric``1(``0)' />", LoadOptions.PreserveWhitespace);
string expectedFullName = "DataFilesTest.DotNetMethodTests.GenericOne<T>.MethodMethodGeneric<A>";
Type type = typeof(GenericOne <>);
MethodInfo methodInfo = type.GetMethods().First(m => m.Name == "MethodMethodGeneric");
//act
DotNetMethod result = DotNetMethod.FromVisualStudioXml(xmlElement);
result.AddAssemblyInfo(methodInfo);
//assert
Assert.AreEqual(expectedFullName, result.Name.FullName);
Assert.AreEqual(1, result.MethodName.Parameters.Count);
Assert.AreEqual("A", result.MethodName.Parameters[0].FullTypeName);
Assert.AreEqual("a", result.MethodName.Parameters[0].Name);
}
public void DotNetMethod_FromAssembly_MethodOneGeneric_AddedToType()
{
//arrange
XElement typeXmlElement = XElement.Parse("<member name='T:DataFilesTest.DotNetMethodTests.NormalClass' />", LoadOptions.PreserveWhitespace);
XElement methodXmlElement = XElement.Parse("<member name='M:DataFilesTest.DotNetMethodTests.NormalClass.MethodOneGeneric``1' />", LoadOptions.PreserveWhitespace);
string expectedFullName = "DataFilesTest.DotNetMethodTests.NormalClass.MethodOneGeneric<CustomA>";
Type type = typeof(NormalClass);
//act
DotNetType typeResult = DotNetType.FromVisualStudioXml(typeXmlElement);
DotNetMethod methodResult = DotNetMethod.FromVisualStudioXml(methodXmlElement);
typeResult.AddMember(methodResult);
Assert.IsTrue(methodResult.MatchesSignature(type.GetDeclaredMethods().First(m => m.Name == "MethodOneGeneric")));
typeResult.AddAssemblyInfo(type, typeResult.Name);
//assert
Assert.AreEqual(expectedFullName, typeResult.Methods[0].Name.FullName);
}
public void DotNetMethod_FromAssembly_RefParameter()
{
//arrange
XElement xmlTypeElement = XElement.Parse("<member name='T:DataFilesTest.DotNetMethodTests.NormalClass' />", LoadOptions.PreserveWhitespace);
XElement xmlMemberElement = XElement.Parse("<member name='M:DataFilesTest.DotNetMethodTests.NormalClass.MethodRef(System.Int32@)' />", LoadOptions.PreserveWhitespace);
Type type = typeof(NormalClass);
DotNetType dotNetType = new DotNetType(new DotNetQualifiedClassName("DataFilesTest.DotNetMethodTests.NormalClass"));
dotNetType.AddMember(DotNetMethod.FromVisualStudioXml(xmlMemberElement));
//act
dotNetType.AddAssemblyInfo(type, dotNetType.Name);
DotNetMethod result = dotNetType.Methods[0];
//assert
Assert.AreEqual(1, result.MethodName.Parameters.Count);
Assert.AreEqual("System.Int32", result.MethodName.Parameters[0].FullTypeName);
Assert.AreEqual("a", result.MethodName.Parameters[0].Name);
Assert.AreEqual(ParameterCategory.Ref, result.MethodName.Parameters[0].Category);
}
public void DotNetMethod_FromAssembly_ExtensionMethodParameters()
{
//arrange
XElement xmlElement = XElement.Parse("<member name='M:DataFilesTest.StaticTestClass.MethodExtension(System.String,System.String)'></member>", LoadOptions.PreserveWhitespace);
Type type = typeof(StaticTestClass);
MethodInfo methodInfo = type.GetDeclaredMethods().First(m => m.Name == "MethodExtension");
//act
DotNetMethod result = DotNetMethod.FromVisualStudioXml(xmlElement);
result.AddAssemblyInfo(methodInfo);
//assert
#if DATAFILES_TARGET_20 || DATAFILES_TARGET_30
Assert.AreEqual(MethodCategory.Static, result.Category);
Assert.AreEqual(ParameterCategory.Normal, result.MethodName.Parameters[0].Category);
#else
Assert.AreEqual(MethodCategory.Extension, result.Category);
Assert.AreEqual(ParameterCategory.Extension, result.MethodName.Parameters[0].Category);
#endif
Assert.AreEqual(ParameterCategory.Normal, result.MethodName.Parameters[1].Category);
}
public void DotNetMethod_ThirdPartyTypes()
{
//arrange
string xmlDocumentationFilename = Path.Combine(Utilities.GetProjectDirectory(), "../ThirdPartyTest/bin/Debug/ThirdPartyTest.XML");
string dllFilename = Path.Combine(Utilities.GetProjectDirectory(), "../ThirdPartyTest/bin/Debug/ThirdPartyTest.dll");
string thirdPartyDllFilename = Path.Combine(Utilities.GetProjectDirectory(), "../ThirdPartyTest/bin/Debug/Markdown.dll");
//act
DotNetDocumentationFile xmlDocumentation = new DotNetDocumentationFile(xmlDocumentationFilename);
xmlDocumentation.AddAssemblyInfo(dllFilename, thirdPartyDllFilename);
//assert
DotNetType type = xmlDocumentation.Types[0];
DotNetMethod methodA = type.Methods.First(m => m.Name.LocalName == "MethodA");
DotNetMethod methodB = type.Methods.First(m => m.Name.LocalName == "MethodB");
DotNetMethod methodC = type.Methods.First(m => m.Name.LocalName == "MethodC");
Assert.AreEqual("HeyRed.MarkdownSharp.Markdown", methodA.MethodName.ReturnTypeName);
Assert.AreEqual(0, methodA.MethodName.Parameters.Count);
Assert.AreEqual("System.Void", methodB.MethodName.ReturnTypeName);
Assert.AreEqual(1, methodB.MethodName.Parameters.Count);
Assert.AreEqual("HeyRed.MarkdownSharp.Markdown", methodC.MethodName.ReturnTypeName);
Assert.AreEqual(1, methodC.MethodName.Parameters.Count);
}
public void DotNetMethodOperator_SortLINQ_OperatorOrder_ByParameters()
{
//arrange
string xmlA = "<member name='M:MyNamespace.MyClass.op_Addition(MyNamespace.MyClass,System.Byte)' />";
string xmlB = "<member name='M:MyNamespace.MyClass.op_Addition(MyNamespace.MyClass,System.Decimal)' />";
string xmlC = "<member name='M:MyNamespace.MyClass.op_Addition(MyNamespace.MyClass,System.Int32)' />";
string xmlD = "<member name='M:MyNamespace.MyClass.op_Addition(MyNamespace.MyClass,System.Int64)' />";
List <DotNetMethodOperator> list = new List <DotNetMethodOperator>()
{
(DotNetMethodOperator)DotNetMethod.FromVisualStudioXml(XElement.Parse(xmlC, LoadOptions.PreserveWhitespace)),
(DotNetMethodOperator)DotNetMethod.FromVisualStudioXml(XElement.Parse(xmlA, LoadOptions.PreserveWhitespace)),
(DotNetMethodOperator)DotNetMethod.FromVisualStudioXml(XElement.Parse(xmlD, LoadOptions.PreserveWhitespace)),
(DotNetMethodOperator)DotNetMethod.FromVisualStudioXml(XElement.Parse(xmlB, LoadOptions.PreserveWhitespace)),
};
//act
list = list.OrderBy(x => x).ToList();
//assert
Assert.AreEqual("System.Byte", list[0].MethodName.Parameters[1].TypeName);
Assert.AreEqual("System.Decimal", list[1].MethodName.Parameters[1].TypeName);
Assert.AreEqual("System.Int32", list[2].MethodName.Parameters[1].TypeName);
Assert.AreEqual("System.Int64", list[3].MethodName.Parameters[1].TypeName);
}
public void DotNetMethodOperator_Sort_OperatorOrder_RegardlessOfParameters()
{
//arrange
string xmlA = "<member name='M:MyNamespace.MyClass.op_Addition(MyNamespace.MyClass,System.Int32)' />";
string xmlB = "<member name='M:MyNamespace.MyClass.op_Subtraction(MyNamespace.MyClass,System.Byte)' />";
string xmlC = "<member name='M:MyNamespace.MyClass.op_Multiply(MyNamespace.MyClass,System.Int64)' />";
string xmlD = "<member name='M:MyNamespace.MyClass.op_Division(MyNamespace.MyClass,System.Decimal)' />";
List <DotNetMethodOperator> list = new List <DotNetMethodOperator>()
{
(DotNetMethodOperator)DotNetMethod.FromVisualStudioXml(XElement.Parse(xmlC, LoadOptions.PreserveWhitespace)),
(DotNetMethodOperator)DotNetMethod.FromVisualStudioXml(XElement.Parse(xmlA, LoadOptions.PreserveWhitespace)),
(DotNetMethodOperator)DotNetMethod.FromVisualStudioXml(XElement.Parse(xmlD, LoadOptions.PreserveWhitespace)),
(DotNetMethodOperator)DotNetMethod.FromVisualStudioXml(XElement.Parse(xmlB, LoadOptions.PreserveWhitespace)),
};
//act
list.Sort();
//assert
Assert.AreEqual("op_Addition", list[0].Name.LocalName);
Assert.AreEqual("op_Subtraction", list[1].Name.LocalName);
Assert.AreEqual("op_Multiply", list[2].Name.LocalName);
Assert.AreEqual("op_Division", list[3].Name.LocalName);
}
public void DotNetProperty_Assembly_ExplicitInterfaceImplementation_Properties()
{
//arrange
Type type = typeof(ExplicitInterfaceImplementation);
DotNetType dotNetType = DotNetType.FromVisualStudioXml(XElement.Parse("<member name='T:DataFilesTest.DotNetPropertyTests.ExplicitInterfaceImplementation'></member>", LoadOptions.PreserveWhitespace));
dotNetType.AddMember(DotNetProperty.FromVisualStudioXml(XElement.Parse("<member name='P:DataFilesTest.DotNetPropertyTests.ExplicitInterfaceImplementation.DataFilesTest#DotNetPropertyTests#IInterfaceA#SharedProperty'></member>", LoadOptions.PreserveWhitespace)));
dotNetType.AddMember(DotNetProperty.FromVisualStudioXml(XElement.Parse("<member name='P:DataFilesTest.DotNetPropertyTests.ExplicitInterfaceImplementation.DataFilesTest#DotNetPropertyTests#IInterfaceB#SharedProperty'></member>", LoadOptions.PreserveWhitespace)));
dotNetType.AddMember(DotNetMethod.FromVisualStudioXml(XElement.Parse("<member name='M:DataFilesTest.DotNetPropertyTests.ExplicitInterfaceImplementation.DataFilesTest#DotNetPropertyTests#IInterfaceA#SharedMethod(System.Int32)'></member>", LoadOptions.PreserveWhitespace)));
dotNetType.AddMember(DotNetMethod.FromVisualStudioXml(XElement.Parse("<member name='M:DataFilesTest.DotNetPropertyTests.ExplicitInterfaceImplementation.DataFilesTest#DotNetPropertyTests#IInterfaceB#SharedMethod(System.Int32)'></member>", LoadOptions.PreserveWhitespace)));
//act
dotNetType.AddAssemblyInfo(type, dotNetType.Name);
//assert
Assert.AreEqual(2, dotNetType.Properties.Count);
Assert.AreEqual("DataFilesTest.DotNetPropertyTests.IInterfaceA", dotNetType.Properties[0].Name.ExplicitInterface);
Assert.AreEqual("DataFilesTest.DotNetPropertyTests.IInterfaceB", dotNetType.Properties[1].Name.ExplicitInterface);
Assert.AreEqual("System.Int32", dotNetType.Properties[0].TypeName);
Assert.AreEqual("System.Int32", dotNetType.Properties[1].TypeName);
Assert.AreEqual(2, dotNetType.Methods.Count);
Assert.AreEqual("DataFilesTest.DotNetPropertyTests.IInterfaceA", dotNetType.Methods[0].Name.ExplicitInterface);
Assert.AreEqual("DataFilesTest.DotNetPropertyTests.IInterfaceB", dotNetType.Methods[1].Name.ExplicitInterface);
Assert.AreEqual("System.Int32", dotNetType.Methods[0].MethodName.ReturnTypeName);
Assert.AreEqual("System.Int32", dotNetType.Methods[1].MethodName.ReturnTypeName);
}
private static void TestRxObject(MethodArgStack[] Stack, ref MethodArgStack returnValue, DotNetMethod method)
{
var cctor = m.GetMethod("DotNetparserTester", "TestObject", ".ctor");
if (cctor == null)
{
throw new NullReferenceException();
}
var s = new CustomList <MethodArgStack>();
s.Add(MethodArgStack.String("value"));
returnValue = clr.CreateObject(cctor, s);
}
private void Array_GetLowerBound(MethodArgStack[] Stack, ref MethodArgStack returnValue, DotNetMethod method)
{
var array = Stack[0];
var bound = Stack[1];
if (array.type != StackItemType.Array)
{
throw new Exception();
}
//todo
returnValue = MethodArgStack.Int32(0);
}
private static void TestsComplete(MethodArgStack[] Stack, ref MethodArgStack returnValue, DotNetMethod method)
{
if (NumbOfFailedTests == 0)
{
PrintWithColor("All tests are complete. Successed tests: " + NumbOfSuccesssTests + ", failed Tests: " + NumbOfFailedTests, ConsoleColor.Green);
}
else
{
PrintWithColor("All tests are complete. Successed tests: " + NumbOfSuccesssTests + ", failed Tests: " + NumbOfFailedTests, ConsoleColor.Red);
}
}
public void RegisterFunction(string s)
{
MethodInfo mi = GetType().GetMethod(s);
DotNetMethod m = new DotNetMethod(mi, DotNetObject.Marshal(this));
vm.AddVar(s, m);
}
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);
}
private void DebuggerBreak(MethodArgStack[] Stack, ref MethodArgStack returnValue, DotNetMethod method)
{
Debugger.Break();
}
private static void TestSuccess(MethodArgStack[] Stack, ref MethodArgStack returnValue, DotNetMethod method)
{
var testName = (string)Stack[Stack.Length - 1].value;
PrintWithColor("Test Success: " + testName, ConsoleColor.Green);
NumbOfSuccesssTests++;
}
private static void TestsComplete(MethodArgStack[] Stack, ref MethodArgStack returnValue, DotNetMethod method)
{
Console.WriteLine();
PrintWithColor("All Tests Completed.", ConsoleColor.DarkYellow);
Console.WriteLine();
PrintWithColor("Passed tests: " + NumbOfSuccesssTests, ConsoleColor.Green);
PrintWithColor("Failed tests: " + NumbOfFailedTests, ConsoleColor.Red);
}
private static void TestFail(MethodArgStack[] Stack, ref MethodArgStack returnValue, DotNetMethod method)
{
var testName = (string)Stack[Stack.Length - 1].value;
PrintWithColor("Test Failure: " + testName, ConsoleColor.Red);
NumbOfFailedTests++;
}
