Browse Source

NRefactory.VB: removed C# Unit Tests

newNRvisualizers
Siegfried Pammer 16 years ago
parent
commit
27b9e7f071
  1. 2
      VB/Test/ICSharpCode.NRefactory.VB.Tests.csproj
  2. 4
      VB/Test/Lexer/LexerContextTests.cs
  3. 2
      VB/Test/Lexer/LexerTests.cs
  4. 4
      VB/Test/Lexer/XmlModeLexerTests.cs
  5. 74
      VB/Test/Parser/Expressions/BinaryOperatorExpressionTests.cs
  6. 4
      VB/Test/Parser/Expressions/ClassReferenceExpressionTests.cs
  7. 17
      VB/Test/Parser/Expressions/GlobalReferenceExpressionTests.cs
  8. 9
      VB/Test/Parser/Expressions/ObjectCreateExpressionTests.cs
  9. 93
      VB/Test/Parser/Expressions/QueryExpressionTests.cs
  10. 32
      VB/Test/Parser/Expressions/TypeOfIsExpressionTests.cs
  11. 2
      VB/Test/Parser/GlobalScope/OptionDeclarationTests.cs
  12. 16
      VB/Test/Parser/GlobalScope/UsingDeclarationTests.cs
  13. 4
      VB/Test/Parser/ParseUtilVBNet.cs
  14. 60
      VB/Test/Parser/SkipMethodBodiesTest.cs
  15. 28
      VB/Test/Parser/Statements/BlockStatementTests.cs
  16. 8
      VB/Test/Parser/Statements/BreakStatementTests.cs
  17. 19
      VB/Test/Parser/Statements/CheckedStatementTests.cs
  18. 8
      VB/Test/Parser/Statements/ContinueStatementTests.cs
  19. 22
      VB/Test/Parser/Statements/DoLoopStatementTests.cs
  20. 9
      VB/Test/Parser/Statements/EmptyStatementTests.cs
  21. 4
      VB/Test/Parser/Statements/EndStatementTests.cs
  22. 4
      VB/Test/Parser/Statements/EraseStatementTests.cs
  23. 4
      VB/Test/Parser/Statements/ErrorStatementTests.cs
  24. 15
      VB/Test/Parser/Statements/ExpressionStatementTests.cs
  25. 9
      VB/Test/Parser/Statements/FixedStatementTests.cs
  26. 4
      VB/Test/Parser/Statements/ForNextStatementTests.cs
  27. 20
      VB/Test/Parser/Statements/ForStatementTests.cs
  28. 9
      VB/Test/Parser/Statements/ForeachStatementTests.cs
  29. 17
      VB/Test/Parser/Statements/GotoCaseStatementTests.cs
  30. 9
      VB/Test/Parser/Statements/GotoStatementTests.cs
  31. 43
      VB/Test/Parser/Statements/IfElseStatementTests.cs
  32. 15
      VB/Test/Parser/Statements/LabelStatementTests.cs
  33. 216
      VB/Test/Parser/Statements/LocalVariableDeclarationTests.cs
  34. 9
      VB/Test/Parser/Statements/LockStatementTests.cs
  35. 4
      VB/Test/Parser/Statements/OnErrorStatementTest.cs
  36. 4
      VB/Test/Parser/Statements/RaiseEventStatementTest.cs
  37. 4
      VB/Test/Parser/Statements/RemoveHandlerStatement.cs
  38. 4
      VB/Test/Parser/Statements/ResumeStatement.cs
  39. 24
      VB/Test/Parser/Statements/ReturnStatementTests.cs
  40. 4
      VB/Test/Parser/Statements/StopStatementTests.cs
  41. 10
      VB/Test/Parser/Statements/SwitchStatementTests.cs
  42. 16
      VB/Test/Parser/Statements/ThrowStatementTests.cs
  43. 34
      VB/Test/Parser/Statements/TryCatchStatementTests.cs
  44. 20
      VB/Test/Parser/Statements/UncheckedStatementTests.cs
  45. 9
      VB/Test/Parser/Statements/UnsafeStatementTests.cs
  46. 9
      VB/Test/Parser/Statements/UsingStatementTests.cs
  47. 4
      VB/Test/Parser/Statements/WithStatementTests.cs
  48. 45
      VB/Test/Parser/Statements/YieldStatementTests.cs
  49. 41
      VB/Test/Parser/TypeLevel/ConstructorDeclarationTests.cs
  50. 4
      VB/Test/Parser/TypeLevel/DeclareDeclarationTests.cs
  51. 22
      VB/Test/Parser/TypeLevel/DestructorDeclarationTests.cs
  52. 72
      VB/Test/Parser/TypeLevel/EventDeclarationTests.cs
  53. 13
      VB/Test/Parser/TypeLevel/FieldDeclarationTests.cs
  54. 37
      VB/Test/Parser/TypeLevel/IndexerDeclarationTests.cs
  55. 289
      VB/Test/Parser/TypeLevel/MethodDeclarationTests.cs
  56. 44
      VB/Test/Parser/TypeLevel/OperatorDeclarationTests.cs
  57. 92
      VB/Test/Parser/TypeLevel/PropertyDeclarationTests.cs

2
VB/Test/ICSharpCode.NRefactory.VB.Tests.csproj

@ -151,8 +151,6 @@ @@ -151,8 +151,6 @@
<Compile Include="Parser\Statements\WithStatementTests.cs" />
<Compile Include="Output\CodeDOM\CodeDOMPrimitiveExpressionTest.cs" />
<Compile Include="Output\CodeDOM\CodeDOMParenthesizedExpressionTest.cs" />
<Compile Include="Parser\Statements\YieldStatementTests.cs" />
<Compile Include="Parser\SkipMethodBodiesTest.cs" />
<Compile Include="Parser\Expressions\AnonymousMethodTests.cs" />
<Compile Include="Output\CodeDOM\InvocationExpressionTest.cs" />
<Compile Include="Parser\Expressions\TypeReferenceExpressionTests.cs" />

4
VB/Test/Lexer/LexerContextTests.cs

@ -4,7 +4,7 @@ @@ -4,7 +4,7 @@
using System;
using System.IO;
using NUnit.Framework;
using VBParser = ICSharpCode.NRefactory.VB.Parser;
using ICSharpCode.NRefactory.VB.Parser;
namespace ICSharpCode.NRefactory.VB.Tests.Lexer
{
@ -560,7 +560,7 @@ exit Global @@ -560,7 +560,7 @@ exit Global
do {
t = lexer.NextToken();
p.InformToken(t);
} while (t.Kind != VBParser.Tokens.EOF);
} while (t.Kind != Tokens.EOF);
Console.WriteLine(p.Output);

2
VB/Test/Lexer/LexerTests.cs

