← Back to branch summary

~ubuntu-branches/ubuntu/feisty/monodevelop/feisty

« back to all changes in this revision

Viewing changes to Core/src/NRefactory/Test/Parser/Expressions/BinaryOperatorExpressionTests.cs

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge
  • Date: 2006-08-18 00:51:23 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20060818005123-5iit07y0j7wjg55f
Tags: 0.11+svn20060818-0ubuntu1
* New SVN snapshot
  + Works with Gtk# 2.9.0
* debian/control:
  + Updated Build-Depends
* debian/patches/use_nunit2.2.dpatch,
  debian/patches/use_real_libs.dpatch:
  + Updated
* debian/patches/versioncontrol_buildfix.dpatch:
  + Fix build failure in the version control addin

Show diffs side-by-side

added added

removed removed

Lines of Context:
Core/src/NRefactory/Test/Parser/Expressions/BinaryOperatorExpressionTests.cs
 
1
// <file>
 
2
//     <copyright see="prj:///doc/copyright.txt"/>
 
3
//     <license see="prj:///doc/license.txt"/>
 
4
//     <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
 
5
//     <version>$Revision: 972 $</version>
 
6
// </file>
 
7
 
 
8
using System;
 
9
using System.IO;
 
10
using NUnit.Framework;
 
11
using ICSharpCode.NRefactory.Parser;
 
12
using ICSharpCode.NRefactory.Parser.AST;
 
13
using ICSharpCode.NRefactory.PrettyPrinter;
 
14
 
 
15
namespace ICSharpCode.NRefactory.Tests.AST
 
