unit tests for vb.net type level declarations

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@281 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/Libraries/NRefactory/Project/Src/Lexer/VBNet/Lexer.cs

@@ -165,7 +165,6 @@ namespace ICSharpCode.NRefactory.Parser.VB
 					string s = ReadIdent(ch);
 					int keyWordToken = Keywords.GetToken(s);
 					if (keyWordToken >= 0) {
-						System.Console.WriteLine("token: {0} X: {1} Y: {2}", keyWordToken.ToString(), x, y);
 						lineEnd = false;
 						return new Token(keyWordToken, x, y, s);
 					}

src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG

@@ -2925,7 +2925,6 @@ PrimitiveTypeName<out string type>
 	| "ULong"		(. type = "ULong"; .)
 	| "UShort"		(. type = "UShort"; .)
 	| "SByte"		(. type = "SByte"; .)
-	
 	.
 
 ParameterModifier<ParamModifiers m>

src/Libraries/NRefactory/Test/Parser/ParseUtilVBNet.cs

@@ -30,6 +30,7 @@ namespace ICSharpCode.NRefactory.Tests.AST
 		
 		public static object ParseTypeMember(string typeMember, Type type)
 		{
+			System.Console.WriteLine("Class TestClass\n " + typeMember + "\n End Class\n");
 			TypeDeclaration td = (TypeDeclaration)ParseGlobal("Class TestClass\n " + typeMember + "\n End Class\n", typeof(TypeDeclaration));
 			Assert.IsTrue(td.Children.Count > 0);
 			Assert.IsTrue(type.IsAssignableFrom(td.Children[0].GetType()), String.Format("Parsed expression was {0} instead of {1} ({2})", td.GetType(), type, td));

src/Libraries/NRefactory/Test/Parser/TypeLevel/ConstructorDeclarationTests.cs

@@ -45,7 +45,24 @@ namespace ICSharpCode.NRefactory.Tests.AST
 		#endregion
 		
 		#region VB.NET
-			// TODO
+		[Test]
+		public void VBNetConstructorDeclarationTest1()
+		{
+			string program = @"Sub New()
+								End Sub";
+			ConstructorDeclaration cd = (ConstructorDeclaration)ParseUtilVBNet.ParseTypeMember(program, typeof(ConstructorDeclaration));
+			Assert.IsTrue(cd.ConstructorInitializer.IsNull);
+		}
+		
+		[Test]
+		public void VBNetConstructorDeclarationTest2()
+		{
+			ConstructorDeclaration cd = (ConstructorDeclaration)ParseUtilVBNet.ParseTypeMember("Sub New(x As Integer, Optional y As String) \nEnd Sub", typeof(ConstructorDeclaration));
+			Assert.AreEqual(2, cd.Parameters.Count);
+			Assert.AreEqual("Integer", cd.Parameters[0].TypeReference.Type);
+			Assert.AreEqual("String", cd.Parameters[1].TypeReference.Type);
+			Assert.AreEqual(ParamModifier.Optional, cd.Parameters[1].ParamModifier & ParamModifier.Optional);
+		}
 		#endregion 
 	}
 }

src/Libraries/NRefactory/Test/Parser/TypeLevel/EventDeclarationTests.cs

@@ -45,7 +45,16 @@ namespace ICSharpCode.NRefactory.Tests.AST
 		#endregion
 		
 		#region VB.NET
-			// TODO
+		[Test]
+		public void VBNetSimpleEventDeclarationTest()
+		{
+			EventDeclaration ed = (EventDeclaration)ParseUtilVBNet.ParseTypeMember("event MyEvent(x as Integer)", typeof(EventDeclaration));
+			Assert.AreEqual(1, ed.Parameters.Count);
+			Assert.AreEqual("MyEvent", ed.Name);
+			Assert.AreEqual("System.EventHandler", ed.TypeReference.Type);
+			Assert.IsFalse(ed.HasAddRegion);
+			Assert.IsFalse(ed.HasRemoveRegion);
+		}
 		#endregion 
 	}
 }

src/Libraries/NRefactory/Test/Parser/TypeLevel/IndexerDeclarationTests.cs

@@ -31,7 +31,7 @@ namespace ICSharpCode.NRefactory.Tests.AST
 		#endregion
 		
 		#region VB.NET
-			// TODO
+		// no vb.net representation (indexers are properties named "item" in vb.net)		
 		#endregion 
 	}
 }

src/Libraries/NRefactory/Test/Parser/TypeLevel/MethodDeclarationTests.cs

@@ -154,7 +154,127 @@ namespace ICSharpCode.NRefactory.Tests.AST
 		#endregion
 		
 		#region VB.NET
