public void CSharpDelegateWithoutNameDeclarationTest()
{
string program = "public delegate void(int a, int secondParam, MyObj lastParam);\n";
DelegateDeclaration dd = ParseUtilCSharp.ParseGlobal <DelegateDeclaration>(program, true);
Assert.AreEqual("System.Void", dd.ReturnType.SystemType);
Assert.AreEqual("?", dd.Name);
TestParameters(dd);
}
public void CSharpSimpleStaticClassTypeDeclarationTest()
{
TypeDeclaration td = ParseUtilCSharp.ParseGlobal <TypeDeclaration>("static class MyClass { }");
Assert.IsNotNull(td);
Assert.AreEqual(ClassType.Class, td.Type);
Assert.AreEqual("MyClass", td.Name);
Assert.AreEqual(Modifier.Static, td.Modifier);
}
public void CSharpSimpleClassTypeDeclarationTest()
{
TypeDeclaration td = ParseUtilCSharp.ParseGlobal <TypeDeclaration>("class MyClass : My.Base.Class { }");
Assert.AreEqual(ClassType.Class, td.Type);
Assert.AreEqual("MyClass", td.Name);
Assert.AreEqual("My.Base.Class", td.BaseTypes[0].Type);
Assert.AreEqual(Modifier.None, td.Modifier);
}
public void GlobalAttributeCSharp()
{
string program = @"[global::Microsoft.VisualBasic.CompilerServices.DesignerGenerated()]
[someprefix::DesignerGenerated()]
public class Form1 {
}";
TypeDeclaration decl = ParseUtilCSharp.ParseGlobal <TypeDeclaration>(program);
Assert.AreEqual("Microsoft.VisualBasic.CompilerServices.DesignerGenerated", decl.Attributes[0].Attributes[0].Name);
Assert.AreEqual("someprefix.DesignerGenerated", decl.Attributes[1].Attributes[0].Name);
}
public void CSharpGenericClassTypeDeclarationTest()
{
TypeDeclaration td = ParseUtilCSharp.ParseGlobal <TypeDeclaration>("public class G<T> {}");
Assert.AreEqual(ClassType.Class, td.Type);
Assert.AreEqual("G", td.Name);
Assert.AreEqual(Modifier.Public, td.Modifier);
Assert.AreEqual(0, td.BaseTypes.Count);
Assert.AreEqual(1, td.Templates.Count);
Assert.AreEqual("T", td.Templates[0].Name);
}
public void CSharpGenericDelegateDeclarationTest()
{
string program = "public delegate T CreateObject<T>(int a, int secondParam, MyObj lastParam) where T : ICloneable;\n";
DelegateDeclaration dd = ParseUtilCSharp.ParseGlobal <DelegateDeclaration>(program);
Assert.AreEqual("CreateObject", dd.Name);
Assert.AreEqual("T", dd.ReturnType.Type);
TestParameters(dd);
Assert.AreEqual(1, dd.Templates.Count);
Assert.AreEqual("T", dd.Templates[0].Name);
Assert.AreEqual(1, dd.Templates[0].Bases.Count);
Assert.AreEqual("ICloneable", dd.Templates[0].Bases[0].Type);
}
public void EmptyMethods()
{
string txt = @"internal sealed class Lexer : AbstractLexer
{
public Lexer(TextReader reader) : base(reader)
{
}
void Method()
{
}
}" ;
Check(ParseUtilCSharp.ParseGlobal <TypeDeclaration>(txt, false, true));
}
public void CSharpJuggedNamespaceTest()
{
string program = "namespace N1 {//TestNamespace\n" +
" namespace N2 {// Declares a namespace named N2 within N1.\n" +
" }\n" +
"}\n";
NamespaceDeclaration ns = ParseUtilCSharp.ParseGlobal <NamespaceDeclaration>(program);
Assert.AreEqual("N1", ns.Name);
Assert.IsTrue(ns.Children[0] is NamespaceDeclaration);
ns = (NamespaceDeclaration)ns.Children[0];
Assert.AreEqual("N2", ns.Name);
}
public void CSharpGenericClassWithWhere()
{
string declr = @"
public class Test<T> where T : IMyInterface
{
}
";
TypeDeclaration td = ParseUtilCSharp.ParseGlobal <TypeDeclaration>(declr);
Assert.AreEqual(ClassType.Class, td.Type);
Assert.AreEqual("Test", td.Name);
Assert.AreEqual(1, td.Templates.Count);
Assert.AreEqual("T", td.Templates[0].Name);
Assert.AreEqual("IMyInterface", td.Templates[0].Bases[0].Type);
}
public void CSharpComplexClassTypeDeclarationTest()
{
string declr = @"
[MyAttr()]
public abstract class MyClass : MyBase, Interface1, My.Test.Interface2
{
}
";
TypeDeclaration td = ParseUtilCSharp.ParseGlobal <TypeDeclaration>(declr);
Assert.AreEqual(ClassType.Class, td.Type);
Assert.AreEqual("MyClass", td.Name);
Assert.AreEqual(Modifier.Public | Modifier.Abstract, td.Modifier);
Assert.AreEqual(1, td.Attributes.Count);
Assert.AreEqual(3, td.BaseTypes.Count);
Assert.AreEqual("MyBase", td.BaseTypes[0].Type);
Assert.AreEqual("Interface1", td.BaseTypes[1].Type);
Assert.AreEqual("My.Test.Interface2", td.BaseTypes[2].Type);
}
public void CSharpGenericVoidMethodInInterface()
{
const string program = @"interface MyInterface {
void MyMethod<T>(T a) where T : ISomeInterface;
}
";
TypeDeclaration td = ParseUtilCSharp.ParseGlobal <TypeDeclaration>(program);
MethodDeclaration md = (MethodDeclaration)td.Children[0];
Assert.AreEqual("void", md.TypeReference.Type);
Assert.AreEqual(1, md.Parameters.Count);
Assert.AreEqual("T", ((ParameterDeclarationExpression)md.Parameters[0]).TypeReference.Type);
Assert.AreEqual("a", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName);
Assert.AreEqual(1, md.Templates.Count);
Assert.AreEqual("T", md.Templates[0].Name);
Assert.AreEqual(1, md.Templates[0].Bases.Count);
Assert.AreEqual("ISomeInterface", md.Templates[0].Bases[0].Type);
}
public void NonEmptyMethods()
{
string txt = @"internal sealed class Lexer : AbstractLexer
{
public Lexer(TextReader reader) : base(reader)
{
if (reader == null) {
throw new ArgumentNullException(""reader"");
}
}
void Method()
{
while(something) {
if (anything)
break;
}
}
}" ;
Check(ParseUtilCSharp.ParseGlobal <TypeDeclaration>(txt, false, true));
}
public void SimpleCSharpDelegateDeclarationTest()
{
string program = "public delegate void MyDelegate(int a, int secondParam, MyObj lastParam);\n";
TestDelegateDeclaration(ParseUtilCSharp.ParseGlobal <DelegateDeclaration>(program));
}