← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to external/nrefactory/ICSharpCode.NRefactory.Tests/CSharp/CodeCompletion/CodeComplteionOperatorTests.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
external/nrefactory/ICSharpCode.NRefactory.Tests/CSharp/CodeCompletion/CodeComplteionOperatorTests.cs
 
1
//
 
2
// OperatorTests.cs
 
3
//
 
4
// Author:
 
5
//   Mike Krüger <mkrueger@novell.com>
 
6
//
 
7
// Copyright (C) 2008 Novell, Inc (http://www.novell.com)
 
8
//
 
9
// Permission is hereby granted, free of charge, to any person obtaining
 
10
// a copy of this software and associated documentation files (the
 
11
// "Software"), to deal in the Software without restriction, including
 
12
// without limitation the rights to use, copy, modify, merge, publish,
 
13
// distribute, sublicense, and/or sell copies of the Software, and to
 
14
// permit persons to whom the Software is furnished to do so, subject to
 
15
// the following conditions:
 
16
// 
 
17
// The above copyright notice and this permission notice shall be
 
18
// included in all copies or substantial portions of the Software.
 
19
// 
 
20
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 
21
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 
22
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 
23
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 
24
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 
25
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 
26
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
27
//
 
28
 
 
29
using System;
 
30
using NUnit.Framework;
 
31
 
 
32
namespace ICSharpCode.NRefactory.CSharp.CodeCompletion
 
