Add TypeMembers unit tests.

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/AliasReferenceExpressionTests.cs

@@ -12,7 +12,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 	public class AliasReferenceExpressionTests
 	{
 		[Test, Ignore]
-		public void CSharpGlobalReferenceExpressionTest()
+		public void GlobalReferenceExpressionTest()
 		{
 			CSharpParser parser = new CSharpParser();
 			parser.ParseTypeReference(new StringReader("global::System"));
@@ -22,7 +22,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test, Ignore]
-		public void CSharpGlobalTypeDeclaration()
+		public void GlobalTypeDeclaration()
 		{
 			VariableDeclarationStatement lvd = ParseUtilCSharp.ParseStatement<VariableDeclarationStatement>("global::System.String a;");
 			//TypeReference typeRef = lvd.GetTypeForVariable(0);

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/ArrayObjectCreateExpressionTests.cs

@@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 	public class ArrayObjectCreateExpressionTests
 	{
 		[Test]
-		public void CSharpArrayCreateExpressionTest1()
+		public void ArrayCreateExpressionTest1()
 		{
 			/*
 			ArrayCreateExpression ace = ParseUtilCSharp.ParseExpression<ArrayCreateExpression>("new int[5]");
@@ -23,7 +23,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpImplicitlyTypedArrayCreateExpression()
+		public void ImplicitlyTypedArrayCreateExpression()
 		{
 			/*
 			ArrayCreateExpression ace = ParseUtilCSharp.ParseExpression<ArrayCreateExpression>("new[] { 1, 10, 100, 1000 }");

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/AssignmentExpressionTests.cs

@@ -9,7 +9,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 	[TestFixture]
 	public class AssignmentExpressionTests
 	{
-		void CSharpTestAssignmentExpression(string program, AssignmentOperatorType op)
+		void TestAssignmentExpression(string program, AssignmentOperatorType op)
 		{
 			AssignmentExpression ae = ParseUtilCSharp.ParseExpression<AssignmentExpression>(program);
 			
@@ -20,69 +20,69 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpAssignTest()
+		public void AssignTest()
 		{
-			CSharpTestAssignmentExpression("a = b", AssignmentOperatorType.Assign);
+			TestAssignmentExpression("a = b", AssignmentOperatorType.Assign);
 		}
 		
 		[Test]
-		public void CSharpAddTest()
+		public void AddTest()
 		{
-			CSharpTestAssignmentExpression("a += b", AssignmentOperatorType.Add);
+			TestAssignmentExpression("a += b", AssignmentOperatorType.Add);
 		}
 		
 		[Test]
-		public void CSharpSubtractTest()
+		public void SubtractTest()
 		{
-			CSharpTestAssignmentExpression("a -= b", AssignmentOperatorType.Subtract);
+			TestAssignmentExpression("a -= b", AssignmentOperatorType.Subtract);
 		}
 		
 		[Test]
-		public void CSharpMultiplyTest()
+		public void MultiplyTest()
 		{
-			CSharpTestAssignmentExpression("a *= b", AssignmentOperatorType.Multiply);
+			TestAssignmentExpression("a *= b", AssignmentOperatorType.Multiply);
 		}
 		
 		[Test]
-		public void CSharpDivideTest()
+		public void DivideTest()
 		{
-			CSharpTestAssignmentExpression("a /= b", AssignmentOperatorType.Divide);
+			TestAssignmentExpression("a /= b", AssignmentOperatorType.Divide);
 		}
 		
 		[Test]
-		public void CSharpModulusTest()
+		public void ModulusTest()
 		{
-			CSharpTestAssignmentExpression("a %= b", AssignmentOperatorType.Modulus);
+			TestAssignmentExpression("a %= b", AssignmentOperatorType.Modulus);
 		}
 		
 		[Test]
-		public void CSharpShiftLeftTest()
+		public void ShiftLeftTest()
 		{
-			CSharpTestAssignmentExpression("a <<= b", AssignmentOperatorType.ShiftLeft);
+			TestAssignmentExpression("a <<= b", AssignmentOperatorType.ShiftLeft);
 		}
 		
 		[Test]
-		public void CSharpShiftRightTest()
+		public void ShiftRightTest()
 		{
-			CSharpTestAssignmentExpression("a >>= b", AssignmentOperatorType.ShiftRight);
+			TestAssignmentExpression("a >>= b", AssignmentOperatorType.ShiftRight);
 		}
 		
 		[Test]
-		public void CSharpBitwiseAndTest()
+		public void BitwiseAndTest()
 		{
-			CSharpTestAssignmentExpression("a &= b", AssignmentOperatorType.BitwiseAnd);
+			TestAssignmentExpression("a &= b", AssignmentOperatorType.BitwiseAnd);
 		}
 		
 		[Test]
-		public void CSharpBitwiseOrTest()
+		public void BitwiseOrTest()
 		{
-			CSharpTestAssignmentExpression("a |= b", AssignmentOperatorType.BitwiseOr);
+			TestAssignmentExpression("a |= b", AssignmentOperatorType.BitwiseOr);
 		}
 		
 		[Test]
-		public void CSharpExclusiveOrTest()
+		public void ExclusiveOrTest()
 		{
-			CSharpTestAssignmentExpression("a ^= b", AssignmentOperatorType.ExclusiveOr);
+			TestAssignmentExpression("a ^= b", AssignmentOperatorType.ExclusiveOr);
 		}
 	}
 }

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/BaseReferenceExpressionTests.cs

@@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 	public class BaseReferenceExpressionTests
 	{
 		[Test]
-		public void CSharpBaseReferenceExpressionTest1()
+		public void BaseReferenceExpressionTest1()
 		{
 			MemberReferenceExpression fre = ParseUtilCSharp.ParseExpression<MemberReferenceExpression>("base.myField");
 			Assert.IsTrue(fre.Target is BaseReferenceExpression);

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/BinaryOperatorExpressionTests.cs

@@ -56,7 +56,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpOperatorPrecedenceTest()
+		public void OperatorPrecedenceTest()
 		{
 			SameOperatorPrecedenceTest("*", BinaryOperatorType.Multiply, "/", BinaryOperatorType.Divide, false);
 			SameOperatorPrecedenceTest("*", BinaryOperatorType.Multiply, "%", BinaryOperatorType.Modulus, false);
@@ -75,7 +75,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		#endregion
 		
-		void CSharpTestBinaryOperatorExpressionTest(string program, BinaryOperatorType op)
+		void TestBinaryOperatorExpressionTest(string program, BinaryOperatorType op)
 		{
 			BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>(program);
 			Assert.AreEqual(op, boe.BinaryOperatorType);
@@ -86,7 +86,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpSubtractionLeftToRight()
+		public void SubtractionLeftToRight()
 		{
 			BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>("a - b - c");
 			Assert.IsTrue(boe.Right is IdentifierExpression);
@@ -94,7 +94,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpNullCoalescingRightToLeft()
+		public void NullCoalescingRightToLeft()
 		{
 			BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>("a ?? b ?? c");
 			Assert.IsTrue(boe.Left is IdentifierExpression);
@@ -102,122 +102,122 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpBitwiseAndTest()
+		public void BitwiseAndTest()
 		{
-			CSharpTestBinaryOperatorExpressionTest("a & b", BinaryOperatorType.BitwiseAnd);
+			TestBinaryOperatorExpressionTest("a & b", BinaryOperatorType.BitwiseAnd);
 		}
 		
 		[Test]
-		public void CSharpBitwiseOrTest()
+		public void BitwiseOrTest()
 		{
-			CSharpTestBinaryOperatorExpressionTest("a | b", BinaryOperatorType.BitwiseOr);
+			TestBinaryOperatorExpressionTest("a | b", BinaryOperatorType.BitwiseOr);
 		}
 		
 		[Test]
-		public void CSharpLogicalAndTest()
+		public void LogicalAndTest()
 		{
-			CSharpTestBinaryOperatorExpressionTest("a && b", BinaryOperatorType.LogicalAnd);
+			TestBinaryOperatorExpressionTest("a && b", BinaryOperatorType.LogicalAnd);
 		}
 		
 		[Test]
-		public void CSharpLogicalOrTest()
+		public void LogicalOrTest()
 		{
-			CSharpTestBinaryOperatorExpressionTest("a || b", BinaryOperatorType.LogicalOr);
+			TestBinaryOperatorExpressionTest("a || b", BinaryOperatorType.LogicalOr);
 		}
 		
 		[Test]
-		public void CSharpExclusiveOrTest()
+		public void ExclusiveOrTest()
 		{
-			CSharpTestBinaryOperatorExpressionTest("a ^ b", BinaryOperatorType.ExclusiveOr);
+			TestBinaryOperatorExpressionTest("a ^ b", BinaryOperatorType.ExclusiveOr);
 		}
 		
 		
 		[Test]
-		public void CSharpGreaterThanTest()
+		public void GreaterThanTest()
 		{
-			CSharpTestBinaryOperatorExpressionTest("a > b", BinaryOperatorType.GreaterThan);
+			TestBinaryOperatorExpressionTest("a > b", BinaryOperatorType.GreaterThan);
 		}
 		
 		[Test]
-		public void CSharpGreaterThanOrEqualTest()
+		public void GreaterThanOrEqualTest()
 		{
-			CSharpTestBinaryOperatorExpressionTest("a >= b", BinaryOperatorType.GreaterThanOrEqual);
+			TestBinaryOperatorExpressionTest("a >= b", BinaryOperatorType.GreaterThanOrEqual);
 		}
 		
 		[Test]
-		public void CSharpEqualityTest()
+		public void EqualityTest()
 		{
-			CSharpTestBinaryOperatorExpressionTest("a == b", BinaryOperatorType.Equality);
+			TestBinaryOperatorExpressionTest("a == b", BinaryOperatorType.Equality);
 		}
 		
 		[Test]
-		public void CSharpInEqualityTest()
+		public void InEqualityTest()
 		{
-			CSharpTestBinaryOperatorExpressionTest("a != b", BinaryOperatorType.InEquality);
+			TestBinaryOperatorExpressionTest("a != b", BinaryOperatorType.InEquality);
 		}
 		
 		[Test]
-		public void CSharpLessThanTest()
+		public void LessThanTest()
 		{
-			CSharpTestBinaryOperatorExpressionTest("a < b", BinaryOperatorType.LessThan);
+			TestBinaryOperatorExpressionTest("a < b", BinaryOperatorType.LessThan);
 		}
 		
 		[Test]
-		public void CSharpLessThanOrEqualTest()
+		public void LessThanOrEqualTest()
 		{
-			CSharpTestBinaryOperatorExpressionTest("a <= b", BinaryOperatorType.LessThanOrEqual);
+			TestBinaryOperatorExpressionTest("a <= b", BinaryOperatorType.LessThanOrEqual);
 		}
 		
 		[Test]
-		public void CSharpAddTest()
+		public void AddTest()
 		{
-			CSharpTestBinaryOperatorExpressionTest("a + b", BinaryOperatorType.Add);
+			TestBinaryOperatorExpressionTest("a + b", BinaryOperatorType.Add);
 		}
 		
 		[Test]
-		public void CSharpSubtractTest()
+		public void SubtractTest()
 		{
-			CSharpTestBinaryOperatorExpressionTest("a - b", BinaryOperatorType.Subtract);
+			TestBinaryOperatorExpressionTest("a - b", BinaryOperatorType.Subtract);
 		}
 		
 		[Test]
-		public void CSharpMultiplyTest()
+		public void MultiplyTest()
 		{
-			CSharpTestBinaryOperatorExpressionTest("a * b", BinaryOperatorType.Multiply);
+			TestBinaryOperatorExpressionTest("a * b", BinaryOperatorType.Multiply);
 		}
 		
 		[Test]
-		public void CSharpDivideTest()
+		public void DivideTest()
 		{
-			CSharpTestBinaryOperatorExpressionTest("a / b", BinaryOperatorType.Divide);
+			TestBinaryOperatorExpressionTest("a / b", BinaryOperatorType.Divide);
 		}
 		
 		[Test]
-		public void CSharpModulusTest()
+		public void ModulusTest()
 		{
-			CSharpTestBinaryOperatorExpressionTest("a % b", BinaryOperatorType.Modulus);
+			TestBinaryOperatorExpressionTest("a % b", BinaryOperatorType.Modulus);
 		}
 		
 		[Test]
-		public void CSharpShiftLeftTest()
+		public void ShiftLeftTest()
 		{
-			CSharpTestBinaryOperatorExpressionTest("a << b", BinaryOperatorType.ShiftLeft);
+			TestBinaryOperatorExpressionTest("a << b", BinaryOperatorType.ShiftLeft);
 		}
 		
 		[Test]
-		public void CSharpShiftRightTest()
+		public void ShiftRightTest()
 		{
-			CSharpTestBinaryOperatorExpressionTest("a >> b", BinaryOperatorType.ShiftRight);
+			TestBinaryOperatorExpressionTest("a >> b", BinaryOperatorType.ShiftRight);
 		}
 		
 		[Test]
-		public void CSharpNullCoalescingTest()
+		public void NullCoalescingTest()
 		{
-			CSharpTestBinaryOperatorExpressionTest("a ?? b", BinaryOperatorType.NullCoalescing);
+			TestBinaryOperatorExpressionTest("a ?? b", BinaryOperatorType.NullCoalescing);
 		}
 		
 		[Test]
-		public void CSharpLessThanOrGreaterTest()
+		public void LessThanOrGreaterTest()
 		{
 			const string expr = "i1 < 0 || i1 > (Count - 1)";
 			BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>(expr);

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/CastExpressionTests.cs

@@ -11,7 +11,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 	{
 		/*
 		[Test]
-		public void CSharpSimpleCastExpression()
+		public void SimpleCastExpression()
 		{
 			CastExpression ce = ParseUtilCSharp.ParseExpression<CastExpression>("(MyObject)o");
 			Assert.AreEqual("MyObject", ce.CastTo.Type);
@@ -20,7 +20,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpArrayCastExpression()
+		public void ArrayCastExpression()
 		{
 			CastExpression ce = ParseUtilCSharp.ParseExpression<CastExpression>("(MyType[])o");
 			Assert.AreEqual("MyType", ce.CastTo.Type);
@@ -93,7 +93,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpCastMemberReferenceOnParenthesizedExpression()
+		public void CastMemberReferenceOnParenthesizedExpression()
 		{
 			// yes, we really wanted to evaluate .Member on expr and THEN cast the result to MyType
 			CastExpression ce = ParseUtilCSharp.ParseExpression<CastExpression>("(MyType)(expr).Member");
@@ -103,7 +103,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpTryCastParenthesizedExpression()
+		public void TryCastParenthesizedExpression()
 		{
 			CastExpression ce = ParseUtilCSharp.ParseExpression<CastExpression>("(o) as string");
 			Assert.AreEqual("System.String", ce.CastTo.ToString());
@@ -112,7 +112,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpCastNegation()
+		public void CastNegation()
 		{
 			CastExpression ce = ParseUtilCSharp.ParseExpression<CastExpression>("(uint)-negativeValue");
 			Assert.AreEqual("System.UInt32", ce.CastTo.ToString());
@@ -122,7 +122,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		*/
 		
 		[Test]
-		public void CSharpSubtractionIsNotCast()
+		public void SubtractionIsNotCast()
 		{
 			BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>("(BigInt)-negativeValue");
 			Assert.IsTrue(boe.Left is ParenthesizedExpression);
@@ -130,7 +130,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpIntMaxValueToBigInt()
+		public void IntMaxValueToBigInt()
 		{
 			CastExpression ce = ParseUtilCSharp.ParseExpression<CastExpression>("(BigInt)int.MaxValue");
 			Assert.AreEqual("BigInt", ce.CastTo.ToString());

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/CheckedExpressionTests.cs

@@ -10,14 +10,14 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 	public class CheckedExpressionTests
 	{
 		[Test]
-		public void CSharpCheckedExpressionTest()
+		public void CheckedExpressionTest()
 		{
 			CheckedExpression ce = ParseUtilCSharp.ParseExpression<CheckedExpression>("checked(a)");
 			Assert.IsTrue(ce.Expression is IdentifierExpression);
 		}
 		
 		[Test]
-		public void CSharpUncheckedExpressionTest()
+		public void UncheckedExpressionTest()
 		{
 			UncheckedExpression ce = ParseUtilCSharp.ParseExpression<UncheckedExpression>("unchecked(a)");
 			Assert.IsTrue(ce.Expression is IdentifierExpression);

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/ConditionalExpressionTests.cs

@@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 	public class ConditionalExpressionTests
 	{
 		[Test]
-		public void CSharpConditionalExpressionTest()
+		public void ConditionalExpressionTest()
 		{
 			ConditionalExpression ce = ParseUtilCSharp.ParseExpression<ConditionalExpression>("a == b ? a() : a.B");
 			
@@ -20,7 +20,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpConditionalIsExpressionTest()
+		public void ConditionalIsExpressionTest()
 		{
 			// (as is b?) ERROR (conflict with nullables, SD-419)
 			ConditionalExpression ce = ParseUtilCSharp.ParseExpression<ConditionalExpression>("a is b ? a() : a.B");
@@ -31,7 +31,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpConditionalIsWithNullableExpressionTest()
+		public void ConditionalIsWithNullableExpressionTest()
 		{
 			ConditionalExpression ce = ParseUtilCSharp.ParseExpression<ConditionalExpression>("a is b? ? a() : a.B");
 			
@@ -41,7 +41,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpConditionalIsExpressionTest2()
+		public void ConditionalIsExpressionTest2()
 		{
 			ConditionalExpression ce = ParseUtilCSharp.ParseExpression<ConditionalExpression>("a is b ? (a()) : a.B");
 			
@@ -51,7 +51,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpConditionalExpressionNegativeValue()
+		public void ConditionalExpressionNegativeValue()
 		{
 			ConditionalExpression ce = ParseUtilCSharp.ParseExpression<ConditionalExpression>("isNegative ? -1 : 1");
 			
@@ -62,7 +62,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		
 		
 		[Test]
-		public void CSharpConditionalIsWithNegativeValue()
+		public void ConditionalIsWithNegativeValue()
 		{
 			ConditionalExpression ce = ParseUtilCSharp.ParseExpression<ConditionalExpression>("a is b ? -1 : 1");
 			
@@ -72,7 +72,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpConditionalIsWithExplicitPositiveValue()
+		public void ConditionalIsWithExplicitPositiveValue()
 		{
 			ConditionalExpression ce = ParseUtilCSharp.ParseExpression<ConditionalExpression>("a is b ? +1 : 1");
 			
@@ -82,7 +82,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpRepeatedConditionalExpr()
+		public void RepeatedConditionalExpr()
 		{
 			ConditionalExpression ce = ParseUtilCSharp.ParseExpression<ConditionalExpression>("a ? b : c ? d : e");
 			
@@ -92,7 +92,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpNestedConditionalExpr()
+		public void NestedConditionalExpr()
 		{
 			ConditionalExpression ce = ParseUtilCSharp.ParseExpression<ConditionalExpression>("a ? b ? c : d : e");
 			

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/DefaultValueExpressionTests.cs

@@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 	public class DefaultValueExpressionTests
 	{
 		[Test]
-		public void CSharpSimpleDefaultValue()
+		public void SimpleDefaultValue()
 		{
 			DefaultValueExpression toe = ParseUtilCSharp.ParseExpression<DefaultValueExpression>("default(T)");
 			Assert.AreEqual("T", toe.TypeReference.Identifier.Name);
@@ -18,7 +18,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		
 		/*
 		[Test]
-		public void CSharpFullQualifiedDefaultValue()
+		public void FullQualifiedDefaultValue()
 		{
 			DefaultValueExpression toe = ParseUtilCSharp.ParseExpression<DefaultValueExpression>("default(global::MyNamespace.N1.MyType)");
 			Assert.IsTrue(toe.TypeReference.IsGlobal);
@@ -26,7 +26,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpGenericDefaultValue()
+		public void GenericDefaultValue()
 		{
 			DefaultValueExpression toe = ParseUtilCSharp.ParseExpression<DefaultValueExpression>("default(MyNamespace.N1.MyType<string>)");
 			Assert.AreEqual("MyNamespace.N1.MyType", toe.TypeReference.Type);
@@ -34,7 +34,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpDefaultValueAsIntializer()
+		public void DefaultValueAsIntializer()
 		{
 			// This test is failing because we need a resolver for the "default:" / "default(" conflict.
 			LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement<LocalVariableDeclaration>("T a = default(T);");
@@ -43,7 +43,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpDefaultValueInReturnStatement()
+		public void DefaultValueInReturnStatement()
 		{
 			ReturnStatement rs = ParseUtilCSharp.ParseStatement<ReturnStatement>("return default(T);");
 			DefaultValueExpression dve = (DefaultValueExpression)rs.Expression;

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/IdentifierExpressionTests.cs

@@ -58,7 +58,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test, Ignore]
-		public void CSharpGenericMethodReference()
+		public void GenericMethodReference()
 		{
 			IdentifierExpression ident = ParseUtilCSharp.ParseExpression<IdentifierExpression>("M<int>");
 			Assert.AreEqual("M", ident.Identifier);
@@ -67,7 +67,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test, Ignore]
-		public void CSharpGenericMethodReference2()
+		public void GenericMethodReference2()
 		{
 			IdentifierExpression ident = ParseUtilCSharp.ParseExpression<IdentifierExpression>("TargetMethod<string>");
 			Assert.AreEqual("TargetMethod", ident.Identifier);

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/IndexerExpressionTests.cs

@@ -11,7 +11,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 	public class IndexerExpressionTests
 	{
 		[Test]
-		public void CSharpIndexerExpressionTest()
+		public void IndexerExpressionTest()
 		{
 			IndexerExpression ie = ParseUtilCSharp.ParseExpression<IndexerExpression>("field[1, \"Hello\", 'a']");
 			Assert.IsTrue(ie.Target is IdentifierExpression);

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/InvocationExpressionTests.cs

@@ -11,7 +11,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 	public class InvocationExpressionTests
 	{
 		[Test]
-		public void CSharpSimpleInvocationExpressionTest()
+		public void SimpleInvocationExpressionTest()
 		{
 			var ie = ParseUtilCSharp.ParseExpression<InvocationExpression>("myMethod()");
 			Assert.AreEqual(0, ie.Arguments.Count());
@@ -21,7 +21,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		
 		/* TODO port unit tests to new DOM
 		[Test]
-		public void CSharpGenericInvocationExpressionTest()
+		public void GenericInvocationExpressionTest()
 		{
 			var expr = ParseUtilCSharp.ParseExpression<InvocationExpression>("myMethod<char>('a')");
 			Assert.AreEqual(1, expr.Arguments.Count());
@@ -33,7 +33,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpGenericInvocation2ExpressionTest()
+		public void GenericInvocation2ExpressionTest()
 		{
 			var expr = ParseUtilCSharp.ParseExpression<InvocationExpression>("myMethod<T,bool>()");
 			Assert.AreEqual(0, expr.Arguments.Count);
@@ -48,7 +48,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpAmbiguousGrammarGenericMethodCall()
+		public void AmbiguousGrammarGenericMethodCall()
 		{
 			InvocationExpression ie = ParseUtilCSharp.ParseExpression<InvocationExpression>("F(G<A,B>(7))");
 			Assert.IsTrue(ie.TargetObject is IdentifierExpression);
@@ -62,7 +62,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpAmbiguousGrammarNotAGenericMethodCall()
+		public void AmbiguousGrammarNotAGenericMethodCall()
 		{
 			BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>("F<A>+y");
 			Assert.AreEqual(BinaryOperatorType.GreaterThan, boe.Op);
@@ -71,7 +71,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpInvalidNestedInvocationExpressionTest()
+		public void InvalidNestedInvocationExpressionTest()
 		{
 			// this test was written because this bug caused the AbstractASTVisitor to crash
 			

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/MemberReferenceExpressionTests.cs

@@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 	public class MemberReferenceExpressionTests
 	{
 		[Test]
-		public void CSharpSimpleFieldReferenceExpressionTest()
+		public void SimpleFieldReferenceExpressionTest()
 		{
 			MemberReferenceExpression fre = ParseUtilCSharp.ParseExpression<MemberReferenceExpression>("myTargetObject.myField");
 			//Assert.AreEqual("myField", fre.MemberName);
@@ -21,7 +21,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		
 		/* TODO port unit tests
 		[Test]
-		public void CSharpGenericFieldReferenceExpressionTest()
+		public void GenericFieldReferenceExpressionTest()
 		{
 			MemberReferenceExpression fre = ParseUtilCSharp.ParseExpression<MemberReferenceExpression>("SomeClass<string>.myField");
 			Assert.AreEqual("myField", fre.MemberName);
@@ -33,7 +33,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpFullNamespaceGenericFieldReferenceExpressionTest()
+		public void FullNamespaceGenericFieldReferenceExpressionTest()
 		{
 			MemberReferenceExpression fre = ParseUtilCSharp.ParseExpression<MemberReferenceExpression>("Namespace.Subnamespace.SomeClass<string>.myField");
 			Assert.AreEqual("myField", fre.MemberName);
@@ -45,7 +45,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpGlobalFullNamespaceGenericFieldReferenceExpressionTest()
+		public void GlobalFullNamespaceGenericFieldReferenceExpressionTest()
 		{
 			MemberReferenceExpression fre = ParseUtilCSharp.ParseExpression<MemberReferenceExpression>("global::Namespace.Subnamespace.SomeClass<string>.myField");
 			Assert.AreEqual("myField", fre.MemberName);
@@ -59,7 +59,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpNestedGenericFieldReferenceExpressionTest()
+		public void NestedGenericFieldReferenceExpressionTest()
 		{
 			MemberReferenceExpression fre = ParseUtilCSharp.ParseExpression<MemberReferenceExpression>("MyType<string>.InnerClass<int>.myField");
 			Assert.AreEqual("myField", fre.MemberName);

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/ParenthesizedExpressionTests.cs

@@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 	public class ParenthesizedExpressionTests
 	{
 		[Test]
-		public void CSharpPrimitiveParenthesizedExpression()
+		public void PrimitiveParenthesizedExpression()
 		{
 			ParenthesizedExpression p = ParseUtilCSharp.ParseExpression<ParenthesizedExpression>("((1))");
 			Assert.IsTrue(p.Expression is ParenthesizedExpression);

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/PointerReferenceExpressionTests.cs

@@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 	public class PointerReferenceExpressionTests
 	{
 		[Test, Ignore("where did PointerReferenceExpression.MemberName go?")]
-		public void CSharpPointerReferenceExpressionTest()
+		public void PointerReferenceExpressionTest()
 		{
 			PointerReferenceExpression pre = ParseUtilCSharp.ParseExpression<PointerReferenceExpression>("myObj.field->b");
 			Assert.IsTrue(pre.Target is MemberReferenceExpression);

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/PrimitiveExpressionTests.cs

@@ -11,7 +11,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 	public class PrimitiveExpressionTests
 	{
 		[Test]
-		public void CSharpHexIntegerTest1()
+		public void HexIntegerTest1()
 		{
 			InvocationExpression invExpr = ParseUtilCSharp.ParseExpression<InvocationExpression>("0xAFFE.ToString()");
 			Assert.AreEqual(0, invExpr.Arguments.Count());
@@ -34,13 +34,13 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpDoubleTest1()
+		public void DoubleTest1()
 		{
 			CheckLiteral(".5e-06", .5e-06);
 		}
 		
 		[Test]
-		public void CSharpCharTest1()
+		public void CharTest1()
 		{
 			CheckLiteral("'\\u0356'", '\u0356');
 		}
@@ -72,7 +72,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpStringTest1()
+		public void StringTest1()
 		{
 			CheckLiteral("\"\\n\\t\\u0005 Hello World !!!\"", "\n\t\u0005 Hello World !!!");
 		}

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/SizeOfExpressionTests.cs

@@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 	public class SizeOfExpressionTests
 	{
 		[Test]
-		public void CSharpSizeOfExpressionTest()
+		public void SizeOfExpressionTest()
 		{
 			SizeOfExpression soe = ParseUtilCSharp.ParseExpression<SizeOfExpression>("sizeof(MyType)");
 			Assert.AreEqual("MyType", soe.Type.Identifier.Name);

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/StackAllocExpressionTests.cs

@@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 	public class StackAllocExpressionTests
 	{
 		[Test, Ignore]
-		public void CSharpStackAllocExpressionTest()
+		public void StackAllocExpressionTest()
 		{
 			var sae = ParseUtilCSharp.ParseExpression<StackAllocExpression>("stackalloc int[100]");
 			throw new NotImplementedException(); // TODO: verify type + length expression

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/TypeOfExpressionTests.cs

@@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 	public class TypeOfExpressionTests
 	{
 		[Test]
-		public void CSharpSimpleTypeOfExpressionTest()
+		public void SimpleTypeOfExpressionTest()
 		{
 			//TypeOfExpression toe = ParseUtilCSharp.ParseExpression<TypeOfExpression>("typeof(MyNamespace.N1.MyType)");
 			//Assert.AreEqual("MyNamespace.N1.MyType", toe.TypeReference.Type);
@@ -19,28 +19,28 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		
 		/* TODO
 		[Test]
-		public void CSharpGlobalTypeOfExpressionTest()
+		public void GlobalTypeOfExpressionTest()
 		{
 			TypeOfExpression toe = ParseUtilCSharp.ParseExpression<TypeOfExpression>("typeof(global::System.Console)");
 			Assert.AreEqual("System.Console", toe.TypeReference.Type);
 		}
 		
 		[Test]
-		public void CSharpPrimitiveTypeOfExpressionTest()
+		public void PrimitiveTypeOfExpressionTest()
 		{
 			TypeOfExpression toe = ParseUtilCSharp.ParseExpression<TypeOfExpression>("typeof(int)");
 			Assert.AreEqual("System.Int32", toe.TypeReference.Type);
 		}
 		
 		[Test]
-		public void CSharpVoidTypeOfExpressionTest()
+		public void VoidTypeOfExpressionTest()
 		{
 			TypeOfExpression toe = ParseUtilCSharp.ParseExpression<TypeOfExpression>("typeof(void)");
 			Assert.AreEqual("System.Void", toe.TypeReference.Type);
 		}
 		
 		[Test]
-		public void CSharpArrayTypeOfExpressionTest()
+		public void ArrayTypeOfExpressionTest()
 		{
 			TypeOfExpression toe = ParseUtilCSharp.ParseExpression<TypeOfExpression>("typeof(MyType[])");
 			Assert.AreEqual("MyType", toe.TypeReference.Type);
@@ -48,7 +48,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpGenericTypeOfExpressionTest()
+		public void GenericTypeOfExpressionTest()
 		{
 			TypeOfExpression toe = ParseUtilCSharp.ParseExpression<TypeOfExpression>("typeof(MyNamespace.N1.MyType<string>)");
 			Assert.AreEqual("MyNamespace.N1.MyType", toe.TypeReference.Type);
@@ -56,7 +56,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpNestedGenericTypeOfExpressionTest()
+		public void NestedGenericTypeOfExpressionTest()
 		{
 			TypeOfExpression toe = ParseUtilCSharp.ParseExpression<TypeOfExpression>("typeof(MyType<string>.InnerClass<int>.InnerInnerClass)");
 			InnerClassTypeReference ic = (InnerClassTypeReference)toe.TypeReference;
@@ -72,7 +72,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpNullableTypeOfExpressionTest()
+		public void NullableTypeOfExpressionTest()
 		{
 			TypeOfExpression toe = ParseUtilCSharp.ParseExpression<TypeOfExpression>("typeof(MyStruct?)");
 			Assert.AreEqual("System.Nullable", toe.TypeReference.Type);
@@ -80,7 +80,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpUnboundTypeOfExpressionTest()
+		public void UnboundTypeOfExpressionTest()
 		{
 			TypeOfExpression toe = ParseUtilCSharp.ParseExpression<TypeOfExpression>("typeof(MyType<,>)");
 			Assert.AreEqual("MyType", toe.TypeReference.Type);

ICSharpCode.NRefactory.Tests/CSharp/Parser/Expression/UnaryOperatorExpressionTests.cs

@@ -9,7 +9,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 	[TestFixture]
 	public class UnaryOperatorExpressionTests
 	{
-		void CSharpTestUnaryOperatorExpressionTest(string program, UnaryOperatorType op)
+		void TestUnaryOperatorExpressionTest(string program, UnaryOperatorType op)
 		{
 			UnaryOperatorExpression uoe = ParseUtilCSharp.ParseExpression<UnaryOperatorExpression>(program);
 			Assert.AreEqual(op, uoe.UnaryOperatorType);
@@ -18,67 +18,67 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Expression
 		}
 		
 		[Test]
-		public void CSharpNotTest()
+		public void NotTest()
 		{
-			CSharpTestUnaryOperatorExpressionTest("!a", UnaryOperatorType.Not);
+			TestUnaryOperatorExpressionTest("!a", UnaryOperatorType.Not);
 		}
 		
 		[Test]
-		public void CSharpBitNotTest()
+		public void BitNotTest()
 		{
-			CSharpTestUnaryOperatorExpressionTest("~a", UnaryOperatorType.BitNot);
+			TestUnaryOperatorExpressionTest("~a", UnaryOperatorType.BitNot);
 		}
 		
 		[Test]
-		public void CSharpMinusTest()
+		public void MinusTest()
 		{
-			CSharpTestUnaryOperatorExpressionTest("-a", UnaryOperatorType.Minus);
+			TestUnaryOperatorExpressionTest("-a", UnaryOperatorType.Minus);
 		}
 		
 		[Test]
-		public void CSharpPlusTest()
+		public void PlusTest()
 		{
-			CSharpTestUnaryOperatorExpressionTest("+a", UnaryOperatorType.Plus);
+			TestUnaryOperatorExpressionTest("+a", UnaryOperatorType.Plus);
 		}
 		
 		[Test]
-		public void CSharpIncrementTest()
+		public void IncrementTest()
 		{
-			CSharpTestUnaryOperatorExpressionTest("++a", UnaryOperatorType.Increment);
+			TestUnaryOperatorExpressionTest("++a", UnaryOperatorType.Increment);
 		}
 		
 		[Test]
-		public void CSharpDecrementTest()
+		public void DecrementTest()
 		{
-			CSharpTestUnaryOperatorExpressionTest("--a", UnaryOperatorType.Decrement);
+			TestUnaryOperatorExpressionTest("--a", UnaryOperatorType.Decrement);
 		}
 		
 		[Test]
-		public void CSharpPostIncrementTest()
+		public void PostIncrementTest()
 		{
-			CSharpTestUnaryOperatorExpressionTest("a++", UnaryOperatorType.PostIncrement);
+			TestUnaryOperatorExpressionTest("a++", UnaryOperatorType.PostIncrement);
 		}
 		
 		[Test]
-		public void CSharpPostDecrementTest()
+		public void PostDecrementTest()
 		{
-			CSharpTestUnaryOperatorExpressionTest("a--", UnaryOperatorType.PostDecrement);
+			TestUnaryOperatorExpressionTest("a--", UnaryOperatorType.PostDecrement);
 		}
 		
 		[Test]
-		public void CSharpStarTest()
+		public void StarTest()
 		{
-			CSharpTestUnaryOperatorExpressionTest("*a", UnaryOperatorType.Dereference);
+			TestUnaryOperatorExpressionTest("*a", UnaryOperatorType.Dereference);
 		}
 		
 		[Test]
-		public void CSharpBitWiseAndTest()
+		public void BitWiseAndTest()
 		{
-			CSharpTestUnaryOperatorExpressionTest("&a", UnaryOperatorType.AddressOf);
+			TestUnaryOperatorExpressionTest("&a", UnaryOperatorType.AddressOf);
 		}
 		
 		[Test]
-		public void CSharpDereferenceAfterCast()
+		public void DereferenceAfterCast()
 		{
 			UnaryOperatorExpression uoe = ParseUtilCSharp.ParseExpression<UnaryOperatorExpression>("*((SomeType*) &w)");
 			Assert.AreEqual(UnaryOperatorType.Dereference, uoe.UnaryOperatorType);

ICSharpCode.NRefactory.Tests/CSharp/Parser/GeneralScope/DelegateDeclarationTests.cs

@@ -35,7 +35,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope
 		}
 		
 		[Test, Ignore]
-		public void CSharpDelegateWithoutNameDeclarationTest()
+		public void DelegateWithoutNameDeclarationTest()
 		{
 			string program = "public delegate void(int a, int secondParam, MyObj lastParam);\n";
 			DelegateDeclaration dd = ParseUtilCSharp.ParseGlobal<DelegateDeclaration>(program, true);
@@ -45,7 +45,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope
 		}
 		
 		[Test, Ignore]
-		public void CSharpGenericDelegateDeclarationTest()
+		public void GenericDelegateDeclarationTest()
 		{
 			string program = "public delegate T CreateObject<T>() where T : ICloneable;\n";
 			DelegateDeclaration dd = ParseUtilCSharp.ParseGlobal<DelegateDeclaration>(program);

ICSharpCode.NRefactory.Tests/CSharp/Parser/GeneralScope/UsingDeclarationTests.cs

@@ -13,7 +13,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope
 	{
 		[Test]
 		[Ignore("error reporting not yet implemented")]
-		public void CSharpWrongUsingTest()
+		public void WrongUsingTest()
 		{
 			string program = "using\n";
 			CSharpParser parser = new CSharpParser();
@@ -23,7 +23,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope
 		}
 		
 		[Test]
-		public void CSharpDeclarationTest()
+		public void DeclarationTest()
 		{
 			string program = "using System;\n" +
 				"using My.Name.Space;\n";
@@ -44,7 +44,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope
 		}
 		
 		[Test]
-		public void CSharpUsingAliasDeclarationTest()
+		public void UsingAliasDeclarationTest()
 		{
 			string program = "using TESTME=System;\n" +
 				"using myAlias=My.Name.Space;\n" +
@@ -75,7 +75,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.GeneralScope
 		
 		[Test]
 		[Ignore("'::' not yet implemented")]
-		public void CSharpUsingWithAliasing()
+		public void UsingWithAliasing()
 		{
 			string program = "using global::System;\n" +
 				"using myAlias=global::My.Name.Space;\n" +

ICSharpCode.NRefactory.Tests/CSharp/Parser/ParseUtil.cs

@@ -55,5 +55,21 @@ namespace ICSharpCode.NRefactory.CSharp.Parser
 			Assert.IsTrue(type.IsAssignableFrom(parsedExpression.GetType()), String.Format("Parsed expression was {0} instead of {1} ({2})", parsedExpression.GetType(), type, parsedExpression));
 			return (T)parsedExpression;
 		}
+		
+		public static T ParseTypeMember<T>(string expr, bool expectErrors = false) where T : AbstractMemberBase
+		{
+			Assert.Ignore("ParseTypeMember not yet implemented");
+			
+			CSharpParser parser = new CSharpParser();
+			var members = parser.ParseTypeMembers(new StringReader(expr));
+			
+			Assert.AreEqual(expectErrors, parser.HasErrors, "HasErrors");
+			
+			Assert.AreEqual(1, members.Count);
+			AbstractMemberBase m = members[0];
+			Type type = typeof(T);
+			Assert.IsTrue(type.IsAssignableFrom(m.GetType()), String.Format("Parsed member was {0} instead of {1} ({2})", m.GetType(), type, m));
+			return (T)m;
+		}
 	}
 }

ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/BlockStatementTests.cs

@@ -11,14 +11,14 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements
 	public class BlockStatementTests
 	{
 		[Test]
-		public void CSharpBlockStatementTest()
+		public void BlockStatementTest()
 		{
 			BlockStatement blockStmt = ParseUtilCSharp.ParseStatement<BlockStatement>("{}");
 			Assert.AreEqual(0, blockStmt.Statements.Count());
 		}
 		
 		[Test]
-		public void CSharpComplexBlockStatementPositionTest()
+		public void ComplexBlockStatementPositionTest()
 		{
 			string code = @"{
 	WebClient wc = new WebClient();

ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/EmptyStatementTests.cs

@@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements
 	public class EmptyStatementTests
 	{
 		[Test]
-		public void CSharpEmptyStatementTest()
+		public void EmptyStatementTest()
 		{
 			EmptyStatement emptyStmt = ParseUtilCSharp.ParseStatement<EmptyStatement>(";");
 		}

ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/FixedStatementTests.cs

@@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements
 	public class FixedStatementTests
 	{
 		[Test]
-		public void CSharpFixedStatementTest()
+		public void FixedStatementTest()
 		{
 			FixedStatement fixedStmt = ParseUtilCSharp.ParseStatement<FixedStatement>("fixed (int* ptr = &myIntArr) { }");
 			// TODO : Extend test.

ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/ForStatementTests.cs

@@ -11,14 +11,14 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements
 	public class ForStatementTests
 	{
 		[Test]
-		public void CSharpForeachStatementTest()
+		public void ForeachStatementTest()
 		{
 			ForeachStatement foreachStmt = ParseUtilCSharp.ParseStatement<ForeachStatement>("foreach (int i in myColl) {} ");
 			// TODO : Extend test.
 		}
 		
 		[Test]
-		public void CSharpEmptyForStatementTest()
+		public void EmptyForStatementTest()
 		{
 			ForStatement forStmt = ParseUtilCSharp.ParseStatement<ForStatement>("for (;;) ;");
 			Assert.AreEqual(0, forStmt.Initializers.Count());
@@ -28,7 +28,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements
 		}
 		
 		[Test]
-		public void CSharpForStatementTest()
+		public void ForStatementTest()
 		{
 			ForStatement forStmt = ParseUtilCSharp.ParseStatement<ForStatement>("for (int i = 5; i < 6; ++i) {} ");
 			// TODO : Extend test.

ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/LockStatementTests.cs

@@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements
 	public class LockStatementTests
 	{
 		[Test]
-		public void CSharpLockStatementTest()
+		public void LockStatementTest()
 		{
 			LockStatement lockStmt = ParseUtilCSharp.ParseStatement<LockStatement>("lock (myObj) {}");
 			// TODO : Extend test.

ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/TryCatchStatementTests.cs

@@ -11,7 +11,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements
 	public class TryCatchStatementTests
 	{
 		[Test]
-		public void CSharpSimpleTryCatchStatementTest()
+		public void SimpleTryCatchStatementTest()
 		{
 			TryCatchStatement tryCatchStatement = ParseUtilCSharp.ParseStatement<TryCatchStatement>("try { } catch { } ");
 			Assert.IsNull(tryCatchStatement.FinallyBlock);
@@ -22,7 +22,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements
 		
 		/* TODO port tests
 		[Test]
-		public void CSharpSimpleTryCatchStatementTest2()
+		public void SimpleTryCatchStatementTest2()
 		{
 			TryCatchStatement tryCatchStatement = ParseUtilCSharp.ParseStatement<TryCatchStatement>("try { } catch (Exception e) { } ");
 			Assert.IsTrue(tryCatchStatement.FinallyBlock.IsNull);
@@ -32,7 +32,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements
 		}
 		
 		[Test]
-		public void CSharpSimpleTryCatchFinallyStatementTest()
+		public void SimpleTryCatchFinallyStatementTest()
 		{
 			TryCatchStatement tryCatchStatement = ParseUtilCSharp.ParseStatement<TryCatchStatement>("try { } catch (Exception) { } catch { } finally { } ");
 			Assert.IsFalse(tryCatchStatement.FinallyBlock.IsNull);

ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/UnsafeStatementTests.cs

@@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements
 	public class UnsafeStatementTests
 	{
 			[Test]
-		public void CSharpUnsafeStatementTest()
+		public void UnsafeStatementTest()
 		{
 			UnsafeStatement unsafeStatement = ParseUtilCSharp.ParseStatement<UnsafeStatement>("unsafe { }");
 			Assert.IsNotNull(unsafeStatement.Block);

ICSharpCode.NRefactory.Tests/CSharp/Parser/Statements/UsingStatementTests.cs

@@ -9,8 +9,8 @@ namespace ICSharpCode.NRefactory.CSharp.Parser.Statements
 	[TestFixture]
 	public class UsingStatementTests
 	{
-			[Test]
-		public void CSharpUsingStatementTest()
+		[Test]
+		public void UsingStatementTest()
 		{
 			UsingStatement usingStmt = ParseUtilCSharp.ParseStatement<UsingStatement>("using (MyVar var = new MyVar()) { } ");
 			// TODO : Extend test.

ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/ConstructorDeclarationTests.cs

@@ -0,0 +1,52 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using System.Linq;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers
+{
+	[TestFixture]
+	public class ConstructorDeclarationTests
+	{
+		[Test]
+		public void ConstructorDeclarationTest1()
+		{
+			ConstructorDeclaration cd = ParseUtilCSharp.ParseTypeMember<ConstructorDeclaration>("MyClass() {}");
+			Assert.IsNull(cd.Initializer);
+		}
+		
+		[Test]
+		public void ConstructorDeclarationTest2()
+		{
+			ConstructorDeclaration cd = ParseUtilCSharp.ParseTypeMember<ConstructorDeclaration>("MyClass() : this(5) {}");
+			Assert.AreEqual(ConstructorInitializerType.This, cd.Initializer.ConstructorInitializerType);
+			Assert.AreEqual(1, cd.Initializer.Arguments.Count());
+		}
+		
+		[Test]
+		public void ConstructorDeclarationTest3()
+		{
+			ConstructorDeclaration cd = ParseUtilCSharp.ParseTypeMember<ConstructorDeclaration>("MyClass() : base(1, 2, 3) {}");
+			Assert.AreEqual(ConstructorInitializerType.Base, cd.Initializer.ConstructorInitializerType);
+			Assert.AreEqual(3, cd.Initializer.Arguments.Count());
+		}
+		
+		[Test]
+		public void StaticConstructorDeclarationTest1()
+		{
+			ConstructorDeclaration cd = ParseUtilCSharp.ParseTypeMember<ConstructorDeclaration>("static MyClass() {}");
+			Assert.IsNull(cd.Initializer);
+			Assert.AreEqual(Modifiers.Static, cd.Modifiers);
+		}
+		
+		[Test]
+		public void ExternStaticConstructorDeclarationTest()
+		{
+			ConstructorDeclaration cd = ParseUtilCSharp.ParseTypeMember<ConstructorDeclaration>("extern static MyClass();");
+			Assert.IsNull(cd.Initializer);
+			Assert.AreEqual(Modifiers.Static | Modifiers.Extern, cd.Modifiers);
+		}
+	}
+}

ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/DestructorDeclarationTests.cs

@@ -0,0 +1,32 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers
+{
+	[TestFixture]
+	public class DestructorDeclarationTests
+	{
+		[Test]
+		public void DestructorDeclarationTest()
+		{
+			DestructorDeclaration dd = ParseUtilCSharp.ParseTypeMember<DestructorDeclaration>("~MyClass() {}");
+		}
+		
+		[Test]
+		public void ExternDestructorDeclarationTest()
+		{
+			DestructorDeclaration dd = ParseUtilCSharp.ParseTypeMember<DestructorDeclaration>("extern ~MyClass();");
+			Assert.AreEqual(Modifiers.Extern, dd.Modifiers);
+		}
+		
+		[Test]
+		public void UnsafeDestructorDeclarationTest()
+		{
+			DestructorDeclaration dd = ParseUtilCSharp.ParseTypeMember<DestructorDeclaration>("unsafe ~MyClass() {}");
+			Assert.AreEqual(Modifiers.Unsafe, dd.Modifiers);
+		}
+	}
+}

ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/EventDeclarationTests.cs

@@ -0,0 +1,84 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers
+{
+	[TestFixture, Ignore]
+	public class EventDeclarationTests
+	{
+		[Test]
+		public void SimpleEventDeclarationTest()
+		{
+			EventDeclaration ed = ParseUtilCSharp.ParseTypeMember<EventDeclaration>("event System.EventHandler MyEvent;");
+			Assert.AreEqual("MyEvent", ed.Name);
+			//Assert.AreEqual("System.EventHandler", ed.TypeReference.Type);
+			Assert.Ignore(); // check type
+			
+			Assert.IsNull(ed.AddAccessor);
+			Assert.IsNull(ed.RemoveAccessor);
+		}
+		
+		/* TODO Port tests
+		[Test]
+		public void MultipleEventDeclarationTest()
+		{
+			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);
+		}
+		
+		[Test]
+		public void EventImplementingInterfaceDeclarationTest()
+		{
+			EventDeclaration ed = ParseUtilCSharp.ParseTypeMember<EventDeclaration>("event EventHandler MyInterface.MyEvent;");
+			
+			Assert.AreEqual("MyEvent", ed.Name);
+			Assert.AreEqual("EventHandler", ed.TypeReference.Type);
+			
+			Assert.IsFalse(ed.HasAddRegion);
+			Assert.IsFalse(ed.HasRemoveRegion);
+			
+			Assert.AreEqual("MyInterface", ed.InterfaceImplementations[0].InterfaceType.Type);
+			Assert.AreEqual("MyEvent", ed.InterfaceImplementations[0].MemberName);
+		}
+		
+		[Test]
+		public void EventImplementingGenericInterfaceDeclarationTest()
+		{
+			EventDeclaration ed = ParseUtilCSharp.ParseTypeMember<EventDeclaration>("event EventHandler MyInterface<string>.MyEvent;");
+			
+			Assert.AreEqual("MyEvent", ed.Name);
+			Assert.AreEqual("EventHandler", ed.TypeReference.Type);
+			
+			Assert.IsFalse(ed.HasAddRegion);
+			Assert.IsFalse(ed.HasRemoveRegion);
+			
+			Assert.AreEqual("MyInterface", ed.InterfaceImplementations[0].InterfaceType.Type);
+			Assert.AreEqual("System.String", ed.InterfaceImplementations[0].InterfaceType.GenericTypes[0].Type);
+			Assert.AreEqual("MyEvent", ed.InterfaceImplementations[0].MemberName);
+		}
+		
+		[Test]
+		public void AddRemoveEventDeclarationTest()
+		{
+			EventDeclaration ed = ParseUtilCSharp.ParseTypeMember<EventDeclaration>("event System.EventHandler MyEvent { add { } remove { } }");
+			Assert.AreEqual("MyEvent", ed.Name);
+			Assert.AreEqual("System.EventHandler", ed.TypeReference.Type);
+			
+			Assert.IsTrue(ed.HasAddRegion);
+			Assert.IsTrue(ed.HasRemoveRegion);
+		}*/
+	}
+}

ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/FieldDeclarationTests.cs

@@ -0,0 +1,27 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers
+{
+	[TestFixture, Ignore]
+	public class FieldDeclarationTests
+	{
+		[Test]
+		public void SimpleFieldDeclarationTest()
+		{
+			throw new NotImplementedException();
+			/*
+			FieldDeclaration fd = ParseUtilCSharp.ParseTypeMember<FieldDeclaration>("int[,,,] myField;");
+			Assert.AreEqual("System.Int32", fd.TypeReference.Type);
+			Assert.AreEqual(new int[] { 3 } , fd.TypeReference.RankSpecifier);
+			Assert.AreEqual(1, fd.Fields.Count);
+			
+			Assert.AreEqual("myField", ((VariableDeclaration)fd.Fields[0]).Name);*/
+		}
+		
+		// TODO add more tests
+	}
+}

ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/IndexerDeclarationTests.cs

@@ -0,0 +1,47 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using System.Linq;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers
+{
+	[TestFixture]
+	public class IndexerDeclarationTests
+	{
+		[Test]
+		public void IndexerDeclarationTest()
+		{
+			IndexerDeclaration id = ParseUtilCSharp.ParseTypeMember<IndexerDeclaration>("int this[int a, string b] { get { } set { } }");
+			Assert.AreEqual(2, id.Parameters.Count());
+			Assert.IsNotNull(id.GetAccessor, "No get region found!");
+			Assert.IsNotNull(id.SetAccessor, "No set region found!");
+		}
+		
+		[Test]
+		public void IndexerImplementingInterfaceTest()
+		{
+			IndexerDeclaration id = ParseUtilCSharp.ParseTypeMember<IndexerDeclaration>("int MyInterface.this[int a, string b] { get { } set { } }");
+			Assert.AreEqual(2, id.Parameters.Count());
+			Assert.IsNotNull(id.GetAccessor, "No get region found!");
+			Assert.IsNotNull(id.SetAccessor, "No set region found!");
+			
+			Assert.AreEqual("MyInterface", id.PrivateImplementationType);
+		}
+		
+		[Test, Ignore]
+		public void IndexerImplementingGenericInterfaceTest()
+		{
+			throw new NotImplementedException();
+			/*
+			IndexerDeclaration id = ParseUtilCSharp.ParseTypeMember<IndexerDeclaration>("int MyInterface<string>.this[int a, string b] { get { } set { } }");
+			Assert.AreEqual(2, id.Parameters.Count);
+			Assert.IsNotNull(id.GetAccessor, "No get region found!");
+			Assert.IsNotNull(id.SetAccessor, "No set region found!");
+			
+			Assert.AreEqual("MyInterface", id.InterfaceImplementations[0].InterfaceType.Type);
+			Assert.AreEqual("System.String", id.InterfaceImplementations[0].InterfaceType.GenericTypes[0].Type);*/
+		}
+	}
+}

ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/MethodDeclarationTests.cs

@@ -0,0 +1,300 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using System.Linq;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers
+{
+	[TestFixture]
+	public class MethodDeclarationTests
+	{
+		[Test]
+		public void SimpleMethodDeclarationTest()
+		{
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("void MyMethod() {} ");
+			Assert.AreEqual("System.Void", md.ReturnType);
+			Assert.AreEqual(0, md.Parameters.Count());
+			Assert.IsFalse(md.IsExtensionMethod);
+		}
+		
+		[Test]
+		public void AbstractMethodDeclarationTest()
+		{
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("abstract void MyMethod();");
+			Assert.AreEqual("System.Void", md.ReturnType);
+			Assert.AreEqual(0, md.Parameters.Count());
+			Assert.IsFalse(md.IsExtensionMethod);
+			Assert.IsNull(md.Body);
+			Assert.AreEqual(Modifiers.Abstract, md.Modifiers);
+		}
+		
+		[Test]
+		public void DefiningPartialMethodDeclarationTest()
+		{
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("partial void MyMethod();");
+			Assert.AreEqual("System.Void", md.ReturnType);
+			Assert.AreEqual(0, md.Parameters.Count());
+			Assert.IsFalse(md.IsExtensionMethod);
+			Assert.IsNull(md.Body);
+			Assert.AreEqual(Modifiers.Partial, md.Modifiers);
+		}
+		
+		[Test]
+		public void ImplementingPartialMethodDeclarationTest()
+		{
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("partial void MyMethod() { }");
+			Assert.AreEqual("System.Void", md.ReturnType);
+			Assert.AreEqual(0, md.Parameters.Count());
+			Assert.IsFalse(md.IsExtensionMethod);
+			Assert.IsNotNull(md.Body);
+			Assert.AreEqual(Modifiers.Partial, md.Modifiers);
+		}
+		
+		[Test]
+		public void SimpleMethodRegionTest()
+		{
+			const string program = @"
+		void MyMethod()
+		{
+			OtherMethod();
+		}
+";
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>(program);
+			Assert.AreEqual(2, md.StartLocation.Line, "StartLocation.Y");
+			Assert.AreEqual(2, md.EndLocation.Line, "EndLocation.Y");
+			Assert.AreEqual(3, md.StartLocation.Column, "StartLocation.X");
+			Assert.AreEqual(18, md.EndLocation.Column, "EndLocation.X");
+		}
+		
+		[Test]
+		public void MethodWithModifiersRegionTest()
+		{
+			const string program = @"
+		public static void MyMethod()
+		{
+			OtherMethod();
+		}
+";
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>(program);
+			Assert.AreEqual(2, md.StartLocation.Line, "StartLocation.Y");
+			Assert.AreEqual(2, md.EndLocation.Line, "EndLocation.Y");
+			Assert.AreEqual(3, md.StartLocation.Column, "StartLocation.X");
+		}
+		
+		[Test]
+		public void MethodWithUnnamedParameterDeclarationTest()
+		{
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("void MyMethod(int) {} ", true);
+			Assert.AreEqual("System.Void", md.ReturnType);
+			Assert.AreEqual(1, md.Parameters.Count());
+			//Assert.AreEqual("?", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName);
+		}
+		
+		/* TODO: port unit tests
+		[Test]
+		public void GenericVoidMethodDeclarationTest()
+		{
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("void MyMethod<T>(T a) {} ");
+			Assert.AreEqual("System.Void", md.ReturnType);
+			Assert.AreEqual(1, md.Parameters.Count());
+			Assert.AreEqual("T", md.Parameters.Single().Type);
+			Assert.AreEqual("a", md.Parameters.Single().Name);
+			
+			Assert.AreEqual(1, md.TypeParameters.Count());
+			Assert.AreEqual("T", md.Templates[0].Name);
+		}
+		
+		[Test]
+		public void GenericMethodDeclarationTest()
+		{
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("T MyMethod<T>(T a) {} ");
+			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 GenericMethodDeclarationWithConstraintTest()
+		{
+			string program = "T MyMethod<T>(T a) where T : ISomeInterface {} ";
+			MethodDeclaration md = ParseUtilCSharp.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);
+		}
+		
+		[Test]
+		public void GenericMethodInInterface()
+		{
+			const string program = @"interface MyInterface {
+	T MyMethod<T>(T a) where T : ISomeInterface;
+}
+";
+			TypeDeclaration td = ParseUtilCSharp.ParseGlobal<TypeDeclaration>(program);
+			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 GenericVoidMethodInInterface()
+		{
+			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);
+		}
+		
+		[Test]
+		public void ShadowingMethodInInterface()
+		{
+			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);
+		}
+		
+		[Test]
+		public void MethodImplementingInterfaceTest()
+		{
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("int MyInterface.MyMethod() {} ");
+			Assert.AreEqual("System.Int32", md.TypeReference.Type);
+			
+			Assert.AreEqual("MyInterface", md.InterfaceImplementations[0].InterfaceType.Type);
+		}
+		
+		[Test]
+		public void MethodImplementingGenericInterfaceTest()
+		{
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("int MyInterface<string>.MyMethod() {} ");
+			Assert.AreEqual("System.Int32", md.TypeReference.Type);
+			
+			Assert.AreEqual("MyInterface", md.InterfaceImplementations[0].InterfaceType.Type);
+			Assert.AreEqual("System.String", md.InterfaceImplementations[0].InterfaceType.GenericTypes[0].Type);
+		}
+		
+		[Test]
+		public void VoidMethodImplementingInterfaceTest()
+		{
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("void MyInterface.MyMethod() {} ");
+			Assert.AreEqual("System.Void", md.TypeReference.Type);
+			
+			Assert.AreEqual("MyInterface", md.InterfaceImplementations[0].InterfaceType.Type);
+		}
+		
+		[Test]
+		public void VoidMethodImplementingGenericInterfaceTest()
+		{
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("void MyInterface<string>.MyMethod() {} ");
+			Assert.AreEqual("System.Void", md.TypeReference.Type);
+			
+			Assert.AreEqual("MyInterface", md.InterfaceImplementations[0].InterfaceType.Type);
+			Assert.AreEqual("System.String", md.InterfaceImplementations[0].InterfaceType.GenericTypes[0].Type);
+		}
+		
+		[Test]
+		public void IncompleteConstraintsTest()
+		{
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>(
+				"void a<T>() where T { }", true // expect errors
+			);
+			Assert.AreEqual("a", md.Name);
+			Assert.AreEqual(1, md.Templates.Count);
+			Assert.AreEqual("T", md.Templates[0].Name);
+			Assert.AreEqual(0, md.Templates[0].Bases.Count);
+		}
+		
+		[Test]
+		public void ExtensionMethodTest()
+		{
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>(
+				"public static int ToInt32(this string s) { return int.Parse(s); }"
+			);
+			Assert.AreEqual("ToInt32", md.Name);
+			Assert.IsTrue(md.IsExtensionMethod);
+			Assert.AreEqual("s", md.Parameters[0].ParameterName);
+			Assert.AreEqual("System.String", md.Parameters[0].TypeReference.Type);
+		}
+		
+		[Test]
+		public void VoidExtensionMethodTest()
+		{
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>(
+				"public static void Print(this string s) { Console.WriteLine(s); }"
+			);
+			Assert.AreEqual("Print", md.Name);
+			Assert.IsTrue(md.IsExtensionMethod);
+			Assert.AreEqual("s", md.Parameters[0].ParameterName);
+			Assert.AreEqual("System.String", md.Parameters[0].TypeReference.Type);
+		}
+		
+		[Test]
+		public void MethodWithEmptyAssignmentErrorInBody()
+		{
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>(
+				"void A\n" +
+				"{\n" +
+				"int a = 3;\n" +
+				" = 4;\n" +
+				"}", true // expect errors
+			);
+			Assert.AreEqual("A", md.Name);
+			Assert.AreEqual(new Location(1, 2), md.Body.StartLocation);
+			Assert.AreEqual(new Location(2, 5), md.Body.EndLocation);
+		}
+		
+		[Test]
+		public void OptionalParameterTest()
+		{
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>(
+				"public void Foo(string bar = null, int baz = 0) { }"
+			);
+			Assert.AreEqual("Foo", md.Name);
+			
+			Assert.AreEqual("bar", md.Parameters[0].ParameterName);
+			Assert.AreEqual("System.String", md.Parameters[0].TypeReference.Type);
+			Assert.AreEqual(ParameterModifiers.In | ParameterModifiers.Optional, md.Parameters[0].ParamModifier);
+			Assert.IsNull(((PrimitiveExpression)md.Parameters[0].DefaultValue).Value);
+			
+			Assert.AreEqual("baz", md.Parameters[1].ParameterName);
+			Assert.AreEqual("System.Int32", md.Parameters[1].TypeReference.Type);
+			Assert.AreEqual(ParameterModifiers.In | ParameterModifiers.Optional, md.Parameters[1].ParamModifier);
+			Assert.AreEqual(0, ((PrimitiveExpression)md.Parameters[1].DefaultValue).Value);
+		}*/
+	}
+}

ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/OperatorDeclarationTests.cs

@@ -0,0 +1,53 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using System.Linq;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers
+{
+	[TestFixture]
+	public class OperatorDeclarationTests
+	{
+		[Test]
+		public void ImplictOperatorDeclarationTest()
+		{
+			OperatorDeclaration od = ParseUtilCSharp.ParseTypeMember<OperatorDeclaration>("public static implicit operator double(MyObject f)  { return 0.5d; }");
+			Assert.AreEqual(OperatorType.Implicit, od.OperatorType);
+			Assert.AreEqual(1, od.Parameters.Count());
+			Assert.AreEqual("System.Double", od.ReturnType);
+			Assert.AreEqual("op_Implicit", od.Name);
+		}
+		
+		[Test]
+		public void ExplicitOperatorDeclarationTest()
+		{
+			OperatorDeclaration od = ParseUtilCSharp.ParseTypeMember<OperatorDeclaration>("public static explicit operator double(MyObject f)  { return 0.5d; }");
+			Assert.AreEqual(OperatorType.Explicit, od.OperatorType);
+			Assert.AreEqual(1, od.Parameters.Count());
+			Assert.AreEqual("System.Double", od.ReturnType);
+			Assert.AreEqual("op_Explicit", od.Name);
+		}
+		
+		[Test]
+		public void BinaryPlusOperatorDeclarationTest()
+		{
+			OperatorDeclaration od = ParseUtilCSharp.ParseTypeMember<OperatorDeclaration>("public static MyObject operator +(MyObject a, MyObject b)  {}");
+			Assert.AreEqual(OperatorType.Addition, od.OperatorType);
+			Assert.AreEqual(2, od.Parameters.Count());
+			Assert.AreEqual("MyObject", od.ReturnType);
+			Assert.AreEqual("op_Addition", od.Name);
+		}
+		
+		[Test]
+		public void UnaryPlusOperatorDeclarationTest()
+		{
+			OperatorDeclaration od = ParseUtilCSharp.ParseTypeMember<OperatorDeclaration>("public static MyObject operator +(MyObject a)  {}");
+			Assert.AreEqual(OperatorType.UnaryPlus, od.OperatorType);
+			Assert.AreEqual(1, od.Parameters.Count());
+			Assert.AreEqual("MyObject", od.ReturnType);
+			Assert.AreEqual("op_UnaryPlus", od.Name);
+		}
+	}
+}

ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeMembers/PropertyDeclarationTests.cs

@@ -0,0 +1,93 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using System.IO;
+using System.Linq;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.CSharp.Parser.TypeMembers
+{
+	[TestFixture]
+	public class PropertyDeclarationTests
+	{
+		[Test]
+		public void SimpleGetSetPropertyDeclarationTest()
+		{
+			PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember<PropertyDeclaration>("int MyProperty { get {} set {} } ");
+			Assert.AreEqual("MyProperty", pd.Name);
+			Assert.IsNotNull(pd.GetAccessor);
+			Assert.IsNotNull(pd.SetAccessor);
+		}
+		
+		[Test]
+		public void GetSetPropertyDeclarationWithAccessorModifiers()
+		{
+			PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember<PropertyDeclaration>("int MyProperty { private get {} protected internal set {} } ");
+			Assert.AreEqual("MyProperty", pd.Name);
+			Assert.IsNotNull(pd.GetAccessor);
+			Assert.IsNotNull(pd.SetAccessor);
+		}
+		
+		[Test]
+		public void SimpleGetPropertyDeclarationTest()
+		{
+			PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember<PropertyDeclaration>("int MyProperty { get {} } ");
+			Assert.AreEqual("MyProperty", pd.Name);
+			Assert.IsNotNull(pd.GetAccessor);
+			Assert.IsNull(pd.SetAccessor);
+		}
+		
+		[Test]
+		public void SimpleSetPropertyDeclarationTest()
+		{
+			PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember<PropertyDeclaration>("int MyProperty { set {} } ");
+			Assert.AreEqual("MyProperty", pd.Name);
+			Assert.IsNull(pd.GetAccessor);
+			Assert.IsNotNull(pd.SetAccessor);
+		}
+		
+		[Test]
+		public void PropertyRegionTest()
+		{
+			const string code = "class T {\n\tint Prop {\n\t\tget { return f; }\n\t\tset { f = value; }\n\t}\n}\n";
+			int line2Pos = code.IndexOf("\tint Prop");
+			int line3Pos = code.IndexOf("\t\tget");
+			int line4Pos = code.IndexOf("\t\tset");
+			
+			CSharpParser parser = new CSharpParser();
+			CompilationUnit cu = parser.Parse(new StringReader(code));
+			PropertyDeclaration pd = (PropertyDeclaration)cu.Children.Single().GetChildByRole(TypeDeclaration.Roles.Member);
+			Assert.AreEqual(new DomLocation(2, code.IndexOf("{\n\t\tget") - line2Pos + 1), pd.LBrace.StartLocation);
+			Assert.AreEqual(new DomLocation(5, 3), pd.EndLocation);
+			Assert.AreEqual(new DomLocation(3, code.IndexOf("{ return") - line3Pos + 1), pd.GetAccessor.Body.StartLocation);
+			Assert.AreEqual(new DomLocation(3, code.IndexOf("}\n\t\tset") + 1 - line3Pos + 1), pd.GetAccessor.Body.EndLocation);
+			Assert.AreEqual(new DomLocation(4, code.IndexOf("{ f =") - line4Pos + 1), pd.SetAccessor.Body.StartLocation);
+			Assert.AreEqual(new DomLocation(4, code.IndexOf("}\n\t}") + 1 - line4Pos + 1), pd.SetAccessor.Body.EndLocation);
+		}
+		
+		[Test]
+		public void PropertyImplementingInterfaceTest()
+		{
+			PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember<PropertyDeclaration>("int MyInterface.MyProperty { get {} } ");
+			Assert.AreEqual("MyProperty", pd.Name);
+			Assert.IsNotNull(pd.GetAccessor);
+			Assert.IsNull(pd.SetAccessor);
+			
+			Assert.AreEqual("MyInterface", pd.PrivateImplementationType);
+		}
+		
+		[Test, Ignore]
+		public void PropertyImplementingGenericInterfaceTest()
+		{
+			PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember<PropertyDeclaration>("int MyInterface<string>.MyProperty { get {} } ");
+			Assert.AreEqual("MyProperty", pd.Name);
+			Assert.IsNotNull(pd.GetAccessor);
+			Assert.IsNull(pd.SetAccessor);
+			
+			throw new NotImplementedException();
+			//Assert.AreEqual("MyInterface", pd.InterfaceImplementations[0].InterfaceType.Type);
+			//Assert.AreEqual("System.String", pd.InterfaceImplementations[0].InterfaceType.GenericTypes[0].Type);
+		}
+	}
+}

ICSharpCode.NRefactory.Tests/ICSharpCode.NRefactory.Tests.csproj

@@ -81,6 +81,14 @@
     <Compile Include="CSharp\Parser\Statements\VariableDeclarationStatementTests.cs" />
     <Compile Include="CSharp\Parser\Statements\WhileStatementTests.cs" />
     <Compile Include="CSharp\Parser\Statements\YieldStatementTests.cs" />
+    <Compile Include="CSharp\Parser\TypeMembers\ConstructorDeclarationTests.cs" />
+    <Compile Include="CSharp\Parser\TypeMembers\DestructorDeclarationTests.cs" />
+    <Compile Include="CSharp\Parser\TypeMembers\EventDeclarationTests.cs" />
+    <Compile Include="CSharp\Parser\TypeMembers\FieldDeclarationTests.cs" />
+    <Compile Include="CSharp\Parser\TypeMembers\IndexerDeclarationTests.cs" />
+    <Compile Include="CSharp\Parser\TypeMembers\MethodDeclarationTests.cs" />
+    <Compile Include="CSharp\Parser\TypeMembers\OperatorDeclarationTests.cs" />
+    <Compile Include="CSharp\Parser\TypeMembers\PropertyDeclarationTests.cs" />
     <Compile Include="CSharp\Parser\TypeSystemConvertVisitorTests.cs" />
     <Compile Include="CSharp\Parser\Expression\AliasReferenceExpressionTests.cs" />
     <Compile Include="CSharp\Parser\Expression\AnonymousMethodTests.cs" />
@@ -144,6 +152,7 @@
   <ItemGroup>
     <Folder Include="CSharp\Parser\Expression" />
     <Folder Include="CSharp\Parser\GeneralScope" />
+    <Folder Include="CSharp\Parser\TypeMembers" />
     <Folder Include="CSharp\Parser\Statements" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />

ICSharpCode.NRefactory/CSharp/Dom/DomLocation.cs

@@ -33,32 +33,28 @@ namespace ICSharpCode.NRefactory.CSharp
 	[Serializable]
 	public struct DomLocation : IComparable<DomLocation>, IEquatable<DomLocation>
 	{
+		public static readonly DomLocation Empty = new DomLocation(0, 0);
+		
+		readonly int line, column;
+		
+		public DomLocation (int line, int column)
+		{
+			this.line   = line;
+			this.column = column;
+		}
+		
 		public bool IsEmpty {
 			get {
-				return Line < 0;
+				return Line <= 0;
 			}
 		}
 		
 		public int Line {
-			get;
-			set;
-		}
-
-		public int Column {
-			get;
-			set;
+			get { return line; }
 		}
 		
-		public static DomLocation Empty {
-			get {
-				return new DomLocation (-1, -1);
-			}
-		}
-		
-		public DomLocation (int line, int column) : this ()
-		{
-			this.Line   = line;
-			this.Column = column;
+		public int Column {
+			get { return column; }
 		}
 		
 		public override bool Equals (object other)
@@ -71,7 +67,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		public override int GetHashCode ()
 		{
 			unchecked {
-				return Line + Column * 5000;
+				return line + column * 5000;
 			}
 		}
 		
@@ -91,12 +87,12 @@ namespace ICSharpCode.NRefactory.CSharp
 		
 		public override string ToString ()
 		{
-			return String.Format ("[DomLocation: Line={0}, Column={1}]", Line, Column);
+			return String.Format ("(Line {0}, Column {1})", Line, Column);
 		}
 
 		public static DomLocation FromInvariantString (string invariantString)
 		{
-			if (invariantString.ToUpper () == "EMPTY")
+			if (string.Equals(invariantString, "EMPTY", StringComparison.OrdinalIgnoreCase))
 				return DomLocation.Empty;
 			string[] splits = invariantString.Split (',', '/');
 			if (splits.Length == 2)
@@ -108,26 +104,26 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			if (IsEmpty)
 				return "Empty";
-			return String.Format ("{0}/{1}", Line, Column);
+			return String.Format ("{0}/{1}", line, column);
 		}
 		
 		public static bool operator==(DomLocation left, DomLocation right)
 		{
-			return left.Line == right.Line && left.Column == right.Column;
+			return left.line == right.line && left.column == right.column;
 		}
 		
 		public static bool operator!=(DomLocation left, DomLocation right)
 		{
-			return left.Line != right.Line || left.Column != right.Column;
+			return left.line != right.line || left.column != right.column;
 		}
 		
 		public static bool operator<(DomLocation left, DomLocation right)
 		{
-			return left.Line < right.Line || left.Line == right.Line && left.Column < right.Column;
+			return left.line < right.line || left.line == right.line && left.column < right.column;
 		}
 		public static bool operator>(DomLocation left, DomLocation right)
 		{
-			return left.Line > right.Line || left.Line == right.Line && left.Column > right.Column;
+			return left.line > right.line || left.line == right.line && left.column > right.column;
 		}
 		public static bool operator<=(DomLocation left, DomLocation right)
 		{

ICSharpCode.NRefactory/CSharp/Dom/INode.cs

@@ -40,6 +40,8 @@ namespace ICSharpCode.NRefactory.CSharp
 			get;
 		}
 		
+		INode GetChildByRole (int role);
+		
 		int Role {
 			get;
 			set;

ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/IndexerDeclaration.cs

@@ -33,6 +33,11 @@ namespace ICSharpCode.NRefactory.CSharp
 {
 	public class IndexerDeclaration : PropertyDeclaration
 	{
+		// TODO: Parameters or Arguments?
+		public IEnumerable<ParameterDeclaration> Parameters { 
+			get { return this.Arguments; }
+		}
+		
 		public IEnumerable<ParameterDeclaration> Arguments { 
 			get {
 				return base.GetChildrenByRole (Roles.Argument).Cast <ParameterDeclaration>();

ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/MethodDeclaration.cs

@@ -32,6 +32,11 @@ namespace ICSharpCode.NRefactory.CSharp
 {
 	public class MethodDeclaration : AbstractMember
 	{
+		// TODO: Parameters or Arguments?
+		public IEnumerable<INode> TypeParameters {
+			get { return this.TypeArguments; }
+		}
+		
 		public IEnumerable<INode> TypeArguments {
 			get { return GetChildrenByRole (Roles.TypeArgument).Cast<INode> (); }
 		}
@@ -42,12 +47,25 @@ namespace ICSharpCode.NRefactory.CSharp
 			}
 		}
 		
+		public IEnumerable<ParameterDeclaration> Parameters { 
+			get {
+				return this.Arguments;
+			}
+		}
+		
 		public IEnumerable<ParameterDeclaration> Arguments { 
 			get {
 				return base.GetChildrenByRole (Roles.Argument).Cast <ParameterDeclaration> ();
 			}
 		}
 		
+		public bool IsExtensionMethod {
+			get {
+				ParameterDeclaration pd = (ParameterDeclaration)GetChildByRole (Roles.Argument);
+				return pd != null && pd.ParameterModifier == ParameterModifier.This;
+			}
+		}
+		
 		public CSharpTokenNode LPar {
 			get { return (CSharpTokenNode)GetChildByRole (Roles.LPar); }
 		}

ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/OperatorDeclaration.cs

@@ -1,4 +1,4 @@
-// 
+// 
 // OperatorDeclaration.cs
 //  
 // Author:
@@ -75,11 +75,6 @@ namespace ICSharpCode.NRefactory.CSharp
 			set;
 		}
 		
-		public string OverloadOperator {
-			get;
-			set;
-		}
-		
 		public CSharpTokenNode OperatorKeyword {
 			get { return (CSharpTokenNode)GetChildByRole (OperatorKeywordRole); }
 		}

ICSharpCode.NRefactory/CSharp/Dom/TypeMembers/ParameterDeclarationExpression.cs

@@ -62,6 +62,10 @@ namespace ICSharpCode.NRefactory.CSharp
 			}
 		}
 		
+		public INode Type {
+			get { return GetChildByRole (Roles.ReturnType); }
+		}
+		
 		public override S AcceptVisitor<T, S> (IDomVisitor<T, S> visitor, T data)
 		{
 			return visitor.VisitParameterDeclaration (this, data);

ICSharpCode.NRefactory/CSharp/Parser/CSharpParser.cs

@@ -2292,7 +2292,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			}
 		}
 		
-		public List<INode> ParseTypeMembers(TextReader reader)
+		public List<AbstractMemberBase> ParseTypeMembers(TextReader reader)
 		{
 			// TODO: add support for type members
 			throw new NotImplementedException();