@ -5,7 +5,7 @@ using NUnit.Framework; @@ -5,7 +5,7 @@ using NUnit.Framework;
using ICSharpCode.NRefactory.VB.Parser;
using ICSharpCode.NRefactory.VB.PrettyPrinter;
namespace ICSharpCode.NRefactory.VB.Tests.Lexer
namespace ICSharpCode.NRefactory.Tests.VB.Lexer
{
[TestFixture]
public sealed class LexerTests

4
VB/Test/Lexer/XmlModeLexerTests.cs

@ -948,12 +948,12 @@ End Using"; @@ -948,12 +948,12 @@ End Using";
#region Helpers
ILexer GenerateLexer(StringReader sr)
{
return ParserFactory.CreateLexer(SupportedLanguage.VBNet, sr);
return ParserFactory.CreateLexer(sr);
}
ILexer GenerateLexerForSnippet(StringReader sr, SnippetType type)
{
var lexer = ParserFactory.CreateLexer(SupportedLanguage.VBNet, sr);
var lexer = ParserFactory.CreateLexer(sr);
lexer.SetInitialContext(type);
return lexer;
}

74
VB/Test/Parser/Expressions/BinaryOperatorExpressionTests.cs

@ -14,14 +14,11 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -14,14 +14,11 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
public class BinaryOperatorExpressionTests
{
void OperatorPrecedenceTest(string strongOperator, BinaryOperatorType strongOperatorType,
string weakOperator, BinaryOperatorType weakOperatorType, bool vb)
string weakOperator, BinaryOperatorType weakOperatorType)
{
string program = "a " + weakOperator + " b " + strongOperator + " c";
BinaryOperatorExpression boe;
if (vb)
boe = ParseUtilVBNet.ParseExpression<BinaryOperatorExpression>(program);
else
boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>(program);
boe = ParseUtilVBNet.ParseExpression<BinaryOperatorExpression>(program);
Assert.AreEqual(weakOperatorType, boe.Op);
Assert.IsTrue(boe.Left is IdentifierExpression);
boe = (BinaryOperatorExpression)boe.Right;
@ -30,10 +27,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -30,10 +27,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
Assert.IsTrue(boe.Right is IdentifierExpression);
program = "a " + strongOperator + " b " + weakOperator + " c";
if (vb)
boe = ParseUtilVBNet.ParseExpression<BinaryOperatorExpression>(program);
else
boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>(program);
boe = ParseUtilVBNet.ParseExpression<BinaryOperatorExpression>(program);
Assert.AreEqual(weakOperatorType, boe.Op);
Assert.IsTrue(boe.Right is IdentifierExpression);
boe = (BinaryOperatorExpression)boe.Left;
@ -43,14 +37,11 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -43,14 +37,11 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
}
void SameOperatorPrecedenceTest(string firstOperator, BinaryOperatorType firstOperatorType,
string secondOperator, BinaryOperatorType secondOperatorType, bool vb)
string secondOperator, BinaryOperatorType secondOperatorType)
{
string program = "a " + secondOperator + " b " + firstOperator + " c";
BinaryOperatorExpression boe;
if (vb)
boe = ParseUtilVBNet.ParseExpression<BinaryOperatorExpression>(program);
else
boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>(program);
boe = ParseUtilVBNet.ParseExpression<BinaryOperatorExpression>(program);
Assert.AreEqual(firstOperatorType, boe.Op);
Assert.IsTrue(boe.Right is IdentifierExpression);
boe = (BinaryOperatorExpression)boe.Left;
@ -59,10 +50,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -59,10 +50,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
Assert.IsTrue(boe.Right is IdentifierExpression);
program = "a " + firstOperator + " b " + secondOperator + " c";
if (vb)
boe = ParseUtilVBNet.ParseExpression<BinaryOperatorExpression>(program);
else
boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>(program);
boe = ParseUtilVBNet.ParseExpression<BinaryOperatorExpression>(program);
Assert.AreEqual(secondOperatorType, boe.Op);
Assert.IsTrue(boe.Right is IdentifierExpression);
boe = (BinaryOperatorExpression)boe.Left;
@ -84,29 +72,29 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -84,29 +72,29 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[Test]
public void VBOperatorPrecedenceTest()
{
OperatorPrecedenceTest("^", BinaryOperatorType.Power, "*", BinaryOperatorType.Multiply, true);
SameOperatorPrecedenceTest("*", BinaryOperatorType.Multiply, "/", BinaryOperatorType.Divide, true);
OperatorPrecedenceTest("/", BinaryOperatorType.Divide, "\\", BinaryOperatorType.DivideInteger, true);
OperatorPrecedenceTest("\\", BinaryOperatorType.DivideInteger, "Mod", BinaryOperatorType.Modulus, true);
OperatorPrecedenceTest("Mod", BinaryOperatorType.Modulus, "+", BinaryOperatorType.Add, true);
SameOperatorPrecedenceTest("+", BinaryOperatorType.Add, "-", BinaryOperatorType.Subtract, true);
OperatorPrecedenceTest("-", BinaryOperatorType.Subtract, "&", BinaryOperatorType.Concat, true);
OperatorPrecedenceTest("&", BinaryOperatorType.Concat, "<<", BinaryOperatorType.ShiftLeft, true);
SameOperatorPrecedenceTest("<<", BinaryOperatorType.ShiftLeft, ">>", BinaryOperatorType.ShiftRight, true);
OperatorPrecedenceTest("<<", BinaryOperatorType.ShiftLeft, "=", BinaryOperatorType.Equality, true);
SameOperatorPrecedenceTest("<>", BinaryOperatorType.InEquality, "=", BinaryOperatorType.Equality, true);
SameOperatorPrecedenceTest("<", BinaryOperatorType.LessThan, "=", BinaryOperatorType.Equality, true);
SameOperatorPrecedenceTest("<=", BinaryOperatorType.LessThanOrEqual, "=", BinaryOperatorType.Equality, true);
SameOperatorPrecedenceTest(">", BinaryOperatorType.GreaterThan, "=", BinaryOperatorType.Equality, true);
SameOperatorPrecedenceTest(">=", BinaryOperatorType.GreaterThanOrEqual, "=", BinaryOperatorType.Equality, true);
SameOperatorPrecedenceTest("Like", BinaryOperatorType.Like, "=", BinaryOperatorType.Equality, true);
SameOperatorPrecedenceTest("Is", BinaryOperatorType.ReferenceEquality, "=", BinaryOperatorType.Equality, true);
SameOperatorPrecedenceTest("IsNot", BinaryOperatorType.ReferenceInequality, "=", BinaryOperatorType.Equality, true);
OperatorPrecedenceTest("=", BinaryOperatorType.Equality, "And", BinaryOperatorType.BitwiseAnd, true);
SameOperatorPrecedenceTest("And", BinaryOperatorType.BitwiseAnd, "AndAlso", BinaryOperatorType.LogicalAnd, true);
OperatorPrecedenceTest("And", BinaryOperatorType.BitwiseAnd, "Or", BinaryOperatorType.BitwiseOr, true);
SameOperatorPrecedenceTest("Or", BinaryOperatorType.BitwiseOr, "OrElse", BinaryOperatorType.LogicalOr, true);
SameOperatorPrecedenceTest("Or", BinaryOperatorType.BitwiseOr, "Xor", BinaryOperatorType.ExclusiveOr, true);
OperatorPrecedenceTest("^", BinaryOperatorType.Power, "*", BinaryOperatorType.Multiply);
SameOperatorPrecedenceTest("*", BinaryOperatorType.Multiply, "/", BinaryOperatorType.Divide);
OperatorPrecedenceTest("/", BinaryOperatorType.Divide, "\\", BinaryOperatorType.DivideInteger);
OperatorPrecedenceTest("\\", BinaryOperatorType.DivideInteger, "Mod", BinaryOperatorType.Modulus);
OperatorPrecedenceTest("Mod", BinaryOperatorType.Modulus, "+", BinaryOperatorType.Add);
SameOperatorPrecedenceTest("+", BinaryOperatorType.Add, "-", BinaryOperatorType.Subtract);
OperatorPrecedenceTest("-", BinaryOperatorType.Subtract, "&", BinaryOperatorType.Concat);
OperatorPrecedenceTest("&", BinaryOperatorType.Concat, "<<", BinaryOperatorType.ShiftLeft);
SameOperatorPrecedenceTest("<<", BinaryOperatorType.ShiftLeft, ">>", BinaryOperatorType.ShiftRight);
OperatorPrecedenceTest("<<", BinaryOperatorType.ShiftLeft, "=", BinaryOperatorType.Equality);
SameOperatorPrecedenceTest("<>", BinaryOperatorType.InEquality, "=", BinaryOperatorType.Equality);
SameOperatorPrecedenceTest("<", BinaryOperatorType.LessThan, "=", BinaryOperatorType.Equality);
SameOperatorPrecedenceTest("<=", BinaryOperatorType.LessThanOrEqual, "=", BinaryOperatorType.Equality);
SameOperatorPrecedenceTest(">", BinaryOperatorType.GreaterThan, "=", BinaryOperatorType.Equality);
SameOperatorPrecedenceTest(">=", BinaryOperatorType.GreaterThanOrEqual, "=", BinaryOperatorType.Equality);
SameOperatorPrecedenceTest("Like", BinaryOperatorType.Like, "=", BinaryOperatorType.Equality);
SameOperatorPrecedenceTest("Is", BinaryOperatorType.ReferenceEquality, "=", BinaryOperatorType.Equality);
SameOperatorPrecedenceTest("IsNot", BinaryOperatorType.ReferenceInequality, "=", BinaryOperatorType.Equality);
OperatorPrecedenceTest("=", BinaryOperatorType.Equality, "And", BinaryOperatorType.BitwiseAnd);
SameOperatorPrecedenceTest("And", BinaryOperatorType.BitwiseAnd, "AndAlso", BinaryOperatorType.LogicalAnd);
OperatorPrecedenceTest("And", BinaryOperatorType.BitwiseAnd, "Or", BinaryOperatorType.BitwiseOr);
SameOperatorPrecedenceTest("Or", BinaryOperatorType.BitwiseOr, "OrElse", BinaryOperatorType.LogicalOr);
SameOperatorPrecedenceTest("Or", BinaryOperatorType.BitwiseOr, "Xor", BinaryOperatorType.ExclusiveOr);
}
[Test]
@ -285,9 +273,9 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -285,9 +273,9 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
string AddInteger<T>(string input, int number) where T : Expression
{
Expression e = ParseUtilCSharp.ParseExpression<T>(input);
Expression e = ParseUtilVBNet.ParseExpression<T>(input);
e = Expression.AddInteger(e, number);
CSharpOutputVisitor v = new CSharpOutputVisitor();
VBNetOutputVisitor v = new VBNetOutputVisitor();
e.AcceptVisitor(v, null);
return v.Text;
}

4
VB/Test/Parser/Expressions/ClassReferenceExpressionTests.cs

@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class ClassReferenceExpressionTests
{
#region C#
// No C# representation
#endregion
#region VB.NET
[Test]
public void VBNetClassReferenceExpressionTest1()

17
VB/Test/Parser/Expressions/GlobalReferenceExpressionTests.cs

@ -12,14 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,14 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class GlobalReferenceExpressionTests
{
[Test]
public void CSharpGlobalReferenceExpressionTest()
{
TypeReferenceExpression tre = ParseUtilCSharp.ParseExpression<TypeReferenceExpression>("global::System");
Assert.IsTrue(tre.TypeReference.IsGlobal);
Assert.AreEqual("System", tre.TypeReference.Type);
}
[Test]
public void VBNetGlobalReferenceExpressionTest()
{
@ -28,15 +20,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -28,15 +20,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
Assert.AreEqual("System", tre.TypeReference.Type);
}
[Test]
public void CSharpGlobalTypeDeclaration()
{
LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement<LocalVariableDeclaration>("global::System.String a;");
TypeReference typeRef = lvd.GetTypeForVariable(0);
Assert.IsTrue(typeRef.IsGlobal);
Assert.AreEqual("System.String", typeRef.Type);
}
[Test]
public void VBNetGlobalTypeDeclaration()
{

9
VB/Test/Parser/Expressions/ObjectCreateExpressionTests.cs

@ -23,7 +23,12 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -23,7 +23,12 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
}
}
#region VB.NET
Expression CheckPropertyInitializationExpression(Expression e, string name)
{
Assert.IsInstanceOf(typeof(MemberInitializerExpression), e);
Assert.AreEqual(name, ((MemberInitializerExpression)e).Name);
return ((MemberInitializerExpression)e).Expression;
}
[Test]
public void VBNetAnonymousType()
@ -105,7 +110,5 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -105,7 +110,5 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
Assert.AreEqual(1, oce.CreateType.GenericTypes.Count);
Assert.AreEqual("System.Int32", oce.CreateType.GenericTypes[0].Type);
}
#endregion
}
}

93
VB/Test/Parser/Expressions/QueryExpressionTests.cs