16
{
 
17
        [TestFixture]
 
18
        public class BinaryOperatorExpressionTests
 
19
        {
 
20
                void OperatorPrecedenceTest(string strongOperator, BinaryOperatorType strongOperatorType,
 
21
                                            string weakOperator, BinaryOperatorType weakOperatorType, bool vb)
 
22
                {
 
23
                        string program = "a " + weakOperator + " b " + strongOperator + " c";
 
24
                        BinaryOperatorExpression boe;
 
25
                        if (vb)
 
26
                                boe = ParseUtilVBNet.ParseExpression<BinaryOperatorExpression>(program);
 
27
                        else
 
28
                                boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>(program);
 
29
                        Assert.AreEqual(weakOperatorType, boe.Op);
 
30
                        Assert.IsTrue(boe.Left is IdentifierExpression);
 
31
                        boe = (BinaryOperatorExpression)boe.Right;
 
32
                        Assert.AreEqual(strongOperatorType, boe.Op);
 
33
                        Assert.IsTrue(boe.Left is IdentifierExpression);
 
34
                        Assert.IsTrue(boe.Right is IdentifierExpression);
 
35
                        
 
36
                        program = "a " + strongOperator + " b " + weakOperator + " c";
 
37
                        if (vb)
 
38
                                boe = ParseUtilVBNet.ParseExpression<BinaryOperatorExpression>(program);
 
39
                        else
 
40
                                boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>(program);
 
41
                        Assert.AreEqual(weakOperatorType, boe.Op);
 
42
                        Assert.IsTrue(boe.Right is IdentifierExpression);
 
43
                        boe = (BinaryOperatorExpression)boe.Left;
 
44
                        Assert.AreEqual(strongOperatorType, boe.Op);
 
45
                        Assert.IsTrue(boe.Left is IdentifierExpression);
 
46
                        Assert.IsTrue(boe.Right is IdentifierExpression);
 
47
                }
 
48
                
 
49
                void SameOperatorPrecedenceTest(string firstOperator, BinaryOperatorType firstOperatorType,
 
50
                                                string secondOperator, BinaryOperatorType secondOperatorType, bool vb)
 
51
                {
 
52
                        string program = "a " + secondOperator + " b " + firstOperator + " c";
 
53
                        BinaryOperatorExpression boe;
 
54
                        if (vb)
 
55
                                boe = ParseUtilVBNet.ParseExpression<BinaryOperatorExpression>(program);
 
56
                        else
 
57
                                boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>(program);
 
58
                        Assert.AreEqual(firstOperatorType, boe.Op);
 
59
                        Assert.IsTrue(boe.Right is IdentifierExpression);
 
60
                        boe = (BinaryOperatorExpression)boe.Left;
 
61
                        Assert.AreEqual(secondOperatorType, boe.Op);
 
62
                        Assert.IsTrue(boe.Left is IdentifierExpression);
 
63
                        Assert.IsTrue(boe.Right is IdentifierExpression);
 
64
                        
 
65
                        program = "a " + firstOperator + " b " + secondOperator + " c";
 
66
                        if (vb)
 
67
                                boe = ParseUtilVBNet.ParseExpression<BinaryOperatorExpression>(program);
 
68
                        else
 
69
                                boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>(program);
 
70
                        Assert.AreEqual(secondOperatorType, boe.Op);
 
71
                        Assert.IsTrue(boe.Right is IdentifierExpression);
 
72
                        boe = (BinaryOperatorExpression)boe.Left;
 
73
                        Assert.AreEqual(firstOperatorType, boe.Op);
 
74
                        Assert.IsTrue(boe.Left is IdentifierExpression);
 
75
                        Assert.IsTrue(boe.Right is IdentifierExpression);
 
76
                }
 
77
                
 
78
                #region C#
 
79
                void CSharpTestBinaryOperatorExpressionTest(string program, BinaryOperatorType op)
 
80
                {
 
81
                        BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>(program);
 
82
                        Assert.AreEqual(op, boe.Op);
 
83
                        
 
84
                        Assert.IsTrue(boe.Left is IdentifierExpression);
 
85
                        Assert.IsTrue(boe.Right is IdentifierExpression);
 
86
                        
 
87
                }
 
88
                
 
89
                [Test]
 
90
                public void CSharpOperatorPrecedenceTest()
 
91
                {
 
92
                        SameOperatorPrecedenceTest("*", BinaryOperatorType.Multiply, "/", BinaryOperatorType.Divide, false);
 
93
                        SameOperatorPrecedenceTest("*", BinaryOperatorType.Multiply, "%", BinaryOperatorType.Modulus, false);
 
94
                        OperatorPrecedenceTest("*", BinaryOperatorType.Multiply, "+", BinaryOperatorType.Add, false);
 
95
                        SameOperatorPrecedenceTest("-", BinaryOperatorType.Subtract, "+", BinaryOperatorType.Add, false);
 
96
                        OperatorPrecedenceTest("+", BinaryOperatorType.Add, "<<", BinaryOperatorType.ShiftLeft, false);
 
97
                        SameOperatorPrecedenceTest(">>", BinaryOperatorType.ShiftRight, "<<", BinaryOperatorType.ShiftLeft, false);
 
98
                        OperatorPrecedenceTest("<<", BinaryOperatorType.ShiftLeft, "==", BinaryOperatorType.Equality, false);
 
99
                        SameOperatorPrecedenceTest("!=", BinaryOperatorType.InEquality, "==", BinaryOperatorType.Equality, false);
 
100
                        OperatorPrecedenceTest("==", BinaryOperatorType.Equality, "&", BinaryOperatorType.BitwiseAnd, false);
 
101
                        OperatorPrecedenceTest("&", BinaryOperatorType.BitwiseAnd, "^", BinaryOperatorType.ExclusiveOr, false);
 
102
                        OperatorPrecedenceTest("^", BinaryOperatorType.ExclusiveOr, "|", BinaryOperatorType.BitwiseOr, false);
 
103
                        OperatorPrecedenceTest("|", BinaryOperatorType.BitwiseOr, "&&", BinaryOperatorType.LogicalAnd, false);
 
104
                        OperatorPrecedenceTest("&&", BinaryOperatorType.LogicalAnd, "||", BinaryOperatorType.LogicalOr, false);
 
105
                        OperatorPrecedenceTest("||", BinaryOperatorType.LogicalOr, "??", BinaryOperatorType.NullCoalescing, false);
 
106
                }
 
107
                
 
108
                [Test]
 
109
                public void CSharpSubtractionLeftToRight()
 
110
                {
 
111
                        BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>("a - b - c");
 
112
                        Assert.IsTrue(boe.Right is IdentifierExpression);
 
113
                        Assert.IsTrue(boe.Left is BinaryOperatorExpression);
 
114
                }
 
115
                
 
116
                [Test]
 
117
                public void CSharpNullCoalescingRightToLeft()
 
118
                {
 
119
                        BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>("a ?? b ?? c");
 
120
                        Assert.IsTrue(boe.Left is IdentifierExpression);
 
121
                        Assert.IsTrue(boe.Right is BinaryOperatorExpression);
 
122
                }
 
123
                
 
124
                [Test]
 
125
                public void CSharpBitwiseAndTest()
 
126
                {
 
127
                        CSharpTestBinaryOperatorExpressionTest("a & b", BinaryOperatorType.BitwiseAnd);
 
128
                }
 
129
                
 
130
                [Test]
 
131
                public void CSharpBitwiseOrTest()
 
132
                {
 
133
                        CSharpTestBinaryOperatorExpressionTest("a | b", BinaryOperatorType.BitwiseOr);
 
134
                }
 
135
                
 
136
                [Test]
 
137
                public void CSharpLogicalAndTest()
 
138
                {
 
139
                        CSharpTestBinaryOperatorExpressionTest("a && b", BinaryOperatorType.LogicalAnd);
 
140
                }
 
141
                
 
142
                [Test]
 
143
                public void CSharpLogicalOrTest()
 
144
                {
 
145
                        CSharpTestBinaryOperatorExpressionTest("a || b", BinaryOperatorType.LogicalOr);
 
146
                }
 
147
                
 
148
                [Test]
 
149
                public void CSharpExclusiveOrTest()
 
150
                {
 
151
                        CSharpTestBinaryOperatorExpressionTest("a ^ b", BinaryOperatorType.ExclusiveOr);
 
152
                }
 
153
                
 
154
                
 
155
                [Test]
 
156
                public void CSharpGreaterThanTest()
 
157
                {
 
158
                        CSharpTestBinaryOperatorExpressionTest("a > b", BinaryOperatorType.GreaterThan);
 
159
                }
 
160
                
 
161
                [Test]
 
162
                public void CSharpGreaterThanOrEqualTest()
 
163
                {
 
164
                        CSharpTestBinaryOperatorExpressionTest("a >= b", BinaryOperatorType.GreaterThanOrEqual);
 
165
                }
 
166
                
 
167
                [Test]
 
168
                public void CSharpEqualityTest()
 
169
                {
 
170
                        CSharpTestBinaryOperatorExpressionTest("a == b", BinaryOperatorType.Equality);
 
171
                }
 
172
                
 
173
                [Test]
 
174
                public void CSharpInEqualityTest()
 
175
                {
 
176
                        CSharpTestBinaryOperatorExpressionTest("a != b", BinaryOperatorType.InEquality);
 
177
                }
 
178
                
 
179
                [Test]
 
180
                public void CSharpLessThanTest()
 
181
                {
 
182
                        CSharpTestBinaryOperatorExpressionTest("a < b", BinaryOperatorType.LessThan);
 
183
                }
 
184
                
 
185
                [Test]
 
186
                public void CSharpLessThanOrEqualTest()
 
187
                {
 
188
                        CSharpTestBinaryOperatorExpressionTest("a <= b", BinaryOperatorType.LessThanOrEqual);
 
189
                }
 
190
                
 
191
                [Test]
 
192
                public void CSharpAddTest()
 
193
                {
 
194
                        CSharpTestBinaryOperatorExpressionTest("a + b", BinaryOperatorType.Add);
 
195
                }
 
196
                
 
197
                [Test]
 
198
                public void CSharpSubtractTest()
 
199
                {
 
200
                        CSharpTestBinaryOperatorExpressionTest("a - b", BinaryOperatorType.Subtract);
 
201
                }
 
202
                
 
203
                [Test]
 
204
                public void CSharpMultiplyTest()
 
205
                {
 
206
                        CSharpTestBinaryOperatorExpressionTest("a * b", BinaryOperatorType.Multiply);
 
207
                }
 
208
                
 
209
                [Test]
 
210
                public void CSharpDivideTest()
 
211
                {
 
212
                        CSharpTestBinaryOperatorExpressionTest("a / b", BinaryOperatorType.Divide);
 
213
                }
 
214
                
 
215
                [Test]
 
216
                public void CSharpModulusTest()
 
217
                {
 
218
                        CSharpTestBinaryOperatorExpressionTest("a % b", BinaryOperatorType.Modulus);
 
219
                }
 
220
                
 
221
                [Test]
 
222
                public void CSharpShiftLeftTest()
 
223
                {
 
224
                        CSharpTestBinaryOperatorExpressionTest("a << b", BinaryOperatorType.ShiftLeft);
 
225
                }
 
226
                
 
227
                [Test]
 
228
                public void CSharpShiftRightTest()
 
229
                {
 
230
                        CSharpTestBinaryOperatorExpressionTest("a >> b", BinaryOperatorType.ShiftRight);
 
231
                }
 
232
                
 
233
                [Test]
 
234
                public void CSharpNullCoalescingTest()
 
235
                {
 
236
                        CSharpTestBinaryOperatorExpressionTest("a ?? b", BinaryOperatorType.NullCoalescing);
 
237
                }
 
238
                #endregion
 
239
                
 
240
                #region VB.NET
 
241
                void VBNetTestBinaryOperatorExpressionTest(string program, BinaryOperatorType op)
 
242
                {
 
243
                        BinaryOperatorExpression boe = ParseUtilVBNet.ParseExpression<BinaryOperatorExpression>(program);
 
244
                        Assert.AreEqual(op, boe.Op);
 
245
                        
 
246
                        Assert.IsTrue(boe.Left is IdentifierExpression);
 
247
                        Assert.IsTrue(boe.Right is IdentifierExpression);
 
248
                        
 
249
                }
 
250
                
 
251
                [Test]
 
252
                public void VBOperatorPrecedenceTest()
 
253
                {
 
254
                        OperatorPrecedenceTest("^", BinaryOperatorType.Power, "*", BinaryOperatorType.Multiply, true);
 
255
                        SameOperatorPrecedenceTest("*", BinaryOperatorType.Multiply, "/", BinaryOperatorType.Divide, true);
 
256
                        OperatorPrecedenceTest("/", BinaryOperatorType.Divide, "\\", BinaryOperatorType.DivideInteger, true);
 
257
                        OperatorPrecedenceTest("\\", BinaryOperatorType.DivideInteger, "Mod", BinaryOperatorType.Modulus, true);
 
258
                        OperatorPrecedenceTest("Mod", BinaryOperatorType.Modulus, "+", BinaryOperatorType.Add, true);
 
259
                        SameOperatorPrecedenceTest("+", BinaryOperatorType.Add, "-", BinaryOperatorType.Subtract, true);
 
260
                        OperatorPrecedenceTest("-", BinaryOperatorType.Subtract, "&", BinaryOperatorType.Concat, true);
 
261
                        OperatorPrecedenceTest("&", BinaryOperatorType.Concat, "<<", BinaryOperatorType.ShiftLeft, true);
 
262
                        SameOperatorPrecedenceTest("<<", BinaryOperatorType.ShiftLeft, ">>", BinaryOperatorType.ShiftRight, true);
 
263
                        OperatorPrecedenceTest("<<", BinaryOperatorType.ShiftLeft, "=", BinaryOperatorType.Equality, true);
 
264
                        SameOperatorPrecedenceTest("<>", BinaryOperatorType.InEquality, "=", BinaryOperatorType.Equality, true);
 
265
                        SameOperatorPrecedenceTest("<", BinaryOperatorType.LessThan, "=", BinaryOperatorType.Equality, true);
 
266
                        SameOperatorPrecedenceTest("<=", BinaryOperatorType.LessThanOrEqual, "=", BinaryOperatorType.Equality, true);
 
267
                        SameOperatorPrecedenceTest(">", BinaryOperatorType.GreaterThan, "=", BinaryOperatorType.Equality, true);
 
268
                        SameOperatorPrecedenceTest(">=", BinaryOperatorType.GreaterThanOrEqual, "=", BinaryOperatorType.Equality, true);
 
269
                        SameOperatorPrecedenceTest("Like", BinaryOperatorType.Like, "=", BinaryOperatorType.Equality, true);
 
270
                        SameOperatorPrecedenceTest("Is", BinaryOperatorType.ReferenceEquality, "=", BinaryOperatorType.Equality, true);
 
271
                        SameOperatorPrecedenceTest("IsNot", BinaryOperatorType.ReferenceInequality, "=", BinaryOperatorType.Equality, true);
 
272
                        OperatorPrecedenceTest("=", BinaryOperatorType.Equality, "And", BinaryOperatorType.BitwiseAnd, true);
 
273
                        SameOperatorPrecedenceTest("And", BinaryOperatorType.BitwiseAnd, "AndAlso", BinaryOperatorType.LogicalAnd, true);
 
274
                        OperatorPrecedenceTest("And", BinaryOperatorType.BitwiseAnd, "Or", BinaryOperatorType.BitwiseOr, true);
 
275
                        SameOperatorPrecedenceTest("Or", BinaryOperatorType.BitwiseOr, "OrElse", BinaryOperatorType.LogicalOr, true);
 
276
                        SameOperatorPrecedenceTest("Or", BinaryOperatorType.BitwiseOr, "Xor", BinaryOperatorType.ExclusiveOr, true);
 
277
                }
 
278
                
 
279
                [Test]
 
280
                public void VBNetTest()
 
281
                {
 
282
                        VBNetTestBinaryOperatorExpressionTest("a ^ b", BinaryOperatorType.Power);
 
283
                }
 
284
                
 
285
                [Test]
 
286
                public void VBNetPowerTest()
 
287
                {
 
288
                        VBNetTestBinaryOperatorExpressionTest("a ^ b", BinaryOperatorType.Power);
 
289
                }
 
290
                
 
291
                [Test]
 
292
                public void VBNetConcatTest()
 
293
                {
 
294
                        VBNetTestBinaryOperatorExpressionTest("a & b", BinaryOperatorType.Concat);
 
295
                }
 
296
                
 
297
                [Test]
 
298
                public void VBNetLogicalAndTest()
 
299
                {
 
300
                        VBNetTestBinaryOperatorExpressionTest("a AndAlso b", BinaryOperatorType.LogicalAnd);
 
301
                }
 
302
                [Test]
 
303
                public void VBNetLogicalAndNotLazyTest()
 
304
                {
 
305
                        VBNetTestBinaryOperatorExpressionTest("a And b", BinaryOperatorType.BitwiseAnd);
 
306
                }
 
307
                
 
308
                [Test]
 
309
                public void VBNetLogicalOrTest()
 
310
                {
 
311
                        VBNetTestBinaryOperatorExpressionTest("a OrElse b", BinaryOperatorType.LogicalOr);
 
312
                }
 
313
                [Test]
 
314
                public void VBNetLogicalOrNotLazyTest()
 
315
                {
 
316
                        VBNetTestBinaryOperatorExpressionTest("a Or b", BinaryOperatorType.BitwiseOr);
 
317
                }
 
318
                
 
319
                [Test]
 
320
                public void VBNetExclusiveOrTest()
 
321
                {
 
322
                        VBNetTestBinaryOperatorExpressionTest("a Xor b", BinaryOperatorType.ExclusiveOr);
 
323
                }
 
324
                
 
325
                
 
326
                [Test]
 
327
                public void VBNetGreaterThanTest()
 
328
                {
 
329
                        VBNetTestBinaryOperatorExpressionTest("a > b", BinaryOperatorType.GreaterThan);
 
330
                }
 
331
                
 
332
                [Test]
 
333
                public void VBNetGreaterThanOrEqualTest()
 
334
                {
 
335
                        VBNetTestBinaryOperatorExpressionTest("a >= b", BinaryOperatorType.GreaterThanOrEqual);
 
336
                }
 
337
                
 
338
                [Test]
 
339
                public void VBNetEqualityTest()
 
340
                {
 
341
                        VBNetTestBinaryOperatorExpressionTest("a = b", BinaryOperatorType.Equality);
 
342
                }
 
343
                
 
344
                [Test]
 
345
                public void VBNetInEqualityTest()
 
346
                {
 
347
                        VBNetTestBinaryOperatorExpressionTest("a <> b", BinaryOperatorType.InEquality);
 
348
                }
 
349
                
 
350
                [Test]
 
351
                public void VBNetLessThanTest()
 
352
                {
 
353
                        VBNetTestBinaryOperatorExpressionTest("a < b", BinaryOperatorType.LessThan);
 
354
                }
 
355
                
 
356
                [Test]
 
357
                public void VBNetLessThanOrEqualTest()
 
358
                {
 
359
                        VBNetTestBinaryOperatorExpressionTest("a <= b", BinaryOperatorType.LessThanOrEqual);
 
360
                }
 
361
                
 
362
                [Test]
 
363
                public void VBNetAddTest()
 
364
                {
 
365
                        VBNetTestBinaryOperatorExpressionTest("a + b", BinaryOperatorType.Add);
 
366
                }
 
367
                
 
368
                [Test]
 
369
                public void VBNetSubtractTest()
 
370
                {
 
371
                        VBNetTestBinaryOperatorExpressionTest("a - b", BinaryOperatorType.Subtract);
 
372
                }
 
373
                
 
374
                [Test]
 
375
                public void VBNetMultiplyTest()
 
376
                {
 
377
                        VBNetTestBinaryOperatorExpressionTest("a * b", BinaryOperatorType.Multiply);
 
378
                }
 
379
                
 
380
                [Test]
 
381
                public void VBNetDivideTest()
 
382
                {
 
383
                        VBNetTestBinaryOperatorExpressionTest("a / b", BinaryOperatorType.Divide);
 
384
                }
 
385
                
 
386
                [Test]
 
387
                public void VBNetDivideIntegerTest()
 
388
                {
 
389
                        VBNetTestBinaryOperatorExpressionTest("a \\ b", BinaryOperatorType.DivideInteger);
 
390
                }
 
391
                
 
392
                [Test]
 
393
                public void VBNetModulusTest()
 
394
                {
 
395
                        VBNetTestBinaryOperatorExpressionTest("a Mod b", BinaryOperatorType.Modulus);
 
396
                }
 
397
                
 
398
                [Test]
 
399
                public void VBNetShiftLeftTest()
 
400
                {
 
401
                        VBNetTestBinaryOperatorExpressionTest("a << b", BinaryOperatorType.ShiftLeft);
 
402
                }
 
403
                
 
404
                [Test]
 
405
                public void VBNetShiftRightTest()
 
406
                {
 
407
                        VBNetTestBinaryOperatorExpressionTest("a >> b", BinaryOperatorType.ShiftRight);
 
408
                }
 
409
                
 
410
                [Test]
 
411
                public void VBNetISTest()
 
412
                {
 
413
                        VBNetTestBinaryOperatorExpressionTest("a is b", BinaryOperatorType.ReferenceEquality);
 
414
                }
 
415
                
 
416
                [Test]
 
417
                public void VBNetISNotTest()
 
418
                {
 
419
                        VBNetTestBinaryOperatorExpressionTest("a IsNot b", BinaryOperatorType.ReferenceInequality);
 
420
                }
 
421
                
 
422
                [Test]
 
423
                public void VBNetLikeTest()
 
424
                {
 
425
                        VBNetTestBinaryOperatorExpressionTest("a Like b", BinaryOperatorType.Like);
 
426
                }
 
427
                #endregion
 
428
                
 
429
                
 
430
                #region AddIntegerTests
 
431
                string AddIntegerToBoe(string input, int number)
 
432
                {
 
433
                        return AddInteger<BinaryOperatorExpression>(input, number);
 
434
                }
 
435
                
 
436
                string AddInteger<T>(string input, int number) where T : Expression
 
437
                {
 
438
                        Expression e = ParseUtilCSharp.ParseExpression<T>(input);
 
439
                        e = Expression.AddInteger(e, number);
 
440
                        CSharpOutputVisitor v = new CSharpOutputVisitor();
 
441
                        e.AcceptVisitor(v, null);
 
442
                        return v.Text;
 
443
                }
 
444
                
 
445
                [Test]
 
446
                public void AddInteger()
 
447
                {
 
448
                        Assert.AreEqual("a + 2", AddIntegerToBoe("a + 1", 1));
 
449
                        Assert.AreEqual("a + 2", AddIntegerToBoe("a + 3", -1));
 
450
                        Assert.AreEqual("a + b + c + 2", AddIntegerToBoe("a + b + c + 1", 1));
 
451
                        Assert.AreEqual("a", AddIntegerToBoe("a + 1", -1));
 
452
                        Assert.AreEqual("2", AddInteger<PrimitiveExpression>("1", 1));
 
453
                        Assert.AreEqual("-1", AddInteger<PrimitiveExpression>("1", -2));
 
454
                        Assert.AreEqual("0", AddInteger<PrimitiveExpression>("1", -1));
 
455
                        Assert.AreEqual("a + 1", AddInteger<IdentifierExpression>("a", 1));
 
456
                }
 
457
                
 
458
                [Test]
 
459
                public void AddIntegerWithNegativeResult()
 
460
                {
 
461
                        Assert.AreEqual("a - 1", AddIntegerToBoe("a + 1", -2));
 
462
                        Assert.AreEqual("a - 2", AddIntegerToBoe("a - 1", -1));
 
463
                        Assert.AreEqual("a + b + c - 2", AddIntegerToBoe("a + b + c + 2", -4));
 
464
                        Assert.AreEqual("a + b + c - 6", AddIntegerToBoe("a + b + c - 2", -4));
 
465
                        Assert.AreEqual("a + b + c", AddIntegerToBoe("a + b + c + 2", -2));
 
466
                        Assert.AreEqual("a", AddIntegerToBoe("a - 1", 1));
 
467
                        Assert.AreEqual("a + 1", AddIntegerToBoe("a - 2", 3));
 
468
                        Assert.AreEqual("a - 1", AddInteger<IdentifierExpression>("a", -1));
 
469
                }
 
470
                #endregion
 
471
        }
 
472
}