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.
21
using NUnit.Framework;
23
namespace ICSharpCode.NRefactory.CSharp
26
public class InsertParenthesesVisitorTests
28
CSharpFormattingOptions policy;
33
policy = FormattingOptionsFactory.CreateMono ();
36
string InsertReadable(Expression expr)
39
expr.AcceptVisitor(new InsertParenthesesVisitor { InsertParenthesesForReadability = true });
40
StringWriter w = new StringWriter();
42
expr.AcceptVisitor(new CSharpOutputVisitor(new TextWriterOutputFormatter(w) { IndentationString = "" }, policy));
46
string InsertRequired(Expression expr)
49
expr.AcceptVisitor(new InsertParenthesesVisitor { InsertParenthesesForReadability = false });
50
StringWriter w = new StringWriter();
52
expr.AcceptVisitor(new CSharpOutputVisitor(new TextWriterOutputFormatter(w) { IndentationString = "" }, policy));
57
public void EqualityInAssignment()
59
Expression expr = new AssignmentExpression(
60
new IdentifierExpression("cond"),
61
new BinaryOperatorExpression(
62
new IdentifierExpression("a"),
63
BinaryOperatorType.Equality,
64
new IdentifierExpression("b")
68
Assert.AreEqual("cond = a == b", InsertRequired(expr));
69
Assert.AreEqual("cond = (a == b)", InsertReadable(expr));
73
public void TrickyCast1()
75
Expression expr = new UnaryOperatorExpression(
76
UnaryOperatorType.Minus, new IdentifierExpression("a")
77
).CastTo(new PrimitiveType("int"));
79
Assert.AreEqual("(int)-a", InsertRequired(expr));
80
Assert.AreEqual("(int)(-a)", InsertReadable(expr));
84
public void TrickyCast2()
86
Expression expr = new UnaryOperatorExpression(
87
UnaryOperatorType.Minus, new IdentifierExpression("a")
88
).CastTo(new SimpleType("MyType"));
90
Assert.AreEqual("(MyType)(-a)", InsertRequired(expr));
91
Assert.AreEqual("(MyType)(-a)", InsertReadable(expr));
95
public void TrickyCast3()
97
Expression expr = new UnaryOperatorExpression(
98
UnaryOperatorType.Not, new IdentifierExpression("a")
99
).CastTo(new SimpleType("MyType"));
101
Assert.AreEqual("(MyType)!a", InsertRequired(expr));
102
Assert.AreEqual("(MyType)(!a)", InsertReadable(expr));
106
public void TrickyCast4()
108
Expression expr = new PrimitiveExpression(int.MinValue).CastTo(new SimpleType("MyType"));
110
Assert.AreEqual("(MyType)(-2147483648)", InsertRequired(expr));
111
Assert.AreEqual("(MyType)(-2147483648)", InsertReadable(expr));
115
public void TrickyCast5()
117
Expression expr = new PrimitiveExpression(-1.0).CastTo(new SimpleType("MyType"));
119
Assert.AreEqual("(MyType)(-1.0)", InsertRequired(expr));
120
Assert.AreEqual("(MyType)(-1.0)", InsertReadable(expr));
124
public void TrickyCast6()
126
Expression expr = new PrimitiveExpression(int.MinValue).CastTo(new PrimitiveType("double"));
128
Assert.AreEqual("(double)-2147483648", InsertRequired(expr));
129
Assert.AreEqual("(double)-2147483648", InsertReadable(expr));
133
public void CastAndInvoke()
135
Expression expr = new IdentifierExpression("a")
136
.CastTo(new PrimitiveType("string"))
139
Assert.AreEqual("((string)a).Length", InsertRequired(expr));
140
Assert.AreEqual("((string)a).Length", InsertReadable(expr));
144
public void DoubleNegation()
146
Expression expr = new UnaryOperatorExpression(
147
UnaryOperatorType.Minus,
148
new UnaryOperatorExpression(UnaryOperatorType.Minus, new IdentifierExpression("a"))
151
Assert.AreEqual("- -a", InsertRequired(expr));
152
Assert.AreEqual("-(-a)", InsertReadable(expr));
156
public void AdditionWithConditional()
158
Expression expr = new BinaryOperatorExpression {
159
Left = new IdentifierExpression("a"),
160
Operator = BinaryOperatorType.Add,
161
Right = new ConditionalExpression {
162
Condition = new BinaryOperatorExpression {
163
Left = new IdentifierExpression("b"),
164
Operator = BinaryOperatorType.Equality,
165
Right = new PrimitiveExpression(null)
167
TrueExpression = new IdentifierExpression("c"),
168
FalseExpression = new IdentifierExpression("d")
172
Assert.AreEqual("a + (b == null ? c : d)", InsertRequired(expr));
173
Assert.AreEqual("a + ((b == null) ? c : d)", InsertReadable(expr));
177
public void TypeTestInConditional()
179
Expression expr = new ConditionalExpression {
180
Condition = new IdentifierExpression("a").IsType(
182
BaseType = new PrimitiveType("int"),
183
HasNullableSpecifier = true
186
TrueExpression = new IdentifierExpression("b"),
187
FalseExpression = new IdentifierExpression("c")
190
Assert.AreEqual("a is int? ? b : c", InsertRequired(expr));
191
Assert.AreEqual("(a is int?) ? b : c", InsertReadable(expr));
193
policy.SpaceBeforeConditionalOperatorCondition = false;
194
policy.SpaceAfterConditionalOperatorCondition = false;
195
policy.SpaceBeforeConditionalOperatorSeparator = false;
196
policy.SpaceAfterConditionalOperatorSeparator = false;
198
Assert.AreEqual("a is int? ?b:c", InsertRequired(expr));
199
Assert.AreEqual("(a is int?)?b:c", InsertReadable(expr));
203
public void MethodCallOnQueryExpression()
205
Expression expr = new QueryExpression {
207
new QueryFromClause {
209
Expression = new IdentifierExpression("b")
211
new QuerySelectClause {
212
Expression = new IdentifierExpression("a").Invoke("c")
217
Assert.AreEqual("( from a in b select a.c ()).ToArray ()", InsertRequired(expr));
218
Assert.AreEqual("( from a in b select a.c ()).ToArray ()", InsertReadable(expr));
222
public void SumOfQueries()
224
QueryExpression query = new QueryExpression {
226
new QueryFromClause {
228
Expression = new IdentifierExpression("b")
230
new QuerySelectClause {
231
Expression = new IdentifierExpression("a")
235
Expression expr = new BinaryOperatorExpression(
237
BinaryOperatorType.Add,
241
Assert.AreEqual("( from a in b select a) + " +
242
" from a in b select a", InsertRequired(expr));
243
Assert.AreEqual("( from a in b select a) + " +
244
"( from a in b select a)", InsertReadable(expr));
248
public void QueryInTypeTest()
250
Expression expr = new QueryExpression {
252
new QueryFromClause {
254
Expression = new IdentifierExpression("b")
256
new QuerySelectClause {
257
Expression = new IdentifierExpression("a")
260
}.IsType(new PrimitiveType("int"));
262
Assert.AreEqual("( from a in b select a) is int", InsertRequired(expr));
263
Assert.AreEqual("( from a in b select a) is int", InsertReadable(expr));
267
public void PrePost()
269
Expression expr = new UnaryOperatorExpression(
270
UnaryOperatorType.Increment,
271
new UnaryOperatorExpression(
272
UnaryOperatorType.PostIncrement,
273
new IdentifierExpression("a")
277
Assert.AreEqual("++a++", InsertRequired(expr));
278
Assert.AreEqual("++(a++)", InsertReadable(expr));
282
public void PostPre()
284
Expression expr = new UnaryOperatorExpression(
285
UnaryOperatorType.PostIncrement,
286
new UnaryOperatorExpression(
287
UnaryOperatorType.Increment,
288
new IdentifierExpression("a")
292
Assert.AreEqual("(++a)++", InsertRequired(expr));
293
Assert.AreEqual("(++a)++", InsertReadable(expr));
297
public void Logical1()
299
Expression expr = new BinaryOperatorExpression(
300
new BinaryOperatorExpression(
301
new IdentifierExpression("a"),
302
BinaryOperatorType.ConditionalAnd,
303
new IdentifierExpression("b")
305
BinaryOperatorType.ConditionalAnd,
306
new IdentifierExpression("c")
309
Assert.AreEqual("a && b && c", InsertRequired(expr));
310
Assert.AreEqual("a && b && c", InsertReadable(expr));
314
public void Logical2()
316
Expression expr = new BinaryOperatorExpression(
317
new IdentifierExpression("a"),
318
BinaryOperatorType.ConditionalAnd,
319
new BinaryOperatorExpression(
320
new IdentifierExpression("b"),
321
BinaryOperatorType.ConditionalAnd,
322
new IdentifierExpression("c")
326
Assert.AreEqual("a && (b && c)", InsertRequired(expr));
327
Assert.AreEqual("a && (b && c)", InsertReadable(expr));
331
public void Logical3()
333
Expression expr = new BinaryOperatorExpression(
334
new IdentifierExpression("a"),
335
BinaryOperatorType.ConditionalOr,
336
new BinaryOperatorExpression(
337
new IdentifierExpression("b"),
338
BinaryOperatorType.ConditionalAnd,
339
new IdentifierExpression("c")
343
Assert.AreEqual("a || b && c", InsertRequired(expr));
344
Assert.AreEqual("a || (b && c)", InsertReadable(expr));
348
public void Logical4()
350
Expression expr = new BinaryOperatorExpression(
351
new IdentifierExpression("a"),
352
BinaryOperatorType.ConditionalAnd,
353
new BinaryOperatorExpression(
354
new IdentifierExpression("b"),
355
BinaryOperatorType.ConditionalOr,
356
new IdentifierExpression("c")
360
Assert.AreEqual("a && (b || c)", InsertRequired(expr));
361
Assert.AreEqual("a && (b || c)", InsertReadable(expr));
365
public void ArrayCreationInIndexer()
367
Expression expr = new IndexerExpression {
368
Target = new ArrayCreateExpression {
369
Type = new PrimitiveType("int"),
370
Arguments = { new PrimitiveExpression(1) }
372
Arguments = { new PrimitiveExpression(0) }
375
Assert.AreEqual("(new int[1]) [0]", InsertRequired(expr));
376
Assert.AreEqual("(new int[1]) [0]", InsertReadable(expr));
380
public void ArrayCreationWithInitializerInIndexer()
382
Expression expr = new IndexerExpression {
383
Target = new ArrayCreateExpression {
384
Type = new PrimitiveType("int"),
385
Arguments = { new PrimitiveExpression(1) },
386
Initializer = new ArrayInitializerExpression {
387
Elements = { new PrimitiveExpression(42) }
390
Arguments = { new PrimitiveExpression(0) }
393
Assert.AreEqual("new int[1] { 42 } [0]", InsertRequired(expr));
394
Assert.AreEqual("(new int[1] { 42 }) [0]", InsertReadable(expr));