@ -14,98 +14,5 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -14,98 +14,5 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class QueryExpressionTests
{
[Test]
public void SimpleExpression()
{
QueryExpression qe = ParseUtilCSharp.ParseExpression<QueryExpression>(
"from c in customers where c.City == \"London\" select c"
);
Assert.AreEqual("c", qe.FromClause.Sources.First().Identifier);
Assert.AreEqual("customers", ((IdentifierExpression)qe.FromClause.Sources.First().Expression).Identifier);
Assert.AreEqual(1, qe.MiddleClauses.Count);
Assert.IsInstanceOf(typeof(QueryExpressionWhereClause), qe.MiddleClauses[0]);
QueryExpressionWhereClause wc = (QueryExpressionWhereClause)qe.MiddleClauses[0];
Assert.IsInstanceOf(typeof(BinaryOperatorExpression), wc.Condition);
Assert.IsInstanceOf(typeof(QueryExpressionSelectClause), qe.SelectOrGroupClause);
}
[Test]
public void ExpressionWithType1()
{
QueryExpression qe = ParseUtilCSharp.ParseExpression<QueryExpression>(
"from Customer c in customers select c"
);
Assert.AreEqual("c", qe.FromClause.Sources.First().Identifier);
Assert.AreEqual("Customer", qe.FromClause.Sources.First().Type.ToString());
Assert.AreEqual("customers", ((IdentifierExpression)qe.FromClause.Sources.First().Expression).Identifier);
Assert.IsInstanceOf(typeof(QueryExpressionSelectClause), qe.SelectOrGroupClause);
}
[Test]
public void ExpressionWithType2()
{
QueryExpression qe = ParseUtilCSharp.ParseExpression<QueryExpression>(
"from int c in customers select c"
);
Assert.AreEqual("c", qe.FromClause.Sources.First().Identifier);
Assert.AreEqual("System.Int32", qe.FromClause.Sources.First().Type.Type);
Assert.AreEqual("customers", ((IdentifierExpression)qe.FromClause.Sources.First().Expression).Identifier);
Assert.IsInstanceOf(typeof(QueryExpressionSelectClause), qe.SelectOrGroupClause);
}
[Test]
public void ExpressionWithType3()
{
QueryExpression qe = ParseUtilCSharp.ParseExpression<QueryExpression>(
"from S<int[]>? c in customers select c"
);
Assert.AreEqual("c", qe.FromClause.Sources.First().Identifier);
Assert.AreEqual("System.Nullable<S<System.Int32[]>>", qe.FromClause.Sources.First().Type.ToString());
Assert.AreEqual("customers", ((IdentifierExpression)qe.FromClause.Sources.First().Expression).Identifier);
Assert.IsInstanceOf(typeof(QueryExpressionSelectClause), qe.SelectOrGroupClause);
}
[Test]
public void MultipleGenerators()
{
QueryExpression qe = ParseUtilCSharp.ParseExpression<QueryExpression>(@"
from c in customers
where c.City == ""London""
from o in c.Orders
where o.OrderDate.Year == 2005
select new { c.Name, o.OrderID, o.Total }");
Assert.AreEqual(3, qe.MiddleClauses.Count);
Assert.IsInstanceOf(typeof(QueryExpressionWhereClause), qe.MiddleClauses[0]);
Assert.IsInstanceOf(typeof(QueryExpressionFromClause), qe.MiddleClauses[1]);
Assert.IsInstanceOf(typeof(QueryExpressionWhereClause), qe.MiddleClauses[2]);
Assert.IsInstanceOf(typeof(QueryExpressionSelectClause), qe.SelectOrGroupClause);
}
[Test]
public void ExpressionWithOrderBy()
{
QueryExpression qe = ParseUtilCSharp.ParseExpression<QueryExpression>(
"from c in customers orderby c.Name select c"
);
Assert.AreEqual("c", qe.FromClause.Sources.First().Identifier);
Assert.AreEqual("customers", ((IdentifierExpression)qe.FromClause.Sources.First().Expression).Identifier);
Assert.IsInstanceOf(typeof(QueryExpressionOrderClause), qe.MiddleClauses[0]);
Assert.IsInstanceOf(typeof(QueryExpressionSelectClause), qe.SelectOrGroupClause);
}
[Test]
public void ExpressionWithOrderByAndLet()
{
QueryExpression qe = ParseUtilCSharp.ParseExpression<QueryExpression>(
"from c in customers orderby c.Name let x = c select x"
);
Assert.AreEqual("c", qe.FromClause.Sources.First().Identifier);
Assert.AreEqual("customers", ((IdentifierExpression)qe.FromClause.Sources.First().Expression).Identifier);
Assert.IsInstanceOf(typeof(QueryExpressionOrderClause), qe.MiddleClauses[0]);
Assert.IsInstanceOf(typeof(QueryExpressionLetClause), qe.MiddleClauses[1]);
Assert.IsInstanceOf(typeof(QueryExpressionSelectClause), qe.SelectOrGroupClause);
}
}
}

32
VB/Test/Parser/Expressions/TypeOfIsExpressionTests.cs

