|
|
|
|
@ -20,11 +20,11 @@ using System;
@@ -20,11 +20,11 @@ using System;
|
|
|
|
|
using System.CodeDom; |
|
|
|
|
using System.CodeDom.Compiler; |
|
|
|
|
using System.IO; |
|
|
|
|
using System.Linq; |
|
|
|
|
using System.Text.RegularExpressions; |
|
|
|
|
using ICSharpCode.NRefactory.CSharp.Resolver; |
|
|
|
|
using ICSharpCode.NRefactory.CSharp.TypeSystem; |
|
|
|
|
using ICSharpCode.NRefactory.TypeSystem; |
|
|
|
|
using ICSharpCode.NRefactory.TypeSystem.Implementation; |
|
|
|
|
using Microsoft.CSharp; |
|
|
|
|
using NUnit.Framework; |
|
|
|
|
|
|
|
|
|
@ -45,138 +45,388 @@ namespace ICSharpCode.NRefactory.CSharp
@@ -45,138 +45,388 @@ namespace ICSharpCode.NRefactory.CSharp
|
|
|
|
|
parsedFile.RootUsingScope.Usings.Add(MakeReference("System.Linq")); |
|
|
|
|
|
|
|
|
|
convertVisitor = new CodeDomConvertVisitor(); |
|
|
|
|
convertVisitor.AllowSnippetNodes = false; |
|
|
|
|
convertVisitor.UseFullyQualifiedTypeNames = true; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
string Convert(Expression expr) |
|
|
|
|
#region Helper methods
|
|
|
|
|
string ConvertHelper(AstNode node, Action<CSharpCodeProvider, CodeObject, TextWriter, CodeGeneratorOptions> action) |
|
|
|
|
{ |
|
|
|
|
CSharpResolver resolver = new CSharpResolver(compilation); |
|
|
|
|
resolver = resolver.WithCurrentUsingScope(parsedFile.RootUsingScope.Resolve(compilation)); |
|
|
|
|
resolver = resolver.WithCurrentTypeDefinition(compilation.FindType(KnownTypeCode.Object).GetDefinition()); |
|
|
|
|
var codeExpr = (CodeExpression)convertVisitor.Convert(expr, new CSharpAstResolver(resolver, expr, parsedFile)); |
|
|
|
|
var codeObj = convertVisitor.Convert(node, new CSharpAstResolver(resolver, node)); |
|
|
|
|
|
|
|
|
|
StringWriter writer = new StringWriter(); |
|
|
|
|
writer.NewLine = " "; |
|
|
|
|
new CSharpCodeProvider().GenerateCodeFromExpression(codeExpr, writer, new CodeGeneratorOptions { IndentString = " " }); |
|
|
|
|
return Regex.Replace(writer.ToString(), @"\s+", " "); |
|
|
|
|
action(new CSharpCodeProvider(), codeObj, writer, new CodeGeneratorOptions { IndentString = " " }); |
|
|
|
|
return Regex.Replace(writer.ToString(), @"\s+", " ").Trim(); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
string ConvertExpression(Expression expr) |
|
|
|
|
{ |
|
|
|
|
return ConvertHelper(expr, (p,obj,w,opt) => p.GenerateCodeFromExpression((CodeExpression)obj, w, opt)); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
string ConvertExpression(string code) |
|
|
|
|
{ |
|
|
|
|
CSharpParser parser = new CSharpParser(); |
|
|
|
|
var expr = parser.ParseExpression(new StringReader(code)); |
|
|
|
|
Assert.IsFalse(parser.HasErrors); |
|
|
|
|
return ConvertExpression(expr); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
string ConvertStatement(Statement statement) |
|
|
|
|
{ |
|
|
|
|
return ConvertHelper(statement, (p,obj,w,opt) => p.GenerateCodeFromStatement((CodeStatement)obj, w, opt)); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
string ConvertStatement(string code) |
|
|
|
|
{ |
|
|
|
|
CSharpParser parser = new CSharpParser(); |
|
|
|
|
var expr = parser.ParseStatements(new StringReader(code)).Single(); |
|
|
|
|
Assert.IsFalse(parser.HasErrors); |
|
|
|
|
return ConvertStatement(expr); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
string ConvertMember(EntityDeclaration entity) |
|
|
|
|
{ |
|
|
|
|
return ConvertHelper(entity, (p,obj,w,opt) => p.GenerateCodeFromMember((CodeTypeMember)obj, w, opt)); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
string ConvertMember(string code) |
|
|
|
|
{ |
|
|
|
|
CSharpParser parser = new CSharpParser(); |
|
|
|
|
var expr = parser.ParseTypeMembers(new StringReader(code)).Single(); |
|
|
|
|
Assert.IsFalse(parser.HasErrors); |
|
|
|
|
return ConvertMember(expr); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
string ConvertTypeDeclaration(EntityDeclaration decl) |
|
|
|
|
{ |
|
|
|
|
return ConvertHelper(decl, (p,obj,w,opt) => p.GenerateCodeFromType((CodeTypeDeclaration)obj, w, opt)); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
string ConvertTypeDeclaration(string code) |
|
|
|
|
{ |
|
|
|
|
CSharpParser parser = new CSharpParser(); |
|
|
|
|
var cu = parser.Parse(new StringReader(code), "program.cs"); |
|
|
|
|
Assert.IsFalse(parser.HasErrors); |
|
|
|
|
return ConvertTypeDeclaration((EntityDeclaration)cu.Children.Single()); |
|
|
|
|
} |
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
#region Type References
|
|
|
|
|
[Test] |
|
|
|
|
public void CreateArray() |
|
|
|
|
public void MultidimensionalArrayTypeReference() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("new int[10]", Convert( |
|
|
|
|
new ArrayCreateExpression { |
|
|
|
|
Type = new PrimitiveType("int"), |
|
|
|
|
Arguments = { new PrimitiveExpression(10) } |
|
|
|
|
})); |
|
|
|
|
Assert.AreEqual("default(int[,][])", ConvertExpression("default(int[,][])")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void CreateJaggedArray() |
|
|
|
|
public void NestedTypeInGenericType() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("new int[10][]", Convert( |
|
|
|
|
new ArrayCreateExpression { |
|
|
|
|
Type = new PrimitiveType("int"), |
|
|
|
|
Arguments = { new PrimitiveExpression(10) }, |
|
|
|
|
AdditionalArraySpecifiers = { new ArraySpecifier() } |
|
|
|
|
})); |
|
|
|
|
Assert.AreEqual("default(System.Collections.Generic.List<string>.Enumerator)", |
|
|
|
|
ConvertExpression("default(List<string>.Enumerator)")); |
|
|
|
|
convertVisitor.UseFullyQualifiedTypeNames = false; |
|
|
|
|
Assert.AreEqual("default(List<string>.Enumerator)", |
|
|
|
|
ConvertExpression("default(List<string>.Enumerator)")); |
|
|
|
|
} |
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
#region Arrays
|
|
|
|
|
[Test] |
|
|
|
|
public void CreateArray() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("new int[10]", ConvertExpression("new int[10]")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test, ExpectedException(typeof(NotSupportedException))] |
|
|
|
|
public void CreateJaggedArray() |
|
|
|
|
{ |
|
|
|
|
ConvertExpression("new int[10][]"); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test, ExpectedException(typeof(NotSupportedException))] |
|
|
|
|
public void Create2DArray() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("new int[10, 20]", Convert( |
|
|
|
|
new ArrayCreateExpression { |
|
|
|
|
Type = new PrimitiveType("int"), |
|
|
|
|
Arguments = { new PrimitiveExpression(10), new PrimitiveExpression(20) } |
|
|
|
|
})); |
|
|
|
|
ConvertExpression("new int[10, 20]"); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void CreateImplicitlyTypedArray() |
|
|
|
|
{ |
|
|
|
|
// implicitly-typed array not supported in CodeDom, so the conversion should infer the type
|
|
|
|
|
Assert.AreEqual("new int[] { 1, 2, 3}", Convert( |
|
|
|
|
new ArrayCreateExpression { |
|
|
|
|
AdditionalArraySpecifiers = { new ArraySpecifier() }, |
|
|
|
|
Initializer = new ArrayInitializerExpression { |
|
|
|
|
Elements = { |
|
|
|
|
new PrimitiveExpression(1), |
|
|
|
|
new PrimitiveExpression(2), |
|
|
|
|
new PrimitiveExpression(3) |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
})); |
|
|
|
|
Assert.AreEqual("new int[] { 1, 2, 3}", ConvertExpression("new [] { 1, 2, 3 }")); |
|
|
|
|
Assert.AreEqual("new System.Collections.Generic.List<string>[] { new System.Collections.Generic.List<string>()}", |
|
|
|
|
ConvertExpression("new [] { new List<string>() }")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
[Test, ExpectedException(typeof(NotSupportedException))] |
|
|
|
|
public void Create2DImplicitlyTypedArray() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("new int[,] { { 1, 2 }, { 3, 4 }}", Convert( |
|
|
|
|
new ArrayCreateExpression { |
|
|
|
|
AdditionalArraySpecifiers = { new ArraySpecifier(2) }, |
|
|
|
|
Initializer = new ArrayInitializerExpression { |
|
|
|
|
Elements = { |
|
|
|
|
new ArrayInitializerExpression(new PrimitiveExpression(1), new PrimitiveExpression(2)), |
|
|
|
|
new ArrayInitializerExpression(new PrimitiveExpression(3), new PrimitiveExpression(4)) |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
})); |
|
|
|
|
ConvertExpression("new [,] { { 1, 2 }, { 3, 4 }}"); |
|
|
|
|
} |
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
#region Operators
|
|
|
|
|
[Test] |
|
|
|
|
public void AdditionOperator() |
|
|
|
|
public void ArithmeticOperators() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("(0 + 1)", Convert( |
|
|
|
|
new BinaryOperatorExpression(new PrimitiveExpression(0), BinaryOperatorType.Add, new PrimitiveExpression(1)))); |
|
|
|
|
Assert.AreEqual("(0 + 1)", ConvertExpression("0 + 1")); |
|
|
|
|
Assert.AreEqual("(0 - 1)", ConvertExpression("0 - 1")); |
|
|
|
|
Assert.AreEqual("(0 * 1)", ConvertExpression("0 * 1")); |
|
|
|
|
Assert.AreEqual("(0 / 1)", ConvertExpression("0 / 1")); |
|
|
|
|
Assert.AreEqual("(0 % 1)", ConvertExpression("0 % 1")); |
|
|
|
|
Assert.AreEqual("(0 & 1)", ConvertExpression("0 & 1")); |
|
|
|
|
Assert.AreEqual("(0 | 1)", ConvertExpression("0 | 1")); |
|
|
|
|
Assert.AreEqual("(0 < 1)", ConvertExpression("0 < 1")); |
|
|
|
|
Assert.AreEqual("(0 > 1)", ConvertExpression("0 > 1")); |
|
|
|
|
Assert.AreEqual("(0 <= 1)", ConvertExpression("0 <= 1")); |
|
|
|
|
Assert.AreEqual("(0 >= 1)", ConvertExpression("0 >= 1")); |
|
|
|
|
Assert.AreEqual("(true && false)", ConvertExpression("true && false")); |
|
|
|
|
Assert.AreEqual("(true || false)", ConvertExpression("true || false")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void EqualityOperator() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("(0 == 1)", Convert( |
|
|
|
|
new BinaryOperatorExpression(new PrimitiveExpression(0), BinaryOperatorType.Equality, new PrimitiveExpression(1)))); |
|
|
|
|
Assert.AreEqual("(0 == 1)", ConvertExpression("0 == 1")); |
|
|
|
|
Assert.AreEqual("(default(object) == null)", ConvertExpression("default(object) == null")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void InEqualityOperator() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("((0 == 1) == false)", Convert( |
|
|
|
|
new BinaryOperatorExpression(new PrimitiveExpression(0), BinaryOperatorType.InEquality, new PrimitiveExpression(1)))); |
|
|
|
|
Assert.AreEqual("((0 == 1) == false)", ConvertExpression("0 != 1")); |
|
|
|
|
Assert.AreEqual("(default(object) != null)", ConvertExpression("default(object) != null")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void ReferenceInEqualityOperator() |
|
|
|
|
public void UnaryOperators() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("(default(object) != null)", Convert( |
|
|
|
|
new BinaryOperatorExpression(new DefaultValueExpression(new PrimitiveType("object")), BinaryOperatorType.InEquality, new NullReferenceExpression()))); |
|
|
|
|
Assert.AreEqual("(a == false)", ConvertExpression("!a")); |
|
|
|
|
Assert.AreEqual("(0 - a)", ConvertExpression("-a")); |
|
|
|
|
Assert.AreEqual("a", ConvertExpression("+a")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void Cast() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("((double)(0))", ConvertExpression("(double)0")); |
|
|
|
|
} |
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
#region Member Access
|
|
|
|
|
[Test] |
|
|
|
|
public void StaticProperty() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("System.Environment.TickCount", Convert( |
|
|
|
|
new IdentifierExpression("Environment").Member("TickCount"))); |
|
|
|
|
Assert.AreEqual("System.Environment.TickCount", ConvertExpression("Environment.TickCount")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void InstanceMethodInvocation() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("this.Equals(null)", |
|
|
|
|
Convert(new IdentifierExpression("Equals").Invoke(new NullReferenceExpression()))); |
|
|
|
|
Assert.AreEqual("this.Equals(null)", ConvertExpression("Equals(null)")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void StaticMethodInvocation() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("object.Equals(null, null)", |
|
|
|
|
Convert(new IdentifierExpression("Equals").Invoke(new NullReferenceExpression(), new NullReferenceExpression()))); |
|
|
|
|
Assert.AreEqual("object.Equals(null, null)", ConvertExpression("Equals(null, null)")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void BaseMemberAccess() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("base.X", ConvertExpression("base.X")); |
|
|
|
|
Assert.AreEqual("base[i]", ConvertExpression("base[i]")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void GenericMethodReference() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("this.Stuff<string>", ConvertExpression("this.Stuff<string>")); |
|
|
|
|
Assert.AreEqual("this.Stuff<string>", ConvertExpression("Stuff<string>")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void ByReferenceCall() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("a.Call(ref x, out y, z)", ConvertExpression("a.Call(ref x, out y, z)")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void MemberAccessOnType() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("string.Empty", ConvertExpression("string.Empty")); |
|
|
|
|
} |
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
#region Statements
|
|
|
|
|
[Test] |
|
|
|
|
public void MethodInvocationStatement() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("a.SomeMethod();", ConvertStatement("a.SomeMethod();")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void Assignment() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("a = 1;", ConvertStatement("a = 1;")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test, ExpectedException(typeof(NotSupportedException))] |
|
|
|
|
public void AssignmentNotSupportedInExpression() |
|
|
|
|
{ |
|
|
|
|
ConvertStatement("a = b = 1;"); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void BlockStatement() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("if (true) { a = 1; b = 2; }", |
|
|
|
|
ConvertStatement("{ a = 1; b = 2; }")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void CompoundAssign() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("a = (a + 1);", ConvertStatement("a += 1;")); |
|
|
|
|
Assert.AreEqual("a = (a - 1);", ConvertStatement("a -= 1;")); |
|
|
|
|
Assert.AreEqual("a = (a * 1);", ConvertStatement("a *= 1;")); |
|
|
|
|
Assert.AreEqual("a = (a / 1);", ConvertStatement("a /= 1;")); |
|
|
|
|
Assert.AreEqual("a = (a % 1);", ConvertStatement("a %= 1;")); |
|
|
|
|
Assert.AreEqual("a = (a & 1);", ConvertStatement("a &= 1;")); |
|
|
|
|
Assert.AreEqual("a = (a | 1);", ConvertStatement("a |= 1;")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void Increment() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("a = (a + 1);", ConvertStatement("a++;")); |
|
|
|
|
Assert.AreEqual("a = (a + 1);", ConvertStatement("++a;")); |
|
|
|
|
Assert.AreEqual("a = (a - 1);", ConvertStatement("a--;")); |
|
|
|
|
Assert.AreEqual("a = (a - 1);", ConvertStatement("--a;")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void ForLoop() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("for (int i = 0; (i < 10); i = (i + 1)) { }", |
|
|
|
|
ConvertStatement("for (int i = 0; i < 10; i++) {}")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void WhileLoop() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("for (new object(); (i < 10); new object()) { }", |
|
|
|
|
ConvertStatement("while (i < 10);")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void VariableDeclarationWithArrayInitializer() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("int[] nums = new int[] { 1, 2};", |
|
|
|
|
ConvertStatement("int[] nums = { 1, 2 };")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void TryCatch() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("try { a = 1; } catch (System.Exception ex) { ex.ToString(); }", |
|
|
|
|
ConvertStatement("try { a = 1; } catch (Exception ex) { ex.ToString(); }")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void TryEmptyCatch() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("try { a = 1; } catch (System.Exception ) { }", |
|
|
|
|
ConvertStatement("try { a = 1; } catch (Exception) { }")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void TryFinally() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("try { a = 1; } finally { a = 0; }", |
|
|
|
|
ConvertStatement("try { a = 1; } finally { a = 0; }")); |
|
|
|
|
} |
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
#region Type Members
|
|
|
|
|
[Test] |
|
|
|
|
public void MethodParameterNamedValue() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("void M(string value) { System.Console.WriteLine(value); }", |
|
|
|
|
ConvertMember("void M(string value) { Console.WriteLine(value); }")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void ValueInProperty() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("string P { set { System.Console.WriteLine(value); } }", |
|
|
|
|
ConvertMember("string P { set { Console.WriteLine(value); } }")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void MethodWithAttribute() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("[Test()] void MethodWithAttribute() { }", |
|
|
|
|
ConvertMember("[Test] void MethodWithAttribute() { }")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void PublicNonVirtualMethod() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("public void Method() { }", |
|
|
|
|
ConvertMember("public void Method() { }")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void PublicVirtualMethod() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("public virtual void Method() { }", |
|
|
|
|
ConvertMember("public virtual void Method() { }")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void NestedClass() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("public class Outer { public class Inner { } }", |
|
|
|
|
ConvertTypeDeclaration("class Outer { class Inner { } }")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void Constructor() |
|
|
|
|
{ |
|
|
|
|
string code = "public class Test : Base { public Test(string x) : base(x) { } }"; |
|
|
|
|
Assert.AreEqual(code, ConvertTypeDeclaration(code)); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void Enum() |
|
|
|
|
{ |
|
|
|
|
string code = "public enum E { [Description(\"Text\")] None, B = 2, }"; |
|
|
|
|
Assert.AreEqual(code, ConvertTypeDeclaration(code)); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void Field() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("public class X {" + |
|
|
|
|
" int A;" + |
|
|
|
|
" int B; }", |
|
|
|
|
ConvertMember("public class X { int A, B; }")); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
[Test] |
|
|
|
|
public void NotOperator() |
|
|
|
|
public void Event() |
|
|
|
|
{ |
|
|
|
|
Assert.AreEqual("(a == false)", Convert(new UnaryOperatorExpression(UnaryOperatorType.Not, new IdentifierExpression("a")))); |
|
|
|
|
Assert.AreEqual("public class X {" + |
|
|
|
|
" protected event System.EventHandler A;" + |
|
|
|
|
" protected event System.EventHandler B; }", |
|
|
|
|
ConvertMember("public class X { protected event EventHandler A, B; }")); |
|
|
|
|
} |
|
|
|
|
#endregion
|
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
Mansheng Yang
14 years ago