33
{
 
34
        [TestFixture()]
 
35
        public class CodeCompletionOperatorTests : TestBase
 
36
        {
 
37
                [Test()]
 
38
                public void TestAddOperator ()
 
39
                {
 
40
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
41
@"class A
 
42
{
 
43
        public static B operator+(A left, A right)
 
44
        {
 
45
                return new B ();
 
46
        }
 
47
}
 
48
 
 
49
class B
 
50
{
 
51
        public void BMethod ()
 
52
        {
 
53
        }
 
54
}
 
55
 
 
56
class TestClass
 
57
{
 
58
        public void Test ()
 
59
        {
 
60
                A a = new A ();
 
61
                A b = new A ();
 
62
                $(a + b).$
 
63
        }
 
64
}");
 
65
                        Assert.IsNotNull (provider);
 
66
                        Assert.IsNotNull (provider.Find ("BMethod"));
 
67
                }
 
68
 
 
69
                [Test()]
 
70
                public void TestSubtractOperator ()
 
71
                {
 
72
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
73
@"class A
 
74
{
 
75
        public static B operator-(A left, A right)
 
76
        {
 
77
                return new B ();
 
78
        }
 
79
}
 
80
 
 
81
class B
 
82
{
 
83
        public void BMethod ()
 
84
        {
 
85
        }
 
86
}
 
87
 
 
88
class TestClass
 
89
{
 
90
        public void Test ()
 
91
        {
 
92
                A a = new A ();
 
93
                A b = new A ();
 
94
                $(a - b).$
 
95
        }
 
96
}");
 
97
                        Assert.IsNotNull (provider);
 
98
                        Assert.IsNotNull (provider.Find ("BMethod"));
 
99
                }
 
100
                
 
101
                [Test()]
 
102
                public void TestMultiplyOperator ()
 
103
                {
 
104
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
105
@"class A
 
106
{
 
107
        public static B operator*(A left, A right)
 
108
        {
 
109
                return new B ();
 
110
        }
 
111
}
 
112
 
 
113
class B
 
114
{
 
115
        public void BMethod ()
 
116
        {
 
117
        }
 
118
}
 
119
 
 
120
class TestClass
 
121
{
 
122
        public void Test ()
 
123
        {
 
124
                A a = new A ();
 
125
                A b = new A ();
 
126
                $(a * b).$
 
127
        }
 
128
}");
 
129
                        Assert.IsNotNull (provider);
 
130
                        Assert.IsNotNull (provider.Find ("BMethod"));
 
131
                }
 
132
                
 
133
                [Test()]
 
134
                public void TestDivideOperator ()
 
135
                {
 
136
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
137
@"class A
 
138
{
 
139
        public static B operator/(A left, A right)
 
140
        {
 
141
                return new B ();
 
142
        }
 
143
}
 
144
 
 
145
class B
 
146
{
 
147
        public void BMethod ()
 
148
        {
 
149
        }
 
150
}
 
151
 
 
152
class TestClass
 
153
{
 
154
        public void Test ()
 
155
        {
 
156
                A a = new A ();
 
157
                A b = new A ();
 
158
                $(a / b).$
 
159
        }
 
160
}");
 
161
                        Assert.IsNotNull (provider);
 
162
                        Assert.IsNotNull (provider.Find ("BMethod"));
 
163
                }
 
164
 
 
165
                [Test()]
 
166
                public void TestModulusOperator ()
 
167
                {
 
168
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
169
@"class A
 
170
{
 
171
        public static B operator%(A left, A right)
 
172
        {
 
173
                return new B ();
 
174
        }
 
175
}
 
176
 
 
177
class B
 
178
{
 
179
        public void BMethod ()
 
180
        {
 
181
        }
 
182
}
 
183
 
 
184
class TestClass
 
185
{
 
186
        public void Test ()
 
187
        {
 
188
                A a = new A ();
 
189
                A b = new A ();
 
190
                $(a % b).$
 
191
        }
 
192
}");
 
193
                        Assert.IsNotNull (provider);
 
194
                        Assert.IsNotNull (provider.Find ("BMethod"));
 
195
                }
 
196
                
 
197
                [Test()]
 
198
                public void TestBitwiseAndOperator ()
 
199
                {
 
200
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
201
@"class A
 
202
{
 
203
        public static B operator&(A left, A right)
 
204
        {
 
205
                return new B ();
 
206
        }
 
207
}
 
208
 
 
209
class B
 
210
{
 
211
        public void BMethod ()
 
212
        {
 
213
        }
 
214
}
 
215
 
 
216
class TestClass
 
217
{
 
218
        public void Test ()
 
219
        {
 
220
                A a = new A ();
 
221
                A b = new A ();
 
222
                $(a & b).$
 
223
        }
 
224
}");
 
225
                        Assert.IsNotNull (provider);
 
226
                        Assert.IsNotNull (provider.Find ("BMethod"));
 
227
                }
 
228
                
 
229
                [Test()]
 
230
                public void TestBitwiseOrOperator ()
 
231
                {
 
232
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
233
@"class A
 
234
{
 
235
        public static B operator|(A left, A right)
 
236
        {
 
237
                return new B ();
 
238
        }
 
239
}
 
240
 
 
241
class B
 
242
{
 
243
        public void BMethod ()
 
244
        {
 
245
        }
 
246
}
 
247
 
 
248
class TestClass
 
249
{
 
250
        public void Test ()
 
251
        {
 
252
                A a = new A ();
 
253
                A b = new A ();
 
254
                $(a | b).$
 
255
        }
 
256
}");
 
257
                        Assert.IsNotNull (provider);
 
258
                        Assert.IsNotNull (provider.Find ("BMethod"));
 
259
                }
 
260
                
 
261
                [Test()]
 
262
                public void TestExclusiveOrOperator ()
 
263
                {
 
264
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
265
@"class A
 
266
{
 
267
        public static B operator^(A left, A right)
 
268
        {
 
269
                return new B ();
 
270
        }
 
271
}
 
272
 
 
273
class B
 
274
{
 
275
        public void BMethod ()
 
276
        {
 
277
        }
 
278
}
 
279
 
 
280
class TestClass
 
281
{
 
282
        public void Test ()
 
283
        {
 
284
                A a = new A ();
 
285
                A b = new A ();
 
286
                $(a ^ b).$
 
287
        }
 
288
}");
 
289
                        Assert.IsNotNull (provider);
 
290
                        Assert.IsNotNull (provider.Find ("BMethod"));
 
291
                }
 
292
                
 
293
                [Test()]
 
294
                public void TestShiftLeftOperator ()
 
295
                {
 
296
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
297
@"class A
 
298
{
 
299
        public static B operator<<(A left, A right)
 
300
        {
 
301
                return new B ();
 
302
        }
 
303
}
 
304
 
 
305
class B
 
306
{
 
307
        public void BMethod ()
 
308
        {
 
309
        }
 
310
}
 
311
 
 
312
class TestClass
 
313
{
 
314
        public void Test ()
 
315
        {
 
316
                A a = new A ();
 
317
                A b = new A ();
 
318
                $(a << b).$
 
319
        }
 
320
}");
 
321
                        Assert.IsNotNull (provider);
 
322
                        Assert.IsNotNull (provider.Find ("BMethod"));
 
323
                }
 
324
                
 
325
                [Test()]
 
326
                public void TestShiftRightOperator ()
 
327
                {
 
328
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
329
@"class A
 
330
{
 
331
        public static B operator>>(A left, A right)
 
332
        {
 
333
                return new B ();
 
334
        }
 
335
}
 
336
 
 
337
class B
 
338
{
 
339
        public void BMethod ()
 
340
        {
 
341
        }
 
342
}
 
343
 
 
344
class TestClass
 
345
{
 
346
        public void Test ()
 
347
        {
 
348
                A a = new A ();
 
349
                A b = new A ();
 
350
                $(a >> b).$
 
351
        }
 
352
}");
 
353
                        Assert.IsNotNull (provider);
 
354
                        Assert.IsNotNull (provider.Find ("BMethod"));
 
355
                }
 
356
                
 
357
                [Test()]
 
358
                public void TestGreaterThanOperator ()
 
359
                {
 
360
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
361
@"class A
 
362
{
 
363
        public static B operator>(A left, A right)
 
364
        {
 
365
                return new B ();
 
366
        }
 
367
}
 
368
 
 
369
class B
 
370
{
 
371
        public void BMethod ()
 
372
        {
 
373
        }
 
374
}
 
375
 
 
376
class TestClass
 
377
{
 
378
        public void Test ()
 
379
        {
 
380
                A a = new A ();
 
381
                A b = new A ();
 
382
                $(a > b).$
 
383
        }
 
384
}");
 
385
                        Assert.IsNotNull (provider);
 
386
                        Assert.IsNotNull (provider.Find ("BMethod"));
 
387
                }
 
388
                
 
389
                [Test()]
 
390
                public void TestGreaterThanOrEqualOperator ()
 
391
                {
 
392
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
393
@"class A
 
394
{
 
395
        public static B operator>=(A left, A right)
 
396
        {
 
397
                return new B ();
 
398
        }
 
399
}
 
400
 
 
401
class B
 
402
{
 
403
        public void BMethod ()
 
404
        {
 
405
        }
 
406
}
 
407
 
 
408
class TestClass
 
409
{
 
410
        public void Test ()
 
411
        {
 
412
                A a = new A ();
 
413
                A b = new A ();
 
414
                $(a >= b).$
 
415
        }
 
416
}");
 
417
                        Assert.IsNotNull (provider);
 
418
                        Assert.IsNotNull (provider.Find ("BMethod"));
 
419
                }
 
420
                
 
421
                [Test()]
 
422
                public void TestEqualityOperator ()
 
423
                {
 
424
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
425
@"class A
 
426
{
 
427
        public static B operator==(A left, A right)
 
428
        {
 
429
                return new B ();
 
430
        }
 
431
}
 
432
 
 
433
class B
 
434
{
 
435
        public void BMethod ()
 
436
        {
 
437
        }
 
438
}
 
439
 
 
440
class TestClass
 
441
{
 
442
        public void Test ()
 
443
        {
 
444
                A a = new A ();
 
445
                A b = new A ();
 
446
                $(a == b).$
 
447
        }
 
448
}");
 
449
                        Assert.IsNotNull (provider);
 
450
                        Assert.IsNotNull (provider.Find ("BMethod"));
 
451
                }
 
452
                
 
453
                [Test()]
 
454
                public void TestInEqualityOperator ()
 
455
                {
 
456
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
457
@"class A
 
458
{
 
459
        public static B operator!=(A left, A right)
 
460
        {
 
461
                return new B ();
 
462
        }
 
463
}
 
464
 
 
465
class B
 
466
{
 
467
        public void BMethod ()
 
468
        {
 
469
        }
 
470
}
 
471
 
 
472
class TestClass
 
473
{
 
474
        public void Test ()
 
475
        {
 
476
                A a = new A ();
 
477
                A b = new A ();
 
478
                $(a != b).$
 
479
        }
 
480
}");
 
481
                        Assert.IsNotNull (provider);
 
482
                        Assert.IsNotNull (provider.Find ("BMethod"));
 
483
                }
 
484
                
 
485
                [Test()]
 
486
                public void TestLessThanOperator ()
 
487
                {
 
488
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
489
@"class A
 
490
{
 
491
        public static B operator<(A left, A right)
 
492
        {
 
493
                return new B ();
 
494
        }
 
495
}
 
496
 
 
497
class B
 
498
{
 
499
        public void BMethod ()
 
500
        {
 
501
        }
 
502
}
 
503
 
 
504
class TestClass
 
505
{
 
506
        public void Test ()
 
507
        {
 
508
                A a = new A ();
 
509
                A b = new A ();
 
510
                $(a < b).$
 
511
        }
 
512
}");
 
513
                        Assert.IsNotNull (provider);
 
514
                        Assert.IsNotNull (provider.Find ("BMethod"));
 
515
                }
 
516
                
 
517
                [Test()]
 
518
                public void TestLessThanOrEqualOperator ()
 
519
                {
 
520
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
521
@"class A
 
522
{
 
523
        public static B operator<=(A left, A right)
 
524
        {
 
525
                return new B ();
 
526
        }
 
527
}
 
528
 
 
529
class B
 
530
{
 
531
        public void BMethod ()
 
532
        {
 
533
        }
 
534
}
 
535
 
 
536
class TestClass
 
537
{
 
538
        public void Test ()
 
539
        {
 
540
                A a = new A ();
 
541
                A b = new A ();
 
542
                $(a <= b).$
 
543
        }
 
544
}");
 
545
                        Assert.IsNotNull (provider);
 
546
                        Assert.IsNotNull (provider.Find ("BMethod"));
 
547
                }
 
548
                
 
549
                [Test()]
 
550
                public void TestUnaryPlusOperator ()
 
551
                {
 
552
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
553
@"class A
 
554
{
 
555
        public static B operator+(A left)
 
556
        {
 
557
                return new B ();
 
558
        }
 
559
}
 
560
 
 
561
class B : A
 
562
{
 
563
        public void BMethod ()
 
564
        {
 
565
        }
 
566
}
 
567
 
 
568
class TestClass
 
569
{
 
570
        public void Test ()
 
571
        {
 
572
                A a = new A ();
 
573
                $(+a).$
 
574
        }
 
575
}");
 
576
                        Assert.IsNotNull (provider);
 
577
                        Assert.IsNotNull (provider.Find ("BMethod"));
 
578
                }
 
579
                
 
580
                [Test()]
 
581
                public void TestUnaryMinusOperator ()
 
582
                {
 
583
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
584
@"class A
 
585
{
 
586
        public static B operator-(A left)
 
587
        {
 
588
                return new B ();
 
589
        }
 
590
}
 
591
 
 
592
class B : A
 
593
{
 
594
        public void BMethod ()
 
595
        {
 
596
        }
 
597
}
 
598
 
 
599
class TestClass
 
600
{
 
601
        public void Test ()
 
602
        {
 
603
                A a = new A ();
 
604
                $(-a).$
 
605
        }
 
606
}");
 
607
                        Assert.IsNotNull (provider);
 
608
                        Assert.IsNotNull (provider.Find ("BMethod"));
 
609
                }
 
610
                
 
611
                [Test()]
 
612
                public void TestUnaryNotOperator ()
 
613
                {
 
614
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
615
@"class A
 
616
{
 
617
        public static B operator!(A left)
 
618
        {
 
619
                return new B ();
 
620
        }
 
621
}
 
622
 
 
623
class B : A
 
624
{
 
625
        public void BMethod ()
 
626
        {
 
627
        }
 
628
}
 
629
 
 
630
class TestClass
 
631
{
 
632
        public void Test ()
 
633
        {
 
634
                A a = new A ();
 
635
                $(!a).$
 
636
        }
 
637
}");
 
638
                        Assert.IsNotNull (provider);
 
639
                        Assert.IsNotNull (provider.Find ("BMethod"));
 
640
                }
 
641
                
 
642
                [Test()]
 
643
                public void TestUnaryBitwiseNotOperator ()
 
644
                {
 
645
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
646
@"class A
 
647
{
 
648
        public static B operator~(A left)
 
649
        {
 
650
                return new B ();
 
651
        }
 
652
}
 
653
 
 
654
class B : A
 
655
{
 
656
        public void BMethod ()
 
657
        {
 
658
        }
 
659
}
 
660
 
 
661
class TestClass
 
662
{
 
663
        public void Test ()
 
664
        {
 
665
                A a = new A ();
 
666
                $(~a).$
 
667
        }
 
668
}");
 
669
                        Assert.IsNotNull (provider);
 
670
                        Assert.IsNotNull (provider.Find ("BMethod"));
 
671
                }
 
672
        }
 
673
}