@ -12,38 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,38 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class TypeOfIsExpressionTests
{
#region C#
[Test]
public void GenericArrayIsExpression()
{
TypeOfIsExpression ce = ParseUtilCSharp.ParseExpression<TypeOfIsExpression>("o is List<string>[]");
Assert.AreEqual("List", ce.TypeReference.Type);
Assert.AreEqual("System.String", ce.TypeReference.GenericTypes[0].Type);
Assert.AreEqual(new int[] { 0 }, ce.TypeReference.RankSpecifier);
Assert.IsTrue(ce.Expression is IdentifierExpression);
}
[Test]
public void NullableIsExpression()
{
TypeOfIsExpression ce = ParseUtilCSharp.ParseExpression<TypeOfIsExpression>("o is int?");
Assert.AreEqual("System.Nullable", ce.TypeReference.Type);
Assert.AreEqual("System.Int32", ce.TypeReference.GenericTypes[0].Type);
Assert.IsTrue(ce.Expression is IdentifierExpression);
}
[Test]
public void NullableIsExpressionInBinaryOperatorExpression()
{
BinaryOperatorExpression boe;
boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>("o is int? == true");
TypeOfIsExpression ce = (TypeOfIsExpression)boe.Left;
Assert.AreEqual("System.Nullable", ce.TypeReference.Type);
Assert.AreEqual("System.Int32", ce.TypeReference.GenericTypes[0].Type);
Assert.IsTrue(ce.Expression is IdentifierExpression);
}
#endregion
#region VB.NET
[Test]
public void VBNetSimpleTypeOfIsExpression()

2
VB/Test/Parser/GlobalScope/OptionDeclarationTests.cs

@ -79,7 +79,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -79,7 +79,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
public void VBNetInvalidOptionDeclarationTest()
{
string program = "Option\n";
IParser parser = ParserFactory.CreateParser(SupportedLanguage.VBNet, new StringReader(program));
IParser parser = ParserFactory.CreateParser(new StringReader(program));
parser.Parse();
Assert.IsFalse(parser.Errors.ErrorOutput.Length == 0, "Expected errors, but operation completed successfully");
}

16
VB/Test/Parser/GlobalScope/UsingDeclarationTests.cs

@ -61,7 +61,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -61,7 +61,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
public void VBNetWrongUsingTest()
{
string program = "Imports\n";
IParser parser = ParserFactory.CreateParser(SupportedLanguage.VBNet, new StringReader(program));
IParser parser = ParserFactory.CreateParser(new StringReader(program));
parser.Parse();
Assert.IsTrue(parser.Errors.Count > 0);
UsingDeclaration u = (UsingDeclaration)parser.CompilationUnit.Children[0];
@ -74,7 +74,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -74,7 +74,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
public void VBNetWrongUsing2Test()
{
string program = "Imports ,\n";
IParser parser = ParserFactory.CreateParser(SupportedLanguage.VBNet, new StringReader(program));
IParser parser = ParserFactory.CreateParser(new StringReader(program));
parser.Parse();
Assert.IsTrue(parser.Errors.Count > 0);
UsingDeclaration u = (UsingDeclaration)parser.CompilationUnit.Children[0];
@ -88,7 +88,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -88,7 +88,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
{
string program = "Imports System\n" +
"Imports My.Name.Space\n";
IParser parser = ParserFactory.CreateParser(SupportedLanguage.VBNet, new StringReader(program));
IParser parser = ParserFactory.CreateParser(new StringReader(program));
parser.Parse();
Assert.AreEqual("", parser.Errors.ErrorOutput);
@ -101,7 +101,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -101,7 +101,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
string program = "Imports TESTME=System\n" +
"Imports myAlias=My.Name.Space\n" +
"Imports StringCollection = System.Collections.Generic.List(Of string)\n";
IParser parser = ParserFactory.CreateParser(SupportedLanguage.VBNet, new StringReader(program));
IParser parser = ParserFactory.CreateParser(new StringReader(program));
parser.Parse();
Assert.AreEqual("", parser.Errors.ErrorOutput);
@ -112,7 +112,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -112,7 +112,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
public void VBNetComplexUsingAliasDeclarationTest()
{
string program = "Imports NS1, AL=NS2, NS3, AL2=NS4, NS5\n";
IParser parser = ParserFactory.CreateParser(SupportedLanguage.VBNet, new StringReader(program));
IParser parser = ParserFactory.CreateParser(new StringReader(program));
parser.Parse();
Assert.AreEqual("", parser.Errors.ErrorOutput);
@ -123,7 +123,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -123,7 +123,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
public void VBNetXmlNamespaceUsingTest()
{
string program = "Imports <xmlns=\"http://icsharpcode.net/sharpdevelop/avalonedit\">";
IParser parser = ParserFactory.CreateParser(SupportedLanguage.VBNet, new StringReader(program));
IParser parser = ParserFactory.CreateParser(new StringReader(program));
parser.Parse();
Assert.AreEqual("", parser.Errors.ErrorOutput);
@ -144,7 +144,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -144,7 +144,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
public void VBNetXmlNamespaceWithPrefixUsingTest()
{
string program = "Imports <xmlns:avalonedit=\"http://icsharpcode.net/sharpdevelop/avalonedit\">";
IParser parser = ParserFactory.CreateParser(SupportedLanguage.VBNet, new StringReader(program));
IParser parser = ParserFactory.CreateParser(new StringReader(program));
parser.Parse();
Assert.AreEqual("", parser.Errors.ErrorOutput);
@ -165,7 +165,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -165,7 +165,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
public void VBNetXmlNamespaceSingleQuotedUsingTest()
{
string program = "Imports <xmlns='http://icsharpcode.net/sharpdevelop/avalonedit'>";
IParser parser = ParserFactory.CreateParser(SupportedLanguage.VBNet, new StringReader(program));
IParser parser = ParserFactory.CreateParser(new StringReader(program));
parser.Parse();
Assert.AreEqual("", parser.Errors.ErrorOutput);

4
VB/Test/Parser/ParseUtilVBNet.cs

@ -18,7 +18,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -18,7 +18,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
public static T ParseGlobal<T>(string program, bool expectErrors) where T : INode
{
IParser parser = ParserFactory.CreateParser(SupportedLanguage.VBNet, new StringReader(program));
IParser parser = ParserFactory.CreateParser(new StringReader(program));
parser.Parse();
if (expectErrors)
@ -76,7 +76,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -76,7 +76,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
public static T ParseExpression<T>(string expr, bool expectErrors) where T : INode
{
IParser parser = ParserFactory.CreateParser(SupportedLanguage.VBNet, new StringReader(expr));
IParser parser = ParserFactory.CreateParser(new StringReader(expr));
INode parsedExpression = parser.ParseExpression();
if (expectErrors)
Assert.IsFalse(parser.Errors.ErrorOutput.Length == 0, "Expected errors, but operation completed successfully");

60
VB/Test/Parser/SkipMethodBodiesTest.cs

@ -1,60 +0,0 @@ @@ -1,60 +0,0 @@
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
using System;
using ICSharpCode.NRefactory.VB.Dom;
using NUnit.Framework;
namespace ICSharpCode.NRefactory.VB.Tests.Dom
{
[TestFixture]
public class SkipMethodBodiesTest
{
[Test]
public void EmptyMethods()
{
string txt = @"internal sealed class Lexer : AbstractLexer
{
public Lexer(TextReader reader) : base(reader)
{
}
void Method()
{
}
}";
Check(ParseUtilCSharp.ParseGlobal<TypeDeclaration>(txt, false, true));
}
[Test]
public void NonEmptyMethods()
{
string txt = @"internal sealed class Lexer : AbstractLexer
{
public Lexer(TextReader reader) : base(reader)
{
if (reader == null) {
throw new ArgumentNullException(""reader"");
}
}
void Method()
{
while(something) {
if (anything)
break;
}
}
}";
Check(ParseUtilCSharp.ParseGlobal<TypeDeclaration>(txt, false, true));
}
void Check(TypeDeclaration td)
{
Assert.AreEqual("Lexer", td.Name);
Assert.AreEqual(2, td.Children.Count);
Assert.AreEqual(0, ((ConstructorDeclaration)td.Children[0]).Body.Children.Count);
Assert.AreEqual(0, ((MethodDeclaration)td.Children[1]).Body.Children.Count);
}
}
}

28
VB/Test/Parser/Statements/BlockStatementTests.cs

@ -12,34 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,34 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class BlockStatementTests
{
#region C#
[Test]
public void CSharpBlockStatementTest()
{
BlockStatement blockStmt = ParseUtilCSharp.ParseStatement<BlockStatement>("{}");
}
[Test]
public void CSharpComplexBlockStatementPositionTest()
{
string code = @"{
WebClient wc = new WebClient();
wc.Test();
wc.UploadStringCompleted += delegate {
output.BeginInvoke((MethodInvoker)delegate {
output.Text += newText;
});
};
}";
BlockStatement blockStmt = ParseUtilCSharp.ParseStatement<BlockStatement>(code);
//Assert.AreEqual(1, blockStmt.StartLocation.Column); // does not work because ParseStatement inserts special code
Assert.AreEqual(1, blockStmt.StartLocation.Line);
Assert.AreEqual(2, blockStmt.EndLocation.Column);
Assert.AreEqual(9, blockStmt.EndLocation.Line);
}
#endregion
#region VB.NET
// TODO
#endregion

8
VB/Test/Parser/Statements/BreakStatementTests.cs

@ -12,14 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,14 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class BreakStatementTests
{
#region C#
[Test]
public void CSharpBreakStatementTest()
{
BreakStatement breakStmt = ParseUtilCSharp.ParseStatement<BreakStatement>("break;");
}
#endregion
#region VB.NET
// No VB.NET representation
#endregion

19
VB/Test/Parser/Statements/CheckedStatementTests.cs

@ -12,25 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,25 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class CheckedStatementTests
{
#region C#
[Test]
public void CSharpCheckedStatementTest()
{
CheckedStatement checkedStatement = ParseUtilCSharp.ParseStatement<CheckedStatement>("checked { }");
Assert.IsFalse(checkedStatement.Block.IsNull);
}
[Test]
public void CSharpCheckedStatementAndExpressionTest()
{
CheckedStatement checkedStatement = ParseUtilCSharp.ParseStatement<CheckedStatement>("checked { checked(++i); }");
Assert.IsFalse(checkedStatement.Block.IsNull);
ExpressionStatement es = (ExpressionStatement)checkedStatement.Block.Children[0];
CheckedExpression ce = (CheckedExpression)es.Expression;
Assert.IsInstanceOf<UnaryOperatorExpression>(ce.Expression);
}
#endregion
#region VB.NET
// No VB.NET representation
#endregion

8
VB/Test/Parser/Statements/ContinueStatementTests.cs

@ -12,14 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,14 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class ContinueStatementTests
{
#region C#
[Test]
public void CSharpContinueStatementTest()
{
ContinueStatement continueStmt = ParseUtilCSharp.ParseStatement<ContinueStatement>("continue;");
}
#endregion
#region VB.NET
// No VB.NET representation
#endregion

22
VB/Test/Parser/Statements/DoLoopStatementTests.cs

@ -12,28 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,28 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class DoLoopStatementTests
{
#region C#
[Test]
public void CSharpWhileStatementTest()
{
DoLoopStatement doLoopStmt = ParseUtilCSharp.ParseStatement<DoLoopStatement>("while (true) { }");
Assert.AreEqual(ConditionPosition.Start, doLoopStmt.ConditionPosition);
Assert.AreEqual(ConditionType.While, doLoopStmt.ConditionType);
Assert.IsTrue(doLoopStmt.Condition is PrimitiveExpression);
Assert.IsTrue(doLoopStmt.EmbeddedStatement is BlockStatement);
}
[Test]
public void CSharpDoWhileStatementTest()
{
DoLoopStatement doLoopStmt = ParseUtilCSharp.ParseStatement<DoLoopStatement>("do { } while (true);");
Assert.AreEqual(ConditionPosition.End, doLoopStmt.ConditionPosition);
Assert.AreEqual(ConditionType.While, doLoopStmt.ConditionType);
Assert.IsTrue(doLoopStmt.Condition is PrimitiveExpression);
Assert.IsTrue(doLoopStmt.EmbeddedStatement is BlockStatement);
}
#endregion
#region VB.NET
// TODO
#endregion

9
VB/Test/Parser/Statements/EmptyStatementTests.cs

@ -12,17 +12,8 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,17 +12,8 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class EmptyStatementTests
{
#region C#
[Test]
public void CSharpEmptyStatementTest()
{
EmptyStatement emptyStmt = ParseUtilCSharp.ParseStatement<EmptyStatement>(";");
}
#endregion
#region VB.NET
// No VB.NET representation
#endregion
}
}

4
VB/Test/Parser/Statements/EndStatementTests.cs

@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class EndStatementTests
{
#region C#
// No C# representation
#endregion
#region VB.NET
[Test]
public void VBNetEndStatementTest()

4
VB/Test/Parser/Statements/EraseStatementTests.cs

@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class EraseStatementTests
{
#region C#
// No C# representation
#endregion
#region VB.NET
[Test]
public void VBNetEraseStatementTest()

4
VB/Test/Parser/Statements/ErrorStatementTests.cs

@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class ErrorStatementTests
{
#region C#
// No C# representation
#endregion
#region VB.NET
[Test]
public void VBNetErrorStatementTest()

15
VB/Test/Parser/Statements/ExpressionStatementTests.cs

@ -12,21 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,21 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class ExpressionStatementTests
{
#region C#
[Test]
public void CSharpStatementExpressionTest()
{
ExpressionStatement stmtExprStmt = ParseUtilCSharp.ParseStatement<ExpressionStatement>("my.Obj.PropCall;");
Assert.IsTrue(stmtExprStmt.Expression is MemberReferenceExpression);
}
[Test]
public void CSharpStatementExpressionTest1()
{
ExpressionStatement stmtExprStmt = ParseUtilCSharp.ParseStatement<ExpressionStatement>("yield.yield;");
Assert.IsTrue(stmtExprStmt.Expression is MemberReferenceExpression);
}
#endregion
#region VB.NET
// TODO
#endregion

9
VB/Test/Parser/Statements/FixedStatementTests.cs

@ -12,15 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,15 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class FixedStatementTests
{
#region C#
[Test]
public void CSharpFixedStatementTest()
{
FixedStatement fixedStmt = ParseUtilCSharp.ParseStatement<FixedStatement>("fixed (int* ptr = &myIntArr) { }");
// TODO : Extend test.
}
#endregion
#region VB.NET
// No VB.NET representation
#endregion

4
VB/Test/Parser/Statements/ForNextStatementTests.cs

@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class ForNextStatementTests
{
#region C#
// No C# representation
#endregion
#region VB.NET
[Test]
public void VBNetForNextStatementTest()

20
VB/Test/Parser/Statements/ForStatementTests.cs

@ -12,28 +12,8 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,28 +12,8 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class ForStatementTests
{
#region C#
[Test]
public void CSharpEmptyForStatementTest()
{
ForStatement forStmt = ParseUtilCSharp.ParseStatement<ForStatement>("for (;;) ;");
Assert.AreEqual(0, forStmt.Initializers.Count);
Assert.AreEqual(0, forStmt.Iterator.Count);
Assert.IsTrue(forStmt.Condition.IsNull);
Assert.IsTrue(forStmt.EmbeddedStatement is EmptyStatement);
}
[Test]
public void CSharpForStatementTest()
{
ForStatement forStmt = ParseUtilCSharp.ParseStatement<ForStatement>("for (int i = 5; i < 6; ++i) {} ");
// TODO : Extend test.
}
#endregion
#region VB.NET
// No VB.NET representation (for ... next is different)
#endregion
}
}

9
VB/Test/Parser/Statements/ForeachStatementTests.cs

@ -12,15 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,15 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class ForeachStatementTests
{
#region C#
[Test]
public void CSharpForeachStatementTest()
{
ForeachStatement foreachStmt = ParseUtilCSharp.ParseStatement<ForeachStatement>("foreach (int i in myColl) {} ");
// TODO : Extend test.
}
#endregion
#region VB.NET
[Test]
public void VBNetForeachStatementTest()

17
VB/Test/Parser/Statements/GotoCaseStatementTests.cs

@ -12,23 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,23 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class GotoCaseStatementTests
{
#region C#
[Test]
public void CSharpGotoCaseDefaltStatementTest()
{
GotoCaseStatement gotoCaseStmt = ParseUtilCSharp.ParseStatement<GotoCaseStatement>("goto default;");
Assert.IsTrue(gotoCaseStmt.IsDefaultCase);
}
[Test]
public void CSharpGotoCaseStatementTest()
{
GotoCaseStatement gotoCaseStmt = ParseUtilCSharp.ParseStatement<GotoCaseStatement>("goto case 6;");
Assert.IsFalse(gotoCaseStmt.IsDefaultCase);
Assert.IsTrue(gotoCaseStmt.Expression is PrimitiveExpression);
}
#endregion
#region VB.NET
// No VB.NET representation
#endregion

9
VB/Test/Parser/Statements/GotoStatementTests.cs

@ -12,15 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,15 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class GotoStatementTests
{
#region C#
[Test]
public void CSharpGotoStatementTest()
{
GotoStatement gotoStmt = ParseUtilCSharp.ParseStatement<GotoStatement>("goto myLabel;");
Assert.AreEqual("myLabel", gotoStmt.Label);
}
#endregion
#region VB.NET
[Test]
public void VBNetGotoStatementTest()

43
VB/Test/Parser/Statements/IfElseStatementTests.cs

@ -12,49 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,49 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class IfElseStatementTests
{
#region C#
[Test]
public void CSharpSimpleIfStatementTest()
{
IfElseStatement ifElseStatement = ParseUtilCSharp.ParseStatement<IfElseStatement>("if (true) { }");
Assert.IsFalse(ifElseStatement.Condition.IsNull);
Assert.IsTrue(ifElseStatement.TrueStatement.Count == 1, "true count != 1:" + ifElseStatement.TrueStatement.Count);
Assert.IsTrue(ifElseStatement.FalseStatement.Count == 0, "false count != 0:" + ifElseStatement.FalseStatement.Count);
Assert.IsTrue(ifElseStatement.TrueStatement[0] is BlockStatement);
}
[Test]
public void CSharpSimpleIfElseStatementTest()
{
IfElseStatement ifElseStatement = ParseUtilCSharp.ParseStatement<IfElseStatement>("if (true) { } else { }");
Assert.IsFalse(ifElseStatement.Condition.IsNull);
Assert.IsTrue(ifElseStatement.TrueStatement.Count == 1, "true count != 1:" + ifElseStatement.TrueStatement.Count);
Assert.IsTrue(ifElseStatement.FalseStatement.Count == 1, "false count != 1:" + ifElseStatement.FalseStatement.Count);
Assert.IsTrue(ifElseStatement.TrueStatement[0] is BlockStatement, "Statement was: " + ifElseStatement.TrueStatement[0]);
Assert.IsTrue(ifElseStatement.FalseStatement[0] is BlockStatement, "Statement was: " + ifElseStatement.FalseStatement[0]);
}
[Test]
public void CSharpIfElseIfStatementTest()
{
IfElseStatement ifElseStatement = ParseUtilCSharp.ParseStatement<IfElseStatement>("if (1) { } else if (2) { } else if (3) { } else { }");
Assert.IsFalse(ifElseStatement.Condition.IsNull);
Assert.IsTrue(ifElseStatement.ElseIfSections.Count == 2, "elseif section count != 2:" + ifElseStatement.ElseIfSections.Count);
Assert.IsTrue(ifElseStatement.TrueStatement.Count == 1, "true count != 1:" + ifElseStatement.TrueStatement.Count);
Assert.IsTrue(ifElseStatement.FalseStatement.Count == 1, "false count != 1:" + ifElseStatement.FalseStatement.Count);
Assert.IsTrue(ifElseStatement.TrueStatement[0] is BlockStatement, "Statement was: " + ifElseStatement.TrueStatement[0]);
Assert.IsTrue(ifElseStatement.FalseStatement[0] is BlockStatement, "Statement was: " + ifElseStatement.FalseStatement[0]);
Assert.IsTrue(ifElseStatement.ElseIfSections[0].EmbeddedStatement is BlockStatement, "Statement was: " + ifElseStatement.ElseIfSections[0].EmbeddedStatement);
Assert.IsTrue(ifElseStatement.ElseIfSections[1].EmbeddedStatement is BlockStatement, "Statement was: " + ifElseStatement.ElseIfSections[1].EmbeddedStatement);
Assert.AreEqual(2, (ifElseStatement.ElseIfSections[0].Condition as PrimitiveExpression).Value);
Assert.AreEqual(3, (ifElseStatement.ElseIfSections[1].Condition as PrimitiveExpression).Value);
}
#endregion
#region VB.NET
[Test]
public void VBNetSimpleIfStatementTest()

15
VB/Test/Parser/Statements/LabelStatementTests.cs

@ -12,21 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,21 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class LabelStatementTests
{
#region C#
[Test]
public void CSharpLabelStatementTest()
{
LabelStatement labelStmt = ParseUtilCSharp.ParseStatement<LabelStatement>("myLabel: ; ");
Assert.AreEqual("myLabel", labelStmt.Label);
}
[Test]
public void CSharpLabel2StatementTest()
{
LabelStatement labelStmt = ParseUtilCSharp.ParseStatement<LabelStatement>("yield: ; ");
Assert.AreEqual("yield", labelStmt.Label);
}
#endregion
#region VB.NET
[Test]
public void VBNetLabelStatementTest()

216
VB/Test/Parser/Statements/LocalVariableDeclarationTests.cs

@ -12,222 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,222 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class LocalVariableDeclarationTests
{
#region C#
[Test]
public void CSharpLocalVariableDeclarationTest()
{
LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement<LocalVariableDeclaration>("int a = 5;");
Assert.AreEqual(1, lvd.Variables.Count);
Assert.AreEqual("a", ((VariableDeclaration)lvd.Variables[0]).Name);
TypeReference type = lvd.GetTypeForVariable(0);
Assert.AreEqual("System.Int32", type.Type);
Assert.AreEqual(5, ((PrimitiveExpression)lvd.Variables[0].Initializer).Value);
}
[Test]
public void CSharpVoidPointerVariableDeclarationTest()
{
LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement<LocalVariableDeclaration>("void *a;");
Assert.AreEqual(1, lvd.Variables.Count);
Assert.AreEqual("a", ((VariableDeclaration)lvd.Variables[0]).Name);
TypeReference type = lvd.GetTypeForVariable(0);
Assert.AreEqual("System.Void", type.Type);
Assert.AreEqual(1, type.PointerNestingLevel);
}
[Test]
public void CSharpComplexGenericLocalVariableDeclarationTest()
{
LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement<LocalVariableDeclaration>("Generic<Namespace.Printable, G<Printable[]> > where = new Generic<Namespace.Printable, G<Printable[]>>();");
Assert.AreEqual(1, lvd.Variables.Count);
Assert.AreEqual("where", ((VariableDeclaration)lvd.Variables[0]).Name);
TypeReference type = lvd.GetTypeForVariable(0);
Assert.AreEqual("Generic", type.Type);
Assert.AreEqual(2, type.GenericTypes.Count);
Assert.AreEqual("Namespace.Printable", type.GenericTypes[0].Type);
Assert.AreEqual(0, type.GenericTypes[0].GenericTypes.Count);
Assert.AreEqual("G", type.GenericTypes[1].Type);
Assert.AreEqual(1, type.GenericTypes[1].GenericTypes.Count);
Assert.AreEqual("Printable", type.GenericTypes[1].GenericTypes[0].Type);
// TODO: Check initializer
}
[Test]
public void CSharpNestedGenericLocalVariableDeclarationTest()
{
LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement<LocalVariableDeclaration>("MyType<string>.InnerClass<int>.InnerInnerClass a;");
Assert.AreEqual(1, lvd.Variables.Count);
InnerClassTypeReference ic = (InnerClassTypeReference)lvd.GetTypeForVariable(0);
Assert.AreEqual("InnerInnerClass", ic.Type);
Assert.AreEqual(0, ic.GenericTypes.Count);
ic = (InnerClassTypeReference)ic.BaseType;
Assert.AreEqual("InnerClass", ic.Type);
Assert.AreEqual(1, ic.GenericTypes.Count);
Assert.AreEqual("System.Int32", ic.GenericTypes[0].Type);
Assert.AreEqual("MyType", ic.BaseType.Type);
Assert.AreEqual(1, ic.BaseType.GenericTypes.Count);
Assert.AreEqual("System.String", ic.BaseType.GenericTypes[0].Type);
}
[Test]
public void CSharpGenericWithArrayLocalVariableDeclarationTest1()
{
LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement<LocalVariableDeclaration>("G<int>[] a;");
Assert.AreEqual(1, lvd.Variables.Count);
TypeReference type = lvd.GetTypeForVariable(0);
Assert.AreEqual("G", type.Type);
Assert.AreEqual(1, type.GenericTypes.Count);
Assert.AreEqual("System.Int32", type.GenericTypes[0].Type);
Assert.AreEqual(0, type.GenericTypes[0].GenericTypes.Count);
Assert.IsFalse(type.GenericTypes[0].IsArrayType);
Assert.AreEqual(new int[] {0}, type.RankSpecifier);
}
[Test]
public void CSharpGenericWithArrayLocalVariableDeclarationTest2()
{
LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement<LocalVariableDeclaration>("G<int[]> a;");
Assert.AreEqual(1, lvd.Variables.Count);
TypeReference type = lvd.GetTypeForVariable(0);
Assert.AreEqual("G", type.Type);
Assert.AreEqual(1, type.GenericTypes.Count);
Assert.AreEqual("System.Int32", type.GenericTypes[0].Type);
Assert.AreEqual(0, type.GenericTypes[0].GenericTypes.Count);
Assert.IsFalse(type.IsArrayType);
Assert.AreEqual(new int[] {0}, type.GenericTypes[0].RankSpecifier);
}
[Test]
public void CSharpGenericLocalVariableDeclarationTest2()
{
LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement<LocalVariableDeclaration>("G<G<int> > a;");
Assert.AreEqual(1, lvd.Variables.Count);
TypeReference type = lvd.GetTypeForVariable(0);
Assert.AreEqual("G", type.Type);
Assert.AreEqual(1, type.GenericTypes.Count);
Assert.AreEqual("G", type.GenericTypes[0].Type);
Assert.AreEqual(1, type.GenericTypes[0].GenericTypes.Count);
Assert.AreEqual("System.Int32", type.GenericTypes[0].GenericTypes[0].Type);
}
[Test]
public void CSharpGenericLocalVariableDeclarationTest2WithoutSpace()
{
LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement<LocalVariableDeclaration>("G<G<int>> a;");
Assert.AreEqual(1, lvd.Variables.Count);
TypeReference type = lvd.GetTypeForVariable(0);
Assert.AreEqual("G", type.Type);
Assert.AreEqual(1, type.GenericTypes.Count);
Assert.AreEqual("G", type.GenericTypes[0].Type);
Assert.AreEqual(1, type.GenericTypes[0].GenericTypes.Count);
Assert.AreEqual("System.Int32", type.GenericTypes[0].GenericTypes[0].Type);
}
[Test]
public void CSharpGenericLocalVariableDeclarationTest()
{
LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement<LocalVariableDeclaration>("G<int> a;");
Assert.AreEqual(1, lvd.Variables.Count);
TypeReference type = lvd.GetTypeForVariable(0);
Assert.AreEqual("G", type.Type);
Assert.AreEqual(1, type.GenericTypes.Count);
Assert.AreEqual("System.Int32", type.GenericTypes[0].Type);
}
[Test]
public void CSharpSimpleLocalVariableDeclarationTest()
{
LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement<LocalVariableDeclaration>("MyVar var = new MyVar();");
Assert.AreEqual(1, lvd.Variables.Count);
Assert.AreEqual("var", ((VariableDeclaration)lvd.Variables[0]).Name);
TypeReference type = lvd.GetTypeForVariable(0);
Assert.AreEqual("MyVar", type.Type);
// TODO: Check initializer
}
[Test]
public void CSharpSimpleLocalVariableDeclarationTest1()
{
LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement<LocalVariableDeclaration>("yield yield = new yield();");
Assert.AreEqual(1, lvd.Variables.Count);
Assert.AreEqual("yield", ((VariableDeclaration)lvd.Variables[0]).Name);
TypeReference type = lvd.GetTypeForVariable(0);
Assert.AreEqual("yield", type.Type);
// TODO: Check initializer
}
[Test]
public void CSharpNullableLocalVariableDeclarationTest1()
{
LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement<LocalVariableDeclaration>("int? a;");
Assert.AreEqual(1, lvd.Variables.Count);
Assert.AreEqual("a", ((VariableDeclaration)lvd.Variables[0]).Name);
TypeReference type = lvd.GetTypeForVariable(0);
Assert.AreEqual("System.Nullable", type.Type);
Assert.AreEqual("System.Int32", type.GenericTypes[0].Type);
}
[Test]
public void CSharpNullableLocalVariableDeclarationTest2()
{
LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement<LocalVariableDeclaration>("DateTime? a;");
Assert.AreEqual(1, lvd.Variables.Count);
Assert.AreEqual("a", ((VariableDeclaration)lvd.Variables[0]).Name);
TypeReference type = lvd.GetTypeForVariable(0);
Assert.AreEqual("System.Nullable", type.Type);
Assert.AreEqual("DateTime", type.GenericTypes[0].Type);
}
[Test]
public void CSharpNullableLocalVariableDeclarationTest3()
{
LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement<LocalVariableDeclaration>("DateTime?[] a;");
Assert.AreEqual(1, lvd.Variables.Count);
Assert.AreEqual("a", ((VariableDeclaration)lvd.Variables[0]).Name);
TypeReference type = lvd.GetTypeForVariable(0);
Assert.IsTrue(type.IsArrayType);
Assert.AreEqual("System.Nullable", type.Type);
Assert.AreEqual("DateTime", type.GenericTypes[0].Type);
}
[Test]
public void CSharpNullableLocalVariableDeclarationTest4()
{
LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement<LocalVariableDeclaration>("SomeStruct<int?>? a;");
Assert.AreEqual(1, lvd.Variables.Count);
Assert.AreEqual("a", ((VariableDeclaration)lvd.Variables[0]).Name);
TypeReference type = lvd.GetTypeForVariable(0);
Assert.AreEqual("System.Nullable", type.Type);
Assert.AreEqual("SomeStruct", type.GenericTypes[0].Type);
Assert.AreEqual("System.Nullable", type.GenericTypes[0].GenericTypes[0].Type);
Assert.AreEqual("System.Int32", type.GenericTypes[0].GenericTypes[0].GenericTypes[0].Type);
}
[Test]
public void PositionTestWithoutModifier()
{
LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement<LocalVariableDeclaration>("\ndouble w = 7;");
Assert.AreEqual(2, lvd.StartLocation.Line);
Assert.AreEqual(1, lvd.StartLocation.Column);
Assert.AreEqual(2, lvd.EndLocation.Line);
Assert.AreEqual(14, lvd.EndLocation.Column);
}
[Test]
public void PositionTestWithModifier()
{
LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement<LocalVariableDeclaration>("\nconst double w = 7;");
Assert.AreEqual(Modifiers.Const, lvd.Modifier);
Assert.AreEqual(2, lvd.StartLocation.Line);
Assert.AreEqual(1, lvd.StartLocation.Column);
Assert.AreEqual(2, lvd.EndLocation.Line);
Assert.AreEqual(20, lvd.EndLocation.Column);
}
#endregion
#region VB.NET
[Test]
public void VBNetLocalVariableDeclarationTest()

9
VB/Test/Parser/Statements/LockStatementTests.cs

@ -12,15 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,15 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class LockStatementTests
{
#region C#
[Test]
public void CSharpLockStatementTest()
{
LockStatement lockStmt = ParseUtilCSharp.ParseStatement<LockStatement>("lock (myObj) {}");
// TODO : Extend test.
}
#endregion
#region VB.NET
// No VB.NET representation
#endregion

4
VB/Test/Parser/Statements/OnErrorStatementTest.cs

@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class OnErrorStatementTest
{
#region C#
// No C# representation
#endregion
#region VB.NET
[Test]
public void VBNetOnErrorStatementTest()

4
VB/Test/Parser/Statements/RaiseEventStatementTest.cs

@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class RaiseEventStatementTest
{
#region C#
// No C# representation
#endregion
#region VB.NET
[Test]
public void VBNetRaiseEventStatementTest()

4
VB/Test/Parser/Statements/RemoveHandlerStatement.cs

@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class RemoveHandlerStatementTests
{
#region C#
// No C# representation
#endregion
#region VB.NET
[Test]
public void VBNetRemoveHandlerTest()

4
VB/Test/Parser/Statements/ResumeStatement.cs

@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class ResumeStatementTests
{
#region C#
// No C# representation
#endregion
#region VB.NET
[Test]
public void VBNetResumeStatementTest()

24
VB/Test/Parser/Statements/ReturnStatementTests.cs

@ -12,30 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,30 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class ReturnStatementTests
{
#region C#
[Test]
public void CSharpEmptyReturnStatementTest()
{
ReturnStatement returnStatement = ParseUtilCSharp.ParseStatement<ReturnStatement>("return;");
Assert.IsTrue(returnStatement.Expression.IsNull);
}
[Test]
public void CSharpReturnStatementTest()
{
ReturnStatement returnStatement = ParseUtilCSharp.ParseStatement<ReturnStatement>("return 5;");
Assert.IsFalse(returnStatement.Expression.IsNull);
Assert.IsTrue(returnStatement.Expression is PrimitiveExpression);
}
[Test]
public void CSharpReturnStatementTest1()
{
ReturnStatement returnStatement = ParseUtilCSharp.ParseStatement<ReturnStatement>("return yield;");
Assert.IsFalse(returnStatement.Expression.IsNull);
Assert.IsTrue(returnStatement.Expression is IdentifierExpression);
}
#endregion
#region VB.NET
[Test]
public void VBNetEmptyReturnStatementTest()

4
VB/Test/Parser/Statements/StopStatementTests.cs

@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class StopStatementTests
{
#region C#
// No C# representation
#endregion
#region VB.NET
[Test]
public void VBNetStopStatementTest()

10
VB/Test/Parser/Statements/SwitchStatementTests.cs

@ -12,16 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,16 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class SwitchStatementTests
{
#region C#
[Test]
public void CSharpSwitchStatementTest()
{
SwitchStatement switchStmt = ParseUtilCSharp.ParseStatement<SwitchStatement>("switch (a) { case 4: case 5: break; case 6: break; default: break; }");
Assert.AreEqual("a", ((IdentifierExpression)switchStmt.SwitchExpression).Identifier);
// TODO: Extend test
}
#endregion
#region VB.NET
[Test]
public void VBSwitchStatementTest()

16
VB/Test/Parser/Statements/ThrowStatementTests.cs

@ -12,22 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,22 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class ThrowStatementTests
{
#region C#
[Test]
public void CSharpEmptyThrowStatementTest()
{
ThrowStatement throwStmt = ParseUtilCSharp.ParseStatement<ThrowStatement>("throw;");
Assert.IsTrue(throwStmt.Expression.IsNull);
}
[Test]
public void CSharpThrowStatementTest()
{
ThrowStatement throwStmt = ParseUtilCSharp.ParseStatement<ThrowStatement>("throw new Exception();");
Assert.IsTrue(throwStmt.Expression is ObjectCreateExpression);
}
#endregion
#region VB.NET
// TODO
#endregion

34
VB/Test/Parser/Statements/TryCatchStatementTests.cs

@ -12,40 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,40 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class TryCatchStatementTests
{
#region C#
[Test]
public void CSharpSimpleTryCatchStatementTest()
{
TryCatchStatement tryCatchStatement = ParseUtilCSharp.ParseStatement<TryCatchStatement>("try { } catch { } ");
Assert.IsTrue(tryCatchStatement.FinallyBlock.IsNull);
Assert.AreEqual(1, tryCatchStatement.CatchClauses.Count);
Assert.IsTrue(tryCatchStatement.CatchClauses[0].TypeReference.IsNull);
Assert.IsEmpty(tryCatchStatement.CatchClauses[0].VariableName);
}
[Test]
public void CSharpSimpleTryCatchStatementTest2()
{
TryCatchStatement tryCatchStatement = ParseUtilCSharp.ParseStatement<TryCatchStatement>("try { } catch (Exception e) { } ");
Assert.IsTrue(tryCatchStatement.FinallyBlock.IsNull);
Assert.AreEqual(1, tryCatchStatement.CatchClauses.Count);
Assert.AreEqual("Exception", tryCatchStatement.CatchClauses[0].TypeReference.Type);
Assert.AreEqual("e", tryCatchStatement.CatchClauses[0].VariableName);
}
[Test]
public void CSharpSimpleTryCatchFinallyStatementTest()
{
TryCatchStatement tryCatchStatement = ParseUtilCSharp.ParseStatement<TryCatchStatement>("try { } catch (Exception) { } catch { } finally { } ");
Assert.IsFalse(tryCatchStatement.FinallyBlock.IsNull);
Assert.AreEqual(2, tryCatchStatement.CatchClauses.Count);
Assert.AreEqual("Exception", tryCatchStatement.CatchClauses[0].TypeReference.Type);
Assert.IsEmpty(tryCatchStatement.CatchClauses[0].VariableName);
Assert.IsTrue(tryCatchStatement.CatchClauses[1].TypeReference.IsNull);
Assert.IsEmpty(tryCatchStatement.CatchClauses[1].VariableName);
}
#endregion
#region VB.NET
// TODO
#endregion

20
VB/Test/Parser/Statements/UncheckedStatementTests.cs

@ -12,26 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,26 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class UncheckedStatementTests
{
#region C#
[Test]
public void CSharpUncheckedStatementTest()
{
UncheckedStatement uncheckedStatement = ParseUtilCSharp.ParseStatement<UncheckedStatement>("unchecked { }");
Assert.IsFalse(uncheckedStatement.Block.IsNull);
}
[Test]
public void CSharpUncheckedStatementAndExpressionTest()
{
UncheckedStatement uncheckedStatement = ParseUtilCSharp.ParseStatement<UncheckedStatement>("unchecked { unchecked(++i); }");
Assert.IsFalse(uncheckedStatement.Block.IsNull);
ExpressionStatement es = (ExpressionStatement)uncheckedStatement.Block.Children[0];
UncheckedExpression ce = (UncheckedExpression)es.Expression;
Assert.IsInstanceOf<UnaryOperatorExpression>(ce.Expression);
}
#endregion
#region VB.NET
// No VB.NET representation
#endregion

9
VB/Test/Parser/Statements/UnsafeStatementTests.cs

@ -12,15 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,15 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class UnsafeStatementTests
{
#region C#
[Test]
public void CSharpUnsafeStatementTest()
{
UnsafeStatement unsafeStatement = ParseUtilCSharp.ParseStatement<UnsafeStatement>("unsafe { }");
Assert.IsFalse(unsafeStatement.Block.IsNull);
}
#endregion
#region VB.NET
// No VB.NET representation
#endregion

9
VB/Test/Parser/Statements/UsingStatementTests.cs

@ -12,15 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,15 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class UsingStatementTests
{
#region C#
[Test]
public void CSharpUsingStatementTest()
{
UsingStatement usingStmt = ParseUtilCSharp.ParseStatement<UsingStatement>("using (MyVar var = new MyVar()) { } ");
// TODO : Extend test.
}
#endregion
#region VB.NET
[Test]
public void VBNetUsingStatementTest()

4
VB/Test/Parser/Statements/WithStatementTests.cs

@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -12,10 +12,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class WithStatementTests
{
#region C#
// No C# representation
#endregion
#region VB.NET
[Test]
public void VBNetWithStatementTest()

45
VB/Test/Parser/Statements/YieldStatementTests.cs

@ -1,45 +0,0 @@ @@ -1,45 +0,0 @@
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
using System;
using System.IO;
using NUnit.Framework;
using ICSharpCode.NRefactory.VB.Parser;
using ICSharpCode.NRefactory.VB.Dom;
namespace ICSharpCode.NRefactory.VB.Tests.Dom
{
[TestFixture]
public class YieldStatementTests
{
[Test]
public void YieldReturnStatementTest()
{
YieldStatement yieldStmt = ParseUtilCSharp.ParseStatement<YieldStatement>("yield return \"Foo\";");
Assert.IsTrue(yieldStmt.IsYieldReturn);
ReturnStatement retStmt = (ReturnStatement)yieldStmt.Statement;
PrimitiveExpression expr = (PrimitiveExpression)retStmt.Expression;
Assert.AreEqual("Foo", expr.Value);
}
[Test]
public void YieldBreakStatementTest()
{
YieldStatement yieldStmt = ParseUtilCSharp.ParseStatement<YieldStatement>("yield break;");
Assert.IsTrue(yieldStmt.IsYieldBreak);
}
[Test]
public void YieldAsVariableTest()
{
ExpressionStatement se = ParseUtilCSharp.ParseStatement<ExpressionStatement>("yield = 3;");
AssignmentExpression ae = se.Expression as AssignmentExpression;
Assert.AreEqual(AssignmentOperatorType.Assign, ae.Op);
Assert.IsTrue(ae.Left is IdentifierExpression);
Assert.AreEqual("yield", ((IdentifierExpression)ae.Left).Identifier);
Assert.IsTrue(ae.Right is PrimitiveExpression);
}
}
}

41
VB/Test/Parser/TypeLevel/ConstructorDeclarationTests.cs

@ -10,47 +10,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -10,47 +10,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class ConstructorDeclarationTests
{
#region C#
[Test]
public void CSharpConstructorDeclarationTest1()
{
ConstructorDeclaration cd = ParseUtilCSharp.ParseTypeMember<ConstructorDeclaration>("MyClass() {}");
Assert.IsTrue(cd.ConstructorInitializer.IsNull);
}
[Test]
public void CSharpConstructorDeclarationTest2()
{
ConstructorDeclaration cd = ParseUtilCSharp.ParseTypeMember<ConstructorDeclaration>("MyClass() : this(5) {}");
Assert.AreEqual(ConstructorInitializerType.This, cd.ConstructorInitializer.ConstructorInitializerType);
Assert.AreEqual(1, cd.ConstructorInitializer.Arguments.Count);
}
[Test]
public void CSharpConstructorDeclarationTest3()
{
ConstructorDeclaration cd = ParseUtilCSharp.ParseTypeMember<ConstructorDeclaration>("MyClass() : base(1, 2, 3) {}");
Assert.AreEqual(ConstructorInitializerType.Base, cd.ConstructorInitializer.ConstructorInitializerType);
Assert.AreEqual(3, cd.ConstructorInitializer.Arguments.Count);
}
[Test]
public void CSharpStaticConstructorDeclarationTest1()
{
ConstructorDeclaration cd = ParseUtilCSharp.ParseTypeMember<ConstructorDeclaration>("static MyClass() {}");
Assert.IsTrue(cd.ConstructorInitializer.IsNull);
Assert.AreEqual(Modifiers.Static, cd.Modifier);
}
[Test]
public void CSharpExternStaticConstructorDeclarationTest()
{
ConstructorDeclaration cd = ParseUtilCSharp.ParseTypeMember<ConstructorDeclaration>("extern static MyClass();");
Assert.IsTrue(cd.ConstructorInitializer.IsNull);
Assert.AreEqual(Modifiers.Static | Modifiers.Extern, cd.Modifier);
}
#endregion
#region VB.NET
[Test]
public void VBNetConstructorDeclarationTest1()

4
VB/Test/Parser/TypeLevel/DeclareDeclarationTests.cs

@ -10,10 +10,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -10,10 +10,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class DeclareDeclarationTests
{
#region C#
// No C# representation
#endregion
#region VB.NET
[Test]
public void VBNetDeclareDeclarationTest()

22
VB/Test/Parser/TypeLevel/DestructorDeclarationTests.cs

@ -10,28 +10,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -10,28 +10,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class DestructorDeclarationTests
{
#region C#
[Test]
public void CSharpDestructorDeclarationTest()
{
DestructorDeclaration dd = ParseUtilCSharp.ParseTypeMember<DestructorDeclaration>("~MyClass() {}");
}
[Test]
public void CSharpExternDestructorDeclarationTest()
{
DestructorDeclaration dd = ParseUtilCSharp.ParseTypeMember<DestructorDeclaration>("extern ~MyClass();");
Assert.AreEqual(Modifiers.Extern, dd.Modifier);
}
[Test]
public void CSharpUnsafeDestructorDeclarationTest()
{
DestructorDeclaration dd = ParseUtilCSharp.ParseTypeMember<DestructorDeclaration>("unsafe ~MyClass() {}");
Assert.AreEqual(Modifiers.Unsafe, dd.Modifier);
}
#endregion
#region VB.NET
// No VB.NET representation
#endregion

72
VB/Test/Parser/TypeLevel/EventDeclarationTests.cs

@ -10,78 +10,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -10,78 +10,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class EventDeclarationTests
{
#region C#
[Test]
public void CSharpSimpleEventDeclarationTest()
{
EventDeclaration ed = ParseUtilCSharp.ParseTypeMember<EventDeclaration>("event System.EventHandler MyEvent;");
Assert.AreEqual("MyEvent", ed.Name);
Assert.AreEqual("System.EventHandler", ed.TypeReference.Type);
Assert.IsFalse(ed.HasAddRegion);
Assert.IsFalse(ed.HasRemoveRegion);
}
[Test]
public void CSharpMultipleEventDeclarationTest()
{
TypeDeclaration t = ParseUtilCSharp.ParseGlobal<TypeDeclaration>("class C { public event EventHandler A, B; }");
Assert.AreEqual(2, t.Children.Count);
EventDeclaration ed = (EventDeclaration)t.Children[0];
Assert.AreEqual(Modifiers.Public, ed.Modifier);
Assert.AreEqual("EventHandler", ed.TypeReference.Type);
Assert.AreEqual("A", ed.Name);
ed = (EventDeclaration)t.Children[1];
Assert.AreEqual(Modifiers.Public, ed.Modifier);
Assert.AreEqual("EventHandler", ed.TypeReference.Type);
Assert.AreEqual("B", ed.Name);
}
[Test]
public void CSharpEventImplementingInterfaceDeclarationTest()
{
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 CSharpEventImplementingGenericInterfaceDeclarationTest()
{
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 CSharpAddRemoveEventDeclarationTest()
{
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);
}
#endregion
#region VB.NET
[Test]
public void VBNetSimpleEventDeclarationTest()

13
VB/Test/Parser/TypeLevel/FieldDeclarationTests.cs

@ -10,19 +10,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -10,19 +10,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class FieldDeclarationTests
{
#region C#
[Test]
public void CSharpSimpleFieldDeclarationTest()
{
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);
}
#endregion
#region VB.NET
[Test]
public void VBNetSimpleFieldDeclarationTest()

37
VB/Test/Parser/TypeLevel/IndexerDeclarationTests.cs

@ -10,43 +10,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -10,43 +10,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class IndexerDeclarationTests
{
#region C#
[Test]
public void CSharpIndexerDeclarationTest()
{
PropertyDeclaration id = ParseUtilCSharp.ParseTypeMember<PropertyDeclaration>("int this[int a, string b] { get { } set { } }");
Assert.AreEqual(2, id.Parameters.Count);
Assert.IsTrue(id.HasGetRegion, "No get region found!");
Assert.IsTrue(id.HasSetRegion, "No set region found!");
Assert.IsTrue(id.IsIndexer, "No Default modifier set!");
}
[Test]
public void CSharpIndexerImplementingInterfaceTest()
{
PropertyDeclaration id = ParseUtilCSharp.ParseTypeMember<PropertyDeclaration>("int MyInterface.this[int a, string b] { get { } set { } }");
Assert.AreEqual(2, id.Parameters.Count);
Assert.IsTrue(id.HasGetRegion, "No get region found!");
Assert.IsTrue(id.HasSetRegion, "No set region found!");
Assert.IsTrue(id.IsIndexer, "No Default modifier set!");
Assert.AreEqual("MyInterface", id.InterfaceImplementations[0].InterfaceType.Type);
}
[Test]
public void CSharpIndexerImplementingGenericInterfaceTest()
{
PropertyDeclaration id = ParseUtilCSharp.ParseTypeMember<PropertyDeclaration>("int MyInterface<string>.this[int a, string b] { get { } set { } }");
Assert.AreEqual(2, id.Parameters.Count);
Assert.IsTrue(id.HasGetRegion, "No get region found!");
Assert.IsTrue(id.HasSetRegion, "No set region found!");
Assert.IsTrue(id.IsIndexer, "No Default modifier set!");
Assert.AreEqual("MyInterface", id.InterfaceImplementations[0].InterfaceType.Type);
Assert.AreEqual("System.String", id.InterfaceImplementations[0].InterfaceType.GenericTypes[0].Type);
}
#endregion
#region VB.NET
// no vb.net representation (indexers are properties named "item" in vb.net)
#endregion

289
VB/Test/Parser/TypeLevel/MethodDeclarationTests.cs

@ -10,295 +10,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -10,295 +10,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class MethodDeclarationTests
{
#region C#
[Test]
public void CSharpSimpleMethodDeclarationTest()
{
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("void MyMethod() {} ");
Assert.AreEqual("System.Void", md.TypeReference.Type);
Assert.AreEqual(0, md.Parameters.Count);
Assert.IsFalse(md.IsExtensionMethod);
}
[Test]
public void CSharpAbstractMethodDeclarationTest()
{
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("abstract void MyMethod();");
Assert.AreEqual("System.Void", md.TypeReference.Type);
Assert.AreEqual(0, md.Parameters.Count);
Assert.IsFalse(md.IsExtensionMethod);
Assert.IsTrue(md.Body.IsNull);
Assert.AreEqual(Modifiers.Abstract, md.Modifier);
}
[Test]
public void CSharpDefiningPartialMethodDeclarationTest()
{
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("partial void MyMethod();");
Assert.AreEqual("System.Void", md.TypeReference.Type);
Assert.AreEqual(0, md.Parameters.Count);
Assert.IsFalse(md.IsExtensionMethod);
Assert.IsTrue(md.Body.IsNull);
Assert.AreEqual(Modifiers.Partial, md.Modifier);
}
[Test]
public void CSharpImplementingPartialMethodDeclarationTest()
{
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("partial void MyMethod() { }");
Assert.AreEqual("System.Void", md.TypeReference.Type);
Assert.AreEqual(0, md.Parameters.Count);
Assert.IsFalse(md.IsExtensionMethod);
Assert.IsFalse(md.Body.IsNull);
Assert.AreEqual(Modifiers.Partial, md.Modifier);
}
[Test]
public void CSharpSimpleMethodRegionTest()
{
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");
// 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 CSharpMethodWithModifiersRegionTest()
{
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 CSharpMethodWithUnnamedParameterDeclarationTest()
{
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("void MyMethod(int) {} ", true);
Assert.AreEqual("System.Void", md.TypeReference.Type);
Assert.AreEqual(1, md.Parameters.Count);
//Assert.AreEqual("?", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName);
}
[Test]
public void CSharpGenericVoidMethodDeclarationTest()
{
MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("void MyMethod<T>(T a) {} ");
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);
}
[Test]
public void CSharpGenericMethodDeclarationTest()
{
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 CSharpGenericMethodDeclarationWithConstraintTest()
{
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 CSharpGenericMethodInInterface()
{
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 CSharpGenericVoidMethodInInterface()
{
const string program = @"interface MyInterface {
void MyMethod<T>(T a) where T : ISomeInterface;
}
";
TypeDeclaration td = ParseUtilCSharp.ParseGlobal<TypeDeclaration>(program);
MethodDeclaration md = (MethodDeclaration)td.Children[0];
Assert.AreEqual("System.Void", md.TypeReference.Type);
Assert.AreEqual(1, md.Parameters.Count);
Assert.AreEqual("T", ((ParameterDeclarationExpression)md.Parameters[0]).TypeReference.Type);
Assert.AreEqual("a", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName);
Assert.AreEqual(1, md.Templates.Count);
Assert.AreEqual("T", md.Templates[0].Name);
Assert.AreEqual(1, md.Templates[0].Bases.Count);
Assert.AreEqual("ISomeInterface", md.Templates[0].Bases[0].Type);
}
[Test]
public void CSharpShadowingMethodInInterface()
{
const string program = @"interface MyInterface : IDisposable {
new void Dispose();
}
";
TypeDeclaration td = ParseUtilCSharp.ParseGlobal<TypeDeclaration>(program);
MethodDeclaration md = (MethodDeclaration)td.Children[0];
Assert.AreEqual("System.Void", md.TypeReference.Type);
Assert.AreEqual(0, md.Parameters.Count);
Assert.AreEqual(Modifiers.New, md.Modifier);
}
[Test]
public void CSharpMethodImplementingInterfaceTest()
{
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 CSharpMethodImplementingGenericInterfaceTest()
{
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 CSharpVoidMethodImplementingInterfaceTest()
{
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 CSharpVoidMethodImplementingGenericInterfaceTest()
{
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 CSharpIncompleteConstraintsTest()
{
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 CSharpExtensionMethodTest()
{
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 CSharpVoidExtensionMethodTest()
{
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 CSharpMethodWithEmptyAssignmentErrorInBody()
{
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 CSharpOptionalParameterTest()
{
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);
}
#endregion
#region VB.NET
[Test]

44
VB/Test/Parser/TypeLevel/OperatorDeclarationTests.cs

@ -10,50 +10,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -10,50 +10,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class OperatorDeclarationTests
{
#region C#
[Test]
public void CSharpImplictOperatorDeclarationTest()
{
OperatorDeclaration od = ParseUtilCSharp.ParseTypeMember<OperatorDeclaration>("public static implicit operator double(MyObject f) { return 0.5d; }");
Assert.IsTrue(od.IsConversionOperator);
Assert.AreEqual(1, od.Parameters.Count);
Assert.AreEqual(ConversionType.Implicit, od.ConversionType);
Assert.AreEqual("System.Double", od.TypeReference.Type);
}
[Test]
public void CSharpExplicitOperatorDeclarationTest()
{
OperatorDeclaration od = ParseUtilCSharp.ParseTypeMember<OperatorDeclaration>("public static explicit operator double(MyObject f) { return 0.5d; }");
Assert.IsTrue(od.IsConversionOperator);
Assert.AreEqual(1, od.Parameters.Count);
Assert.AreEqual(ConversionType.Explicit, od.ConversionType);
Assert.AreEqual("System.Double", od.TypeReference.Type);
}
[Test]
public void CSharpBinaryPlusOperatorDeclarationTest()
{
OperatorDeclaration od = ParseUtilCSharp.ParseTypeMember<OperatorDeclaration>("public static MyObject operator +(MyObject a, MyObject b) {}");
Assert.IsTrue(!od.IsConversionOperator);
Assert.AreEqual(OverloadableOperatorType.Add, od.OverloadableOperator);
Assert.AreEqual(2, od.Parameters.Count);
Assert.AreEqual("MyObject", od.TypeReference.Type);
Assert.AreEqual("op_Addition", od.Name);
}
[Test]
public void CSharpUnaryPlusOperatorDeclarationTest()
{
OperatorDeclaration od = ParseUtilCSharp.ParseTypeMember<OperatorDeclaration>("public static MyObject operator +(MyObject a) {}");
Assert.IsTrue(!od.IsConversionOperator);
Assert.AreEqual(OverloadableOperatorType.UnaryPlus, od.OverloadableOperator);
Assert.AreEqual(1, od.Parameters.Count);
Assert.AreEqual("MyObject", od.TypeReference.Type);
Assert.AreEqual("op_UnaryPlus", od.Name);
}
#endregion
#region VB.NET
[Test]

92
VB/Test/Parser/TypeLevel/PropertyDeclarationTests.cs

@ -11,98 +11,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom @@ -11,98 +11,6 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
[TestFixture]
public class PropertyDeclarationTests
{
#region C#
[Test]
public void CSharpSimpleGetSetPropertyDeclarationTest()
{
PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember<PropertyDeclaration>("int MyProperty { get {} set {} } ");
Assert.AreEqual("MyProperty", pd.Name);
Assert.IsTrue(pd.HasGetRegion);
Assert.IsTrue(pd.HasSetRegion);
}
[Test]
public void CSharpGetSetPropertyDeclarationWithAccessorModifiers()
{
PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember<PropertyDeclaration>("int MyProperty { private get {} protected internal set {} } ");
Assert.AreEqual("MyProperty", pd.Name);
Assert.IsTrue(pd.HasGetRegion);
Assert.IsTrue(pd.HasSetRegion);
}
[Test]
public void CSharpSimpleGetPropertyDeclarationTest()
{
PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember<PropertyDeclaration>("int MyProperty { get {} } ");
Assert.AreEqual("MyProperty", pd.Name);
Assert.IsTrue(pd.HasGetRegion);
Assert.IsTrue(!pd.HasSetRegion);
}
[Test]
public void CSharpSimpleSetPropertyDeclarationTest()
{
PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember<PropertyDeclaration>("int MyProperty { set {} } ");
Assert.AreEqual("MyProperty", pd.Name);
Assert.IsTrue(!pd.HasGetRegion);
Assert.IsTrue(pd.HasSetRegion);
}
void CSharpPropertyRegionTest(bool parseMethodBodies)
{
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");
IParser p = ParserFactory.CreateParser(new StringReader(code));
p.ParseMethodBodies = parseMethodBodies;
p.Parse();
PropertyDeclaration pd = (PropertyDeclaration)p.CompilationUnit.Children[0].Children[0];
Assert.AreEqual(new Location(code.IndexOf("{\n\t\tget") - line2Pos + 1, 2), pd.BodyStart);
Assert.AreEqual(new Location(3, 5), pd.BodyEnd);
Assert.AreEqual(new Location(code.IndexOf("{ return") - line3Pos + 1, 3), pd.GetRegion.Block.StartLocation);
Assert.AreEqual(new Location(code.IndexOf("}\n\t\tset") + 1 - line3Pos + 1, 3), pd.GetRegion.Block.EndLocation);
Assert.AreEqual(new Location(code.IndexOf("{ f =") - line4Pos + 1, 4), pd.SetRegion.Block.StartLocation);
Assert.AreEqual(new Location(code.IndexOf("}\n\t}") + 1 - line4Pos + 1, 4), pd.SetRegion.Block.EndLocation);
}
[Test]
public void CSharpPropertyRegionTest()
{
CSharpPropertyRegionTest(true);
}
[Test]
public void CSharpPropertyRegionTestSkipParseMethodBodies()
{
CSharpPropertyRegionTest(false);
}
[Test]
public void CSharpPropertyImplementingInterfaceTest()
{
PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember<PropertyDeclaration>("int MyInterface.MyProperty { get {} } ");
Assert.AreEqual("MyProperty", pd.Name);
Assert.IsTrue(pd.HasGetRegion);
Assert.IsTrue(!pd.HasSetRegion);
Assert.AreEqual("MyInterface", pd.InterfaceImplementations[0].InterfaceType.Type);
}
[Test]
public void CSharpPropertyImplementingGenericInterfaceTest()
{
PropertyDeclaration pd = ParseUtilCSharp.ParseTypeMember<PropertyDeclaration>("int MyInterface<string>.MyProperty { get {} } ");
Assert.AreEqual("MyProperty", pd.Name);
Assert.IsTrue(pd.HasGetRegion);
Assert.IsTrue(!pd.HasSetRegion);
Assert.AreEqual("MyInterface", pd.InterfaceImplementations[0].InterfaceType.Type);
Assert.AreEqual("System.String", pd.InterfaceImplementations[0].InterfaceType.GenericTypes[0].Type);
}
#endregion
#region VB.NET
[Test]
public void VBNetSimpleGetSetPropertyDeclarationTest()

Loading…
Cancel
Save