-		// TODO
+		
+		[Test]
+		public void VBNetSimpleMethodDeclarationTest()
+		{
+			MethodDeclaration md = (MethodDeclaration)ParseUtilCSharp.ParseTypeMember("void MyMethod() {} ", typeof(MethodDeclaration));
+			Assert.AreEqual("void", md.TypeReference.Type);
+			Assert.AreEqual(0, md.Parameters.Count);
+		}
+		
+		[Test]
+		public void VBNetSimpleMethodRegionTest()
+		{
+			const string program = @"
+		void MyMethod()
+		{
+			OtherMethod();
+		}
+";
+			MethodDeclaration md = (MethodDeclaration)ParseUtilCSharp.ParseTypeMember(program, typeof(MethodDeclaration));
+			Assert.AreEqual(2, md.StartLocation.Y, "StartLocation.Y");
+			Assert.AreEqual(2, md.EndLocation.Y, "EndLocation.Y");
+			Assert.AreEqual(3, md.StartLocation.X, "StartLocation.X");
+			
+			// endLocation.X is currently 20. It should be 18, but that error is not critical
+			//Assert.AreEqual(18, md.EndLocation.X, "EndLocation.X");
+		}
+		
+		[Test]
+		public void VBNetMethodWithModifiersRegionTest()
+		{
+			const string program = @"public shared sub MyMethod()
+				OtherMethod()
+			end sub";
+			
+			MethodDeclaration md = (MethodDeclaration)ParseUtilVBNet.ParseTypeMember(program, typeof(MethodDeclaration));
+			Assert.AreEqual(2, md.StartLocation.Y, "StartLocation.Y");
+			Assert.AreEqual(2, md.EndLocation.Y, "EndLocation.Y");
+			Assert.AreEqual(2, md.StartLocation.X, "StartLocation.X");
+		}
+		
+		[Test]
+		public void VBNetGenericFunctionMethodDeclarationTest()
+		{
+			MethodDeclaration md = (MethodDeclaration)ParseUtilVBNet.ParseTypeMember("function MyMethod(Of T)(a As T) As Double\nEnd Function", typeof(MethodDeclaration));
+			Assert.AreEqual("Double", 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);
+		}
+		
+		[Test]
+		public void VBNetGenericMethodDeclarationTest()
+		{
+			MethodDeclaration md = (MethodDeclaration)ParseUtilVBNet.ParseTypeMember("Function MyMethod(Of T)(a As T) As T\nEnd Function ", typeof(MethodDeclaration));
+			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);
+		}
+		
+		[Test]
+		public void VBNetGenericMethodDeclarationWithConstraintTest()
+		{
+			string program = "Function MyMethod(Of T As { ISomeInterface })(a As T) As T\n End Function";
+			MethodDeclaration md = (MethodDeclaration)ParseUtilVBNet.ParseTypeMember(program, typeof(MethodDeclaration));
+			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);
+		}
+		
+		[Test]
+		public void VBNetGenericMethodInInterface()
+		{
+			const string program = @"Interface MyInterface
+	Function MyMethod(Of T As {ISomeInterface})(a As T) As T
+	End Interface";
+			TypeDeclaration td = (TypeDeclaration)ParseUtilVBNet.ParseGlobal(program, typeof(TypeDeclaration));
+			MethodDeclaration md = (MethodDeclaration)td.Children[0];
+			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);
+		}
+		
+		[Test]
+		public void VBNetGenericVoidMethodInInterface()
+		{
+			const string program = @"interface MyInterface
+	Sub MyMethod(Of T As {ISomeInterface})(a as T)
+End Interface
+";
+			TypeDeclaration td = (TypeDeclaration)ParseUtilVBNet.ParseGlobal(program, typeof(TypeDeclaration));
+			MethodDeclaration md = (MethodDeclaration)td.Children[0];
+			Assert.AreEqual("", 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);
+		}
+		
 		#endregion
 	}
 }

src/Libraries/NRefactory/Test/Parser/TypeLevel/PropertyDeclarationTests.cs

@@ -49,7 +49,32 @@ namespace ICSharpCode.NRefactory.Tests.AST
 		#endregion
 		
 		#region VB.NET
-			// TODO
+		[Test]
+		public void VBNetSimpleGetSetPropertyDeclarationTest()
+		{
+			PropertyDeclaration pd = (PropertyDeclaration)ParseUtilVBNet.ParseTypeMember("Property MyProperty As Integer \n Get \n End Get \n Set \n End Set\nEnd Property", typeof(PropertyDeclaration));
+			Assert.AreEqual("MyProperty", pd.Name);
+			Assert.IsTrue(pd.HasGetRegion);
+			Assert.IsTrue(pd.HasSetRegion);
+		}
+		
+		[Test]
+		public void VBNetSimpleGetPropertyDeclarationTest()
+		{
+			PropertyDeclaration pd = (PropertyDeclaration)ParseUtilVBNet.ParseTypeMember("Property MyProperty \nGet\nEnd Get\nEnd Property", typeof(PropertyDeclaration));
+			Assert.AreEqual("MyProperty", pd.Name);
+			Assert.IsTrue(pd.HasGetRegion);
+			Assert.IsFalse(pd.HasSetRegion);
+		}
+		
+		[Test]
+		public void VBNetSimpleSetPropertyDeclarationTest()
+		{
+			PropertyDeclaration pd = (PropertyDeclaration)ParseUtilVBNet.ParseTypeMember("Property MyProperty \n Set\nEnd Set\nEnd Property ", typeof(PropertyDeclaration));
+			Assert.AreEqual("MyProperty", pd.Name);
+			Assert.IsFalse(pd.HasGetRegion);
+			Assert.IsTrue(pd.HasSetRegion);
+		}
 		#endregion 
 	}
 }