1
// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team
3
// Permission is hereby granted, free of charge, to any person obtaining a copy of this
4
// software and associated documentation files (the "Software"), to deal in the Software
5
// without restriction, including without limitation the rights to use, copy, modify, merge,
6
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
7
// to whom the Software is furnished to do so, subject to the following conditions:
9
// The above copyright notice and this permission notice shall be included in all copies or
10
// substantial portions of the Software.
12
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
13
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
14
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
15
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
16
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
17
// DEALINGS IN THE SOFTWARE.
23
using ICSharpCode.NRefactory.PatternMatching;
24
using NUnit.Framework;
26
namespace ICSharpCode.NRefactory.CSharp.Parser
29
/// Helper methods for parser unit tests.
31
public static class ParseUtilCSharp
33
public static T ParseGlobal<T>(string code, bool expectErrors = false) where T : AstNode
35
CSharpParser parser = new CSharpParser();
36
SyntaxTree syntaxTree = parser.Parse(code);
38
foreach (var error in parser.Errors)
39
Console.WriteLine (error.Message);
40
Assert.AreEqual(expectErrors, parser.HasErrors, "HasErrors");
42
AstNode node = syntaxTree.Children.Single(c => c.Role != Roles.NewLine);
43
Type type = typeof(T);
44
Assert.IsTrue(type.IsAssignableFrom(node.GetType()), String.Format("Parsed node was {0} instead of {1} ({2})", node.GetType(), type, node));
48
public static void AssertGlobal(string code, AstNode expectedNode)
50
var node = ParseGlobal<AstNode>(code);
51
if (!expectedNode.IsMatch(node)) {
52
Assert.Fail("Expected '{0}' but was '{1}'", ToCSharp(expectedNode), ToCSharp(node));
56
public static T ParseStatement<T>(string stmt, bool expectErrors = false) where T : AstNode
58
CSharpParser parser = new CSharpParser();
59
var statements = parser.ParseStatements(stmt);
61
foreach (var error in parser.Errors)
62
Console.WriteLine (error.Message);
63
Assert.AreEqual(expectErrors, parser.HasErrors, "HasErrors");
65
AstNode statement = statements.Single();
66
Type type = typeof(T);
67
Assert.IsTrue(type.IsAssignableFrom(statement.GetType()), String.Format("Parsed statement was {0} instead of {1} ({2})", statement.GetType(), type, statement));
71
public static void AssertStatement(string code, CSharp.Statement expectedStmt)
73
var stmt = ParseStatement<CSharp.Statement>(code);
74
if (!expectedStmt.IsMatch(stmt)) {
75
Assert.Fail("Expected '{0}' but was '{1}'", ToCSharp(expectedStmt), ToCSharp(stmt));
79
public static T ParseExpression<T>(string expr, bool expectErrors = false) where T : AstNode
81
CSharpParser parser = new CSharpParser();
82
AstNode parsedExpression = parser.ParseExpression(expr);
84
foreach (var error in parser.Errors)
85
Console.WriteLine (error.Message);
86
Assert.AreEqual(expectErrors, parser.HasErrors, "HasErrors");
87
if (expectErrors && parsedExpression == null)
89
Type type = typeof(T);
90
Assert.IsTrue(type.IsAssignableFrom(parsedExpression.GetType()), String.Format("Parsed expression was {0} instead of {1} ({2})", parsedExpression.GetType(), type, parsedExpression));
91
return (T)parsedExpression;
94
public static void AssertExpression(string code, CSharp.Expression expectedExpr)
96
var expr = ParseExpression<CSharp.Expression>(code);
97
if (!expectedExpr.IsMatch(expr)) {
98
Assert.Fail("Expected '{0}' but was '{1}'", ToCSharp(expectedExpr), ToCSharp(expr));
102
public static T ParseTypeMember<T>(string expr, bool expectErrors = false) where T : EntityDeclaration
104
CSharpParser parser = new CSharpParser();
105
var members = parser.ParseTypeMembers(expr);
106
foreach (var error in parser.Errors)
107
Console.WriteLine (error.Message);
108
Assert.AreEqual(expectErrors, parser.HasErrors, "HasErrors");
109
EntityDeclaration m = members.Single();
110
Type type = typeof(T);
111
Assert.IsTrue(type.IsAssignableFrom(m.GetType()), String.Format("Parsed member was {0} instead of {1} ({2})", m.GetType(), type, m));
115
public static void AssertTypeMember(string code, CSharp.EntityDeclaration expectedMember)
117
var member = ParseTypeMember<CSharp.EntityDeclaration>(code);
118
if (!expectedMember.IsMatch(member)) {
119
Assert.Fail("Expected '{0}' but was '{1}'", ToCSharp(expectedMember), ToCSharp(member));
123
public static DocumentationReference ParseDocumentationReference(string cref, bool expectErrors = false)
125
CSharpParser parser = new CSharpParser();
126
var parsedExpression = parser.ParseDocumentationReference(cref);
128
foreach (var error in parser.Errors)
129
Console.WriteLine (error.Message);
130
Assert.AreEqual(expectErrors, parser.HasErrors, "HasErrors");
131
if (expectErrors && parsedExpression == null)
133
return parsedExpression;
136
public static void AssertDocumentationReference(string cref, CSharp.DocumentationReference expectedExpr)
138
var expr = ParseDocumentationReference(cref);
139
if (!expectedExpr.IsMatch(expr)) {
140
Assert.Fail("Expected '{0}' but was '{1}'", ToCSharp(expectedExpr), ToCSharp(expr));
144
static string ToCSharp(AstNode node)
146
return node.GetText();