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