1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
|
// <file>
// <copyright see="prj:///doc/copyright.txt"/>
// <license see="prj:///doc/license.txt"/>
// <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
// <version>$Revision: 915 $</version>
// </file>
using System;
using System.Drawing;
using System.IO;
using NUnit.Framework;
using ICSharpCode.NRefactory.Parser;
using ICSharpCode.NRefactory.Parser.AST;
namespace ICSharpCode.NRefactory.Tests.AST
{
public class ParseUtilCSharp
{
public static T ParseGlobal<T>(string program) where T : INode
{
return ParseGlobal<T>(program, false);
}
public static T ParseGlobal<T>(string program, bool expectError) where T : INode
{
return ParseGlobal<T>(program, expectError, false);
}
public static T ParseGlobal<T>(string program, bool expectError, bool skipMethodBodies) where T : INode
{
IParser parser = ParserFactory.CreateParser(SupportedLanguage.CSharp, new StringReader(program));
parser.ParseMethodBodies = !skipMethodBodies;
parser.Parse();
Assert.IsNotNull(parser.Errors);
if (expectError)
Assert.IsTrue(parser.Errors.ErrorOutput.Length > 0, "There were errors expected, but parser finished without errors.");
else
Assert.AreEqual("", parser.Errors.ErrorOutput);
Assert.IsNotNull(parser.CompilationUnit);
Assert.IsNotNull(parser.CompilationUnit.Children);
Assert.IsNotNull(parser.CompilationUnit.Children[0]);
Assert.IsTrue(parser.CompilationUnit.Children.Count > 0);
Type type = typeof(T);
Assert.IsTrue(type.IsAssignableFrom(parser.CompilationUnit.Children[0].GetType()), String.Format("Parsed expression was {0} instead of {1} ({2})", parser.CompilationUnit.Children[0].GetType(), type, parser.CompilationUnit.Children[0]));
return (T)parser.CompilationUnit.Children[0];
}
public static T ParseTypeMember<T>(string typeMember) where T : INode
{
return ParseTypeMember<T>(typeMember, false);
}
public static T ParseTypeMember<T>(string typeMember, bool expectError) where T : INode
{
TypeDeclaration td = ParseGlobal<TypeDeclaration>("class MyClass {" + typeMember + "}", expectError);
Assert.IsTrue(td.Children.Count > 0);
Type type = typeof(T);
Assert.IsTrue(type.IsAssignableFrom(td.Children[0].GetType()), String.Format("Parsed expression was {0} instead of {1} ({2})", td.GetType(), type, td));
return (T)td.Children[0];
}
public static T ParseStatement<T>(string statement) where T : INode
{
MethodDeclaration md = ParseTypeMember<MethodDeclaration>("void A() { " + statement + " }");
Assert.IsTrue(md.Body.Children.Count > 0);
Type type = typeof(T);
Assert.IsTrue(type.IsAssignableFrom(md.Body.Children[0].GetType()), String.Format("Parsed expression was {0} instead of {1} ({2})", md.GetType(), type, md));
return (T)md.Body.Children[0];
}
public static T ParseExpression<T>(string expr) where T : INode
{
return ParseExpression<T>(expr, false);
}
public static T ParseExpression<T>(string expr, bool expectErrors) where T : INode
{
IParser parser = ParserFactory.CreateParser(SupportedLanguage.CSharp, new StringReader(expr + ";"));
object parsedExpression = parser.ParseExpression();
if (expectErrors)
Assert.IsTrue(parser.Errors.ErrorOutput.Length > 0, "There were errors expected, but parser finished without errors.");
else
Assert.AreEqual("", parser.Errors.ErrorOutput);
Type type = typeof(T);
Assert.IsTrue(type.IsAssignableFrom(parsedExpression.GetType()), String.Format("Parsed expression was {0} instead of {1} ({2})", parsedExpression.GetType(), type, parsedExpression));
return (T)parsedExpression;
}
}
}
|