← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/AddIns/BackendBindings/VBNetBinding/Test/FormattingStrategy/EndOperatorTests.cs

  • Committer: sk
  • Date: 2011-09-10 05:17:57 UTC
  • Revision ID: halega@halega.com-20110910051757-qfouz1llya9m6boy
4.1.0.7915 Release Candidate 1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/AddIns/BackendBindings/VBNetBinding/Test/FormattingStrategy/EndOperatorTests.cs
 
1
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 
2
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
3
 
 
4
using ICSharpCode.SharpDevelop.Editor.AvalonEdit;
 
5
using System;
 
6
using ICSharpCode.AvalonEdit;
 
7
using ICSharpCode.Core;
 
8
using NUnit.Framework;
 
9
 
 
10
namespace ICSharpCode.VBNetBinding.Tests
 
11
{
 
12
        /// <summary>
 
13
        /// Tests that Operator overrides have "End Operator" added after the user presses the return key.
 
14
        /// </summary>
 
15
        [TestFixture]
 
16
        public class EndOperatorTests
 
17
        {
 
18
                [TestFixtureSetUp]
 
19
                public void SetUpFixture()
 
20
                {
 
21
                        if (!PropertyService.Initialized) {
 
22
                                PropertyService.InitializeService(String.Empty, String.Empty, "VBNetBindingTests");
 
23
                        }
 
24
                }
 
25
 
 
26
                /// <summary>
 
27
                /// Checks that when the user presses the return key after the Operator line that the
 
28
                /// expected code is generated.
 
29
                /// </summary>
 
30
                void RunFormatLineTest(string code, string expectedCode, int expectedOffset)
 
31
                {
 
32
                        string foo = "As Foo\r\n";
 
33
                        int cursorOffset = code.IndexOf(foo) + foo.Length;
 
34
 
 
35
                        AvalonEditTextEditorAdapter editor = new AvalonEditTextEditorAdapter(new TextEditor());
 
36
                        editor.Document.Text = code;
 
37
                        editor.Caret.Offset = cursorOffset;
 
38
                        VBNetFormattingStrategy formattingStrategy = new VBNetFormattingStrategy();
 
39
                        formattingStrategy.FormatLine(editor, '\n');
 
40
                        
 
41
                        Assert.AreEqual(expectedCode, editor.Document.Text);
 
42
                        Assert.AreEqual(expectedOffset, editor.Caret.Offset);
 
43
                }
 
44
                
 
45
                [Test]
 
46
                public void AdditionOperator()
 
47
                {
 
48
                        string code = "Public Class Foo\r\n" +
 
49
                                "\tPublic Shared Operator +(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
50
                                "\r\n" + // This extra new line is required. This is the new line just entered by the user.
 
51
                                "End Class";
 
52
                        
 
53
                        string expectedCode = "Public Class Foo\r\n" +
 
54
                                "\tPublic Shared Operator +(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
55
                                "\t\t\r\n" +
 
56
                                "\tEnd Operator\r\n" +
 
57
                                "End Class";
 
58
                        
 
59
                        int expectedOffset = ("Public Class Foo\r\n" +
 
60
                                              "\tPublic Shared Operator +(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
61
                                              "\t\t").Length;
 
62
                        
 
63
                        RunFormatLineTest(code, expectedCode, expectedOffset);
 
64
                }
 
65
                
 
66
                [Test]
 
67
                public void AdditionOperatorWithExistingEndOperator()
 
68
                {
 
69
                        string code = "Public Class Foo\r\n" +
 
70
                                "\tPublic Shared Operator +(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
71
                                "\r\n" + // This extra new line is required. This is the new line just entered by the user.
 
72
                                "\tEnd Operator\r\n" +
 
73
                                "End Class";
 
74
                        
 
75
                        string expectedCode = "Public Class Foo\r\n" +
 
76
                                "\tPublic Shared Operator +(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
77
                                "\t\t\r\n" +
 
78
                                "\tEnd Operator\r\n" +
 
79
                                "End Class";
 
80
                        
 
81
                        int expectedOffset = ("Public Class Foo\r\n" +
 
82
                                              "\tPublic Shared Operator +(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
83
                                              "\t\t").Length;
 
84
                        
 
85
                        RunFormatLineTest(code, expectedCode, expectedOffset);
 
86
                }
 
87
 
 
88
                [Test]
 
89
                public void ExistingEndOperatorHasWhitespaceInbetween()
 
90
                {
 
91
                        string code = "Public Class Foo\r\n" +
 
92
                                "\tPublic Shared Operator +(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
93
                                "\r\n" + // This extra new line is required. This is the new line just entered by the user.
 
94
                                "\tEnd      Operator\r\n" +
 
95
                                "End Class";
 
96
                        
 
97
                        string expectedCode = "Public Class Foo\r\n" +
 
98
                                "\tPublic Shared Operator +(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
99
                                "\t\t\r\n" +
 
100
                                "\tEnd      Operator\r\n" +
 
101
                                "End Class";
 
102
                        
 
103
                        int expectedOffset = ("Public Class Foo\r\n" +
 
104
                                              "\tPublic Shared Operator +(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
105
                                              "\t\t").Length;
 
106
                        
 
107
                        RunFormatLineTest(code, expectedCode, expectedOffset);
 
108
                }
 
109
 
 
110
                [Test]
 
111
                public void AdditionOperatorHasWhitespaceAfterOperator()
 
112
                {
 
113
                        string code = "Public Class Foo\r\n" +
 
114
                                "\tPublic Shared Operator + (ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
115
                                "\r\n" + // This extra new line is required. This is the new line just entered by the user.
 
116
                                "End Class";
 
117
                        
 
118
                        string expectedCode = "Public Class Foo\r\n" +
 
119
                                "\tPublic Shared Operator + (ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
120
                                "\t\t\r\n" +
 
121
                                "\tEnd Operator\r\n" +
 
122
                                "End Class";
 
123
                        
 
124
                        int expectedOffset = ("Public Class Foo\r\n" +
 
125
                                              "\tPublic Shared Operator + (ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
126
                                              "\t\t").Length;
 
127
                        
 
128
                        RunFormatLineTest(code, expectedCode, expectedOffset);
 
129
                }
 
130
                
 
131
                [Test]
 
132
                public void AdditionOperatorWithNoWhitespace()
 
133
                {
 
134
                        string code = "Public Class Foo\r\n" +
 
135
                                "\tPublic Shared Operator+(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
136
                                "\r\n" + // This extra new line is required. This is the new line just entered by the user.
 
137
                                "End Class";
 
138
                        
 
139
                        string expectedCode = "Public Class Foo\r\n" +
 
140
                                "\tPublic Shared Operator+(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
141
                                "\t\t\r\n" +
 
142
                                "\tEnd Operator\r\n" +
 
143
                                "End Class";
 
144
                        
 
145
                        int expectedOffset = ("Public Class Foo\r\n" +
 
146
                                              "\tPublic Shared Operator+(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
147
                                              "\t\t").Length;
 
148
                        
 
149
                        RunFormatLineTest(code, expectedCode, expectedOffset);
 
150
                }
 
151
                
 
152
                [Test]
 
153
                public void SubtractionOperator()
 
154
                {
 
155
                        string code = "Public Class Foo\r\n" +
 
156
                                "\tPublic Shared Operator -(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
157
                                "\r\n" + // This extra new line is required. This is the new line just entered by the user.
 
158
                                "End Class";
 
159
                        
 
160
                        string expectedCode = "Public Class Foo\r\n" +
 
161
                                "\tPublic Shared Operator -(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
162
                                "\t\t\r\n" +
 
163
                                "\tEnd Operator\r\n" +
 
164
                                "End Class";
 
165
                        
 
166
                        int expectedOffset = ("Public Class Foo\r\n" +
 
167
                                              "\tPublic Shared Operator -(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
168
                                              "\t\t").Length;
 
169
                        
 
170
                        RunFormatLineTest(code, expectedCode, expectedOffset);
 
171
                }
 
172
 
 
173
                [Test]
 
174
                public void IsTrueOperator()
 
175
                {
 
176
                        string code = "Public Class Foo\r\n" +
 
177
                                "\tPublic Shared Operator IsTrue(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
178
                                "\r\n" + // This extra new line is required. This is the new line just entered by the user.
 
179
                                "End Class";
 
180
                        
 
181
                        string expectedCode = "Public Class Foo\r\n" +
 
182
                                "\tPublic Shared Operator IsTrue(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
183
                                "\t\t\r\n" +
 
184
                                "\tEnd Operator\r\n" +
 
185
                                "End Class";
 
186
                        
 
187
                        int expectedOffset = ("Public Class Foo\r\n" +
 
188
                                              "\tPublic Shared Operator IsTrue(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
189
                                              "\t\t").Length;
 
190
                        
 
191
                        RunFormatLineTest(code, expectedCode, expectedOffset);
 
192
                }
 
193
                
 
194
                [Test]
 
195
                public void MultiplicationOperator()
 
196
                {
 
197
                        string code = "Public Class Foo\r\n" +
 
198
                                "\tPublic Shared Operator *(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
199
                                "\r\n" + // This extra new line is required. This is the new line just entered by the user.
 
200
                                "End Class";
 
201
                        
 
202
                        string expectedCode = "Public Class Foo\r\n" +
 
203
                                "\tPublic Shared Operator *(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
204
                                "\t\t\r\n" +
 
205
                                "\tEnd Operator\r\n" +
 
206
                                "End Class";
 
207
                        
 
208
                        int expectedOffset = ("Public Class Foo\r\n" +
 
209
                                              "\tPublic Shared Operator *(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
210
                                              "\t\t").Length;
 
211
                        
 
212
                        RunFormatLineTest(code, expectedCode, expectedOffset);
 
213
                }
 
214
 
 
215
                [Test]
 
216
                public void DivisionOperator()
 
217
                {
 
218
                        string code = "Public Class Foo\r\n" +
 
219
                                "\tPublic Shared Operator /(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
220
                                "\r\n" + // This extra new line is required. This is the new line just entered by the user.
 
221
                                "End Class";
 
222
                        
 
223
                        string expectedCode = "Public Class Foo\r\n" +
 
224
                                "\tPublic Shared Operator /(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
225
                                "\t\t\r\n" +
 
226
                                "\tEnd Operator\r\n" +
 
227
                                "End Class";
 
228
                        
 
229
                        int expectedOffset = ("Public Class Foo\r\n" +
 
230
                                              "\tPublic Shared Operator /(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
231
                                              "\t\t").Length;
 
232
                        
 
233
                        RunFormatLineTest(code, expectedCode, expectedOffset);
 
234
                }
 
235
 
 
236
                [Test]
 
237
                public void IntegerDivisionOperator()
 
238
                {
 
239
                        string code = "Public Class Foo\r\n" +
 
240
                                "\tPublic Shared Operator \\(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
241
                                "\r\n" + // This extra new line is required. This is the new line just entered by the user.
 
242
                                "End Class";
 
243
                        
 
244
                        string expectedCode = "Public Class Foo\r\n" +
 
245
                                "\tPublic Shared Operator \\(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
246
                                "\t\t\r\n" +
 
247
                                "\tEnd Operator\r\n" +
 
248
                                "End Class";
 
249
                        
 
250
                        int expectedOffset = ("Public Class Foo\r\n" +
 
251
                                              "\tPublic Shared Operator \\(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
252
                                              "\t\t").Length;
 
253
                        
 
254
                        RunFormatLineTest(code, expectedCode, expectedOffset);
 
255
                }
 
256
                
 
257
                [Test]
 
258
                public void StringConcatenationOperator()
 
259
                {
 
260
                        string code = "Public Class Foo\r\n" +
 
261
                                "\tPublic Shared Operator &(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
262
                                "\r\n" + // This extra new line is required. This is the new line just entered by the user.
 
263
                                "End Class";
 
264
                        
 
265
                        string expectedCode = "Public Class Foo\r\n" +
 
266
                                "\tPublic Shared Operator &(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
267
                                "\t\t\r\n" +
 
268
                                "\tEnd Operator\r\n" +
 
269
                                "End Class";
 
270
                        
 
271
                        int expectedOffset = ("Public Class Foo\r\n" +
 
272
                                              "\tPublic Shared Operator &(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
273
                                              "\t\t").Length;
 
274
                        
 
275
                        RunFormatLineTest(code, expectedCode, expectedOffset);
 
276
                }
 
277
                
 
278
                [Test]
 
279
                public void ExponentationcationOperator()
 
280
                {
 
281
                        string code = "Public Class Foo\r\n" +
 
282
                                "\tPublic Shared Operator ^(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
283
                                "\r\n" + // This extra new line is required. This is the new line just entered by the user.
 
284
                                "End Class";
 
285
                        
 
286
                        string expectedCode = "Public Class Foo\r\n" +
 
287
                                "\tPublic Shared Operator ^(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
288
                                "\t\t\r\n" +
 
289
                                "\tEnd Operator\r\n" +
 
290
                                "End Class";
 
291
                        
 
292
                        int expectedOffset = ("Public Class Foo\r\n" +
 
293
                                              "\tPublic Shared Operator ^(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
294
                                              "\t\t").Length;
 
295
                        
 
296
                        RunFormatLineTest(code, expectedCode, expectedOffset);
 
297
                }
 
298
                
 
299
                [Test]
 
300
                public void EqualityOperator()
 
301
                {
 
302
                        string code = "Public Class Foo\r\n" +
 
303
                                "\tPublic Shared Operator =(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
304
                                "\r\n" + // This extra new line is required. This is the new line just entered by the user.
 
305
                                "End Class";
 
306
                        
 
307
                        string expectedCode = "Public Class Foo\r\n" +
 
308
                                "\tPublic Shared Operator =(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
309
                                "\t\t\r\n" +
 
310
                                "\tEnd Operator\r\n" +
 
311
                                "End Class";
 
312
                        
 
313
                        int expectedOffset = ("Public Class Foo\r\n" +
 
314
                                              "\tPublic Shared Operator =(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
315
                                              "\t\t").Length;
 
316
                        
 
317
                        RunFormatLineTest(code, expectedCode, expectedOffset);
 
318
                }
 
319
                
 
320
                [Test]
 
321
                public void GreaterThanOperator()
 
322
                {
 
323
                        string code = "Public Class Foo\r\n" +
 
324
                                "\tPublic Shared Operator >(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
325
                                "\r\n" + // This extra new line is required. This is the new line just entered by the user.
 
326
                                "End Class";
 
327
                        
 
328
                        string expectedCode = "Public Class Foo\r\n" +
 
329
                                "\tPublic Shared Operator >(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
330
                                "\t\t\r\n" +
 
331
                                "\tEnd Operator\r\n" +
 
332
                                "End Class";
 
333
                        
 
334
                        int expectedOffset = ("Public Class Foo\r\n" +
 
335
                                              "\tPublic Shared Operator >(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
336
                                              "\t\t").Length;
 
337
                        
 
338
                        RunFormatLineTest(code, expectedCode, expectedOffset);
 
339
                }
 
340
 
 
341
                [Test]
 
342
                public void LessThanOperator()
 
343
                {
 
344
                        string code = "Public Class Foo\r\n" +
 
345
                                "\tPublic Shared Operator <(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
346
                                "\r\n" + // This extra new line is required. This is the new line just entered by the user.
 
347
                                "End Class";
 
348
                        
 
349
                        string expectedCode = "Public Class Foo\r\n" +
 
350
                                "\tPublic Shared Operator <(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
351
                                "\t\t\r\n" +
 
352
                                "\tEnd Operator\r\n" +
 
353
                                "End Class";
 
354
                        
 
355
                        int expectedOffset = ("Public Class Foo\r\n" +
 
356
                                              "\tPublic Shared Operator <(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
357
                                              "\t\t").Length;
 
358
                        
 
359
                        RunFormatLineTest(code, expectedCode, expectedOffset);
 
360
                }
 
361
                
 
362
                [Test]
 
363
                public void InequalityOperator()
 
364
                {
 
365
                        string code = "Public Class Foo\r\n" +
 
366
                                "\tPublic Shared Operator <>(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
367
                                "\r\n" + // This extra new line is required. This is the new line just entered by the user.
 
368
                                "End Class";
 
369
                        
 
370
                        string expectedCode = "Public Class Foo\r\n" +
 
371
                                "\tPublic Shared Operator <>(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
372
                                "\t\t\r\n" +
 
373
                                "\tEnd Operator\r\n" +
 
374
                                "End Class";
 
375
                        
 
376
                        int expectedOffset = ("Public Class Foo\r\n" +
 
377
                                              "\tPublic Shared Operator <>(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
378
                                              "\t\t").Length;
 
379
                        
 
380
                        RunFormatLineTest(code, expectedCode, expectedOffset);
 
381
                }
 
382
                
 
383
                /// <summary>
 
384
                /// Check that a method that starts with "Operator" is ignored.
 
385
                /// </summary>
 
386
                [Test]
 
387
                public void MethodStartsWithOperatorString()
 
388
                {
 
389
                        string code = "Public Class Foo\r\n" +
 
390
                                "\tPublic Shared OperatorIgnore(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
391
                                "\r\n" + // This extra new line is required. This is the new line just entered by the user.
 
392
                                "End Class";
 
393
                        
 
394
                        string expectedCode = "Public Class Foo\r\n" +
 
395
                                "\tPublic Shared OperatorIgnore(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
396
                                "\t\r\n" +
 
397
                                "End Class";
 
398
                        
 
399
                        int expectedOffset = ("Public Class Foo\r\n" +
 
400
                                              "\tPublic Shared OperatorIgnore(ByVal lhs As Foo, ByVal rhs As Foo) As Foo\r\n" +
 
401
                                              "\t").Length;
 
402
                        
 
403
                        RunFormatLineTest(code, expectedCode, expectedOffset);
 
404
                }
 
405
        }
 
406
}