public void VBNetCustomEventsStatementTest()
{
string code = @" Public Custom Event TestEvent As EventHandler
AddHandler(ByVal value As EventHandler)
Handlers = CType([Delegate].Combine(Handlers, value), _
EventHandler)
End AddHandler
RemoveHandler(ByVal value as EventHandler)
Handlers = CType([Delegate].Remove(Handlers, value), _
EventHandler)
End RemoveHandler
RaiseEvent(ByVal sender As Object, ByVal e As EventArgs)
Dim TempHandlers As EventHandler = Handlers
If TempHandlers IsNot Nothing Then
TempHandlers(sender, e)
End If
End RaiseEvent
End Event";
EventDeclaration customEventDecl = ParseUtil.ParseTypeMember <EventDeclaration>(code);
Assert.IsNotNull(customEventDecl);
Assert.AreEqual("TestEvent", customEventDecl.Name);
}
public void VBNetConstructorDeclarationTest1()
{
string program = @"Sub New()
End Sub" ;
ConstructorDeclaration cd = ParseUtil.ParseTypeMember <ConstructorDeclaration>(program);
Assert.IsTrue(cd.ConstructorInitializer.IsNull);
}
public void VBNetSimpleGetSetPropertyDeclarationTest()
{
PropertyDeclaration pd = ParseUtil.ParseTypeMember <PropertyDeclaration>("Property MyProperty As Integer \n Get \n End Get \n Set \n End Set\nEnd Property");
Assert.AreEqual("MyProperty", pd.Name);
Assert.IsTrue(pd.HasGetRegion);
Assert.IsTrue(pd.HasSetRegion);
}
public void VBNetConstructorDeclarationTest2()
{
ConstructorDeclaration cd = ParseUtil.ParseTypeMember <ConstructorDeclaration>("Sub New(x As Integer, Optional y As String) \nEnd Sub");
Assert.AreEqual(2, cd.Parameters.Count);
Assert.AreEqual("System.Int32", cd.Parameters[0].TypeReference.Type);
Assert.AreEqual("System.String", cd.Parameters[1].TypeReference.Type);
Assert.AreEqual(ParameterModifiers.Optional, cd.Parameters[1].ParamModifier & ParameterModifiers.Optional);
}
public void VBNetLabelStatementTest()
{
MethodDeclaration method = ParseUtil.ParseTypeMember <MethodDeclaration>("Sub Test \n myLabel: Console.WriteLine() \n End Sub");
Assert.AreEqual(2, method.Body.Children.Count);
LabelStatement labelStmt = (LabelStatement)method.Body.Children[0];
Assert.AreEqual("myLabel", labelStmt.Label);
}
public void VBNetSimpleInitializerAutoPropertyTest()
{
PropertyDeclaration pd = ParseUtil.ParseTypeMember <PropertyDeclaration>("Property MyProperty = 5");
Assert.AreEqual("MyProperty", pd.Name);
Assert.IsTrue(pd.HasGetRegion);
Assert.IsTrue(pd.HasSetRegion);
Assert.AreEqual(pd.Initializer.ToString(), new PrimitiveExpression(5).ToString());
}
public void VBNetWriteOnlyAutoPropertyTest()
{
PropertyDeclaration pd = ParseUtil.ParseTypeMember <PropertyDeclaration>("WriteOnly Property MyProperty");
Assert.AreEqual("MyProperty", pd.Name);
Assert.IsFalse(pd.HasGetRegion);
Assert.IsTrue(pd.HasSetRegion);
Assert.AreEqual(pd.Initializer, Expression.Null);
}
public void VBNetSimpleSetPropertyDeclarationTest()
{
PropertyDeclaration pd = ParseUtil.ParseTypeMember <PropertyDeclaration>("WriteOnly Property MyProperty \n Set\nEnd Set\nEnd Property ");
Assert.AreEqual("MyProperty", pd.Name);
Assert.IsFalse(pd.HasGetRegion);
Assert.IsTrue(pd.HasSetRegion);
Assert.IsTrue((pd.Modifier & Modifiers.WriteOnly) == Modifiers.WriteOnly);
}
public void VBNetSimpleEventDeclarationTest()
{
EventDeclaration ed = ParseUtil.ParseTypeMember <EventDeclaration>("event MyEvent(x as Integer)");
Assert.AreEqual(1, ed.Parameters.Count);
Assert.AreEqual("MyEvent", ed.Name);
Assert.IsFalse(ed.HasAddRegion);
Assert.IsFalse(ed.HasRemoveRegion);
}
public void VBNetDefiningPartialMethodDeclarationTest()
{
MethodDeclaration md = ParseUtil.ParseTypeMember <MethodDeclaration>(@"Partial Sub MyMethod()
End Sub" );
Assert.AreEqual(0, md.Parameters.Count);
Assert.AreEqual("MyMethod", md.Name);
Assert.IsFalse(md.IsExtensionMethod);
Assert.AreEqual(Modifiers.Partial, md.Modifier);
}
public void VBNetMethodWithTypeCharactersTest()
{
const string program = @"Public Function Func!(ByVal Param&)
Func! = CSingle(Param&)
End Function" ;
MethodDeclaration md = ParseUtil.ParseTypeMember <MethodDeclaration>(program);
Assert.AreEqual(Modifiers.Public, md.Modifier);
}
public void VBNetSimpleObjectInitializerAutoPropertyTest()
{
PropertyDeclaration pd = ParseUtil.ParseTypeMember <PropertyDeclaration>("Property MyProperty As New List");
Assert.AreEqual("MyProperty", pd.Name);
Assert.AreEqual("List", pd.TypeReference.Type);
Assert.IsTrue(pd.HasGetRegion);
Assert.IsTrue(pd.HasSetRegion);
Assert.AreEqual(pd.Initializer.ToString(), new ObjectCreateExpression(new TypeReference("List"), null).ToString());
}
public void VBNetMultiFieldDeclarationTest3()
{
FieldDeclaration fd = ParseUtil.ParseTypeMember <FieldDeclaration>("Dim a(), b As String");
Assert.AreEqual(2, fd.Fields.Count);
Assert.AreEqual("System.String", ((VariableDeclaration)fd.Fields[0]).TypeReference.Type);
Assert.AreEqual("System.String", ((VariableDeclaration)fd.Fields[1]).TypeReference.Type);
Assert.IsTrue(((VariableDeclaration)fd.Fields[0]).TypeReference.IsArrayType);
Assert.IsFalse(((VariableDeclaration)fd.Fields[1]).TypeReference.IsArrayType);
}
public void VBNetSimpleFieldDeclarationTest()
{
FieldDeclaration fd = ParseUtil.ParseTypeMember <FieldDeclaration>("myField As Integer(,,,)");
Assert.AreEqual(1, fd.Fields.Count);
Assert.AreEqual("System.Int32", ((VariableDeclaration)fd.Fields[0]).TypeReference.Type);
Assert.AreEqual("System.Int32", ((VariableDeclaration)fd.Fields[0]).TypeReference.Type);
Assert.AreEqual("myField", ((VariableDeclaration)fd.Fields[0]).Name);
Assert.AreEqual(new int[] { 3 }, ((VariableDeclaration)fd.Fields[0]).TypeReference.RankSpecifier);
}
public void VBNetDeclareDeclarationTest()
{
string program = "Declare Ansi Function GetUserName Lib \"advapi32.dll\" Alias \"GetUserNameA\" (ByVal lpBuffer As String, ByRef nSize As Integer) As Integer\n";
DeclareDeclaration dd = ParseUtil.ParseTypeMember <DeclareDeclaration>(program);
Assert.AreEqual("System.Int32", dd.TypeReference.Type);
Assert.AreEqual("GetUserName", dd.Name);
Assert.AreEqual("advapi32.dll", dd.Library);
Assert.AreEqual("GetUserNameA", dd.Alias);
Assert.AreEqual(CharsetModifier.Ansi, dd.Charset);
}
public void VBNetGenericMethodDeclarationTest()
{
MethodDeclaration md = ParseUtil.ParseTypeMember <MethodDeclaration>("Function MyMethod(Of T)(a As T) As T\nEnd Function ");
Assert.AreEqual("T", 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);
}
public void VBNetFunctionMethodDeclarationTest()
{
const string program = @"public function MyFunction() as Integer
return 1
end function" ;
MethodDeclaration md = ParseUtil.ParseTypeMember <MethodDeclaration>(program);
Assert.AreEqual(Modifiers.Public, md.Modifier);
Assert.AreEqual(2, md.StartLocation.Line, "StartLocation.Y");
Assert.AreEqual(2, md.StartLocation.Column, "StartLocation.X");
Assert.AreEqual(2, md.EndLocation.Line, "EndLocation.Y");
}
public void VBNetSubroutineMethodDeclarationTest()
{
const string program = @"public Sub MyMethod()
OtherMethod()
end Sub" ;
MethodDeclaration md = ParseUtil.ParseTypeMember <MethodDeclaration>(program);
Assert.AreEqual(Modifiers.Public, md.Modifier);
Assert.AreEqual(2, md.StartLocation.Line, "StartLocation.Y");
Assert.AreEqual(2, md.StartLocation.Column, "StartLocation.X");
Assert.AreEqual(2, md.EndLocation.Line, "EndLocation.Y");
}
public void VBNetImplictOperatorDeclarationTest()
{
string programm = @"Public Shared Operator + (ByVal v As Complex) As Complex
Return v
End Operator" ;
OperatorDeclaration od = ParseUtil.ParseTypeMember <OperatorDeclaration>(programm);
Assert.IsFalse(od.IsConversionOperator);
Assert.AreEqual(1, od.Parameters.Count);
Assert.AreEqual(ConversionType.None, od.ConversionType);
Assert.AreEqual("Complex", od.TypeReference.Type);
}
public void VBNetGenericMethodDeclarationWithConstraintTest()
{
string program = "Function MyMethod(Of T As { ISomeInterface })(a As T) As T\n End Function";
MethodDeclaration md = ParseUtil.ParseTypeMember <MethodDeclaration>(program);
Assert.AreEqual("T", 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 VBNetExtensionMethodDeclaration()
{
MethodDeclaration md = ParseUtil.ParseTypeMember <MethodDeclaration>(
@"<Extension> _
Sub Print(s As String)
Console.WriteLine(s)
End Sub" );
Assert.AreEqual("Print", md.Name);
// IsExtensionMethod is only valid for c#.
// Assert.IsTrue(md.IsExtensionMethod);
Assert.AreEqual("s", md.Parameters[0].ParameterName);
Assert.AreEqual("System.String", md.Parameters[0].TypeReference.Type);
}
public void VBNetMethodWithHandlesClause()
{
MethodDeclaration md = ParseUtil.ParseTypeMember <MethodDeclaration>(
@"Public Sub MyMethod(sender As Object, e As EventArgs) Handles x.y
End Sub" );
Assert.AreEqual(new string[] { "x.y" }, md.HandlesClause.ToArray());
md = ParseUtil.ParseTypeMember <MethodDeclaration>(
@"Public Sub MyMethod() Handles Me.FormClosing
End Sub" );
Assert.AreEqual(new string[] { "Me.FormClosing" }, md.HandlesClause.ToArray());
md = ParseUtil.ParseTypeMember <MethodDeclaration>(
@"Public Sub MyMethod() Handles MyBase.Event, Button1.Click
End Sub" );
Assert.AreEqual(new string[] { "MyBase.Event", "Button1.Click" }, md.HandlesClause.ToArray());
}
