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.Type);
//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(Modifiers.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(Modifiers.None, td.Modifier);
}
public void TypeAttributeCSharp()
{
string program = @"[type: System.Attribute()] class Test {}";
TypeDeclaration type = ParseUtilCSharp.ParseGlobal <TypeDeclaration>(program);
AttributeSection decl = type.Attributes[0];
Assert.AreEqual(new Location(1, 1), decl.StartLocation);
Assert.AreEqual("type", decl.AttributeTarget);
}
public void CSharpSimpleClassRegionTest()
{
const string program = "class MyClass\n{\n}\n";
TypeDeclaration td = ParseUtilCSharp.ParseGlobal <TypeDeclaration>(program);
Assert.AreEqual(1, td.StartLocation.Y, "StartLocation.Y");
Assert.AreEqual(1, td.StartLocation.X, "StartLocation.X");
Assert.AreEqual(1, td.BodyStartLocation.Y, "BodyStartLocation.Y");
Assert.AreEqual(14, td.BodyStartLocation.X, "BodyStartLocation.X");
Assert.AreEqual(3, td.EndLocation.Y, "EndLocation.Y");
}
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(Modifiers.Public, td.Modifier);
Assert.AreEqual(0, td.BaseTypes.Count);
Assert.AreEqual(1, td.Templates.Count);
Assert.AreEqual("T", td.Templates[0].Name);
}
public void CSharpNestedClassesTest()
{
TypeDeclaration td = ParseUtilCSharp.ParseGlobal <TypeDeclaration>("class MyClass { partial class P1 {} public partial class P2 {} static class P3 {} internal static class P4 {} }");
Assert.IsNotNull(td);
Assert.AreEqual(ClassType.Class, td.Type);
Assert.AreEqual("MyClass", td.Name);
Assert.AreEqual(Modifiers.Partial, ((TypeDeclaration)td.Children[0]).Modifier);
Assert.AreEqual(Modifiers.Partial | Modifiers.Public, ((TypeDeclaration)td.Children[1]).Modifier);
Assert.AreEqual(Modifiers.Static, ((TypeDeclaration)td.Children[2]).Modifier);
Assert.AreEqual(Modifiers.Static | Modifiers.Internal, ((TypeDeclaration)td.Children[3]).Modifier);
}
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 CSharpShadowingMethodInInterface()
{
const string program = @"interface MyInterface : IDisposable {
new void Dispose();
}
";
TypeDeclaration td = ParseUtilCSharp.ParseGlobal <TypeDeclaration>(program);
MethodDeclaration md = (MethodDeclaration)td.Children[0];
Assert.AreEqual("System.Void", md.TypeReference.Type);
Assert.AreEqual(0, md.Parameters.Count);
Assert.AreEqual(Modifiers.New, md.Modifier);
}
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 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 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 CSharpMultipleEventDeclarationTest()
{
TypeDeclaration t = ParseUtilCSharp.ParseGlobal <TypeDeclaration>("class C { public event EventHandler A, B; }");
Assert.AreEqual(2, t.Children.Count);
EventDeclaration ed = (EventDeclaration)t.Children[0];
Assert.AreEqual(Modifiers.Public, ed.Modifier);
Assert.AreEqual("EventHandler", ed.TypeReference.Type);
Assert.AreEqual("A", ed.Name);
ed = (EventDeclaration)t.Children[1];
Assert.AreEqual(Modifiers.Public, ed.Modifier);
Assert.AreEqual("EventHandler", ed.TypeReference.Type);
Assert.AreEqual("B", ed.Name);
}
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("System.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 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(Modifiers.Public | Modifiers.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 AssemblyAttributeCSharpWithNamedArguments()
{
string program = @"[assembly: Foo(1, namedArg: 2, prop = 3)]";
AttributeSection decl = ParseUtilCSharp.ParseGlobal <AttributeSection>(program);
Assert.AreEqual("assembly", decl.AttributeTarget);
var a = decl.Attributes[0];
Assert.AreEqual("Foo", a.Name);
Assert.AreEqual(2, a.PositionalArguments.Count);
Assert.AreEqual(1, a.NamedArguments.Count);
Assert.AreEqual(1, ((PrimitiveExpression)a.PositionalArguments[0]).Value);
NamedArgumentExpression nae = a.PositionalArguments[1] as NamedArgumentExpression;
Assert.AreEqual("namedArg", nae.Name);
Assert.AreEqual(2, ((PrimitiveExpression)nae.Expression).Value);
nae = a.NamedArguments[0];
Assert.AreEqual("prop", nae.Name);
Assert.AreEqual(3, ((PrimitiveExpression)nae.Expression).Value);
}
public void ContextSensitiveKeywordTest()
{
TypeDeclaration td = ParseUtilCSharp.ParseGlobal <TypeDeclaration>("partial class partial<[partial: where] where> where where : partial<where> { }");
Assert.AreEqual(Modifiers.Partial, td.Modifier);
Assert.AreEqual("partial", td.Name);
Assert.AreEqual(1, td.Templates.Count);
TemplateDefinition tp = td.Templates[0];
Assert.AreEqual("where", tp.Name);
Assert.AreEqual(1, tp.Attributes.Count);
Assert.AreEqual("partial", tp.Attributes[0].AttributeTarget);
Assert.AreEqual(1, tp.Attributes[0].Attributes.Count);
Assert.AreEqual("where", tp.Attributes[0].Attributes[0].Name);
Assert.AreEqual(1, tp.Bases.Count);
Assert.AreEqual("partial", tp.Bases[0].Type);
Assert.AreEqual("where", tp.Bases[0].GenericTypes[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));
}