← 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/CodeIssues/ParameterCanBeDemotedIssue/ParameterCanBeDemotedTests.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/CodeIssues/ParameterCanBeDemotedIssue/ParameterCanBeDemotedTests.cs
 
1
//
 
2
// ParameterCouldBeDeclaredWithBaseTypeTests.cs
 
3
//
 
4
// Author:
 
5
//       Simon Lindgren <simon.n.lindgren@gmail.com>
 
6
//
 
7
// Copyright (c) 2012 Simon Lindgren
 
8
//
 
9
// Permission is hereby granted, free of charge, to any person obtaining a copy
 
10
// of this software and associated documentation files (the "Software"), to deal
 
11
// in the Software without restriction, including without limitation the rights
 
12
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 
13
// copies of the Software, and to permit persons to whom the Software is
 
14
// furnished to do so, subject to the following conditions:
 
15
//
 
16
// The above copyright notice and this permission notice shall be included in
 
17
// all copies or substantial portions of the Software.
 
18
//
 
19
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
20
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
21
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 
22
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
23
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
24
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 
25
// THE SOFTWARE.
 
26
using System;
 
27
using NUnit.Framework;
 
28
using ICSharpCode.NRefactory.CSharp.CodeActions;
 
29
using ICSharpCode.NRefactory.CSharp.Refactoring;
 
30
 
 
31
namespace ICSharpCode.NRefactory.CSharp.CodeIssues
 
32
{
 
33
        [TestFixture]
 
34
        public class ParameterCanBeDemotedTests : InspectionActionTestBase
 
35
        {
 
36
                [Test]
 
37
                public void BasicTest()
 
38
                {
 
39
                        var input = @"
 
40
class A
 
41
{
 
42
        public virtual void Foo() {}
 
43
}
 
44
class B : A
 
45
{
 
46
        public virtual void Bar() {}
 
47
}
 
48
class C
 
49
{
 
50
        void F(B b)
 
51
        {
 
52
                b.Foo();
 
53
        }
 
54
}";
 
55
                        TestRefactoringContext context;
 
56
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(), input, out context);
 
57
                        Assert.AreEqual(1, issues.Count);
 
58
                        var issue = issues [0];
 
59
                        Assert.AreEqual(1, issue.Actions.Count);
 
60
 
 
61
                        CheckFix(context, issues [0], @"
 
62
class A
 
63
{
 
64
        public virtual void Foo() {}
 
65
}
 
66
class B : A
 
67
{
 
68
        public virtual void Bar() {}
 
69
}
 
70
class C
 
71
{
 
72
        void F(A b)
 
73
        {
 
74
                b.Foo();
 
75
        }
 
76
}");
 
77
                }
 
78
                
 
79
                [Test]
 
80
                public void IgnoresUnusedParameters()
 
81
                {
 
82
                        var input = @"
 
83
class A
 
84
{
 
85
        void F(A a1)
 
86
        {
 
87
        }
 
88
}";
 
89
                        TestRefactoringContext context;
 
90
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(), input, out context);
 
91
                        Assert.AreEqual(0, issues.Count);
 
92
                }
 
93
                
 
94
                [Test]
 
95
                public void IgnoresDirectionalParameters()
 
96
                {
 
97
                        var input = @"
 
98
interface IA
 
99
{
 
100
}
 
101
class A : IA
 
102
{
 
103
        void F(out A a1)
 
104
        {
 
105
                object.Equals(a1, null);
 
106
        }
 
107
}";
 
108
                        TestRefactoringContext context;
 
109
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(), input, out context);
 
110
                        Assert.AreEqual(0, issues.Count);
 
111
                }
 
112
 
 
113
                [Test]
 
114
                public void IgnoresOverrides()
 
115
                {
 
116
                        var input = @"
 
117
interface IA
 
118
{
 
119
        void Foo();
 
120
}
 
121
class B : IA
 
122
{
 
123
        public virtual void Foo() {}
 
124
        public virtual void Bar() {}
 
125
}
 
126
class TestBase
 
127
{
 
128
        public void F(B b) {
 
129
                b.Foo();
 
130
                b.Bar();
 
131
        }
 
132
}
 
133
class TestClass : TestBase
 
134
{
 
135
        public override void F(B b)
 
136
        {
 
137
                b.Foo();
 
138
        }
 
139
}";
 
140
                        TestRefactoringContext context;
 
141
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(), input, out context);
 
142
                        Assert.AreEqual(0, issues.Count);
 
143
                }
 
144
                
 
145
                [Test]
 
146
                public void IgnoresOverridables()
 
147
                {
 
148
                        var input = @"
 
149
interface IA
 
150
{
 
151
        void Foo();
 
152
}
 
153
class B : IA
 
154
{
 
155
        public virtual void Foo() {}
 
156
        public virtual void Bar() {}
 
157
}
 
158
class TestClass
 
159
{
 
160
        public virtual void F(B b)
 
161
        {
 
162
                b.Foo();
 
163
        }
 
164
}";
 
165
                        TestRefactoringContext context;
 
166
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(), input, out context);
 
167
                        Assert.AreEqual(0, issues.Count);
 
168
                }
 
169
                
 
170
                [Test]
 
171
                public void HandlesNeededProperties()
 
172
                {
 
173
                        var input = @"
 
174
interface IA
 
175
{
 
176
        void Foo(string s);
 
177
}
 
178
class B : IA
 
179
{
 
180
        public virtual void Foo(string s) {}
 
181
        public string Property { get; }
 
182
}
 
183
class TestClass
 
184
{
 
185
        public void F(B b)
 
186
        {
 
187
                b.Foo(b.Property);
 
188
        }
 
189
}";
 
190
                        TestRefactoringContext context;
 
191
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(false), input, out context);
 
192
                        Assert.AreEqual(0, issues.Count);
 
193
                }
 
194
                
 
195
                [Test]
 
196
                public void InterfaceTest()
 
197
                {
 
198
                        var input = @"
 
199
interface IA
 
200
{
 
201
        void Foo();
 
202
}
 
203
class B : IA
 
204
{
 
205
        public virtual void Foo() {}
 
206
        public virtual void Bar() {}
 
207
}
 
208
class C
 
209
{
 
210
        void F(B b)
 
211
        {
 
212
                b.Foo();
 
213
        }
 
214
}";
 
215
                        TestRefactoringContext context;
 
216
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(), input, out context);
 
217
                        Assert.AreEqual(1, issues.Count);
 
218
                        var issue = issues [0];
 
219
                        Assert.AreEqual(1, issue.Actions.Count);
 
220
                        
 
221
                        CheckFix(context, issues [0], @"
 
222
interface IA
 
223
{
 
224
        void Foo();
 
225
}
 
226
class B : IA
 
227
{
 
228
        public virtual void Foo() {}
 
229
        public virtual void Bar() {}
 
230
}
 
231
class C
 
232
{
 
233
        void F(IA b)
 
234
        {
 
235
                b.Foo();
 
236
        }
 
237
}");
 
238
                }
 
239
                
 
240
                [Test]
 
241
                public void RespectsExpectedTypeInIfStatement()
 
242
                {
 
243
                        var input = @"
 
244
class C
 
245
{
 
246
        void F (bool b, bool c)
 
247
        {
 
248
                if (b && c)
 
249
                        return;
 
250
        }
 
251
}";
 
252
                        TestRefactoringContext context;
 
253
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(false), input, out context);
 
254
                        Assert.AreEqual(0, issues.Count);
 
255
                }
 
256
                
 
257
                [Test]
 
258
                public void MultipleInterfaceTest()
 
259
                {
 
260
                        var input = @"
 
261
interface IA1
 
262
{
 
263
        void Foo();
 
264
}
 
265
interface IA2
 
266
{
 
267
        void Bar();
 
268
}
 
269
class B : IA1, IA2
 
270
{
 
271
        public virtual void Foo() {}
 
272
        public virtual void Bar() {}
 
273
}
 
274
class C : B {}
 
275
class Test
 
276
{
 
277
        void F(C c)
 
278
        {
 
279
                c.Foo();
 
280
                c.Bar();
 
281
        }
 
282
}";
 
283
                        TestRefactoringContext context;
 
284
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(), input, out context);
 
285
                        Assert.AreEqual(1, issues.Count);
 
286
                        var issue = issues [0];
 
287
                        Assert.AreEqual(1, issue.Actions.Count);
 
288
 
 
289
                        CheckFix(context, issues [0], @"
 
290
interface IA1
 
291
{
 
292
        void Foo();
 
293
}
 
294
interface IA2
 
295
{
 
296
        void Bar();
 
297
}
 
298
class B : IA1, IA2
 
299
{
 
300
        public virtual void Foo() {}
 
301
        public virtual void Bar() {}
 
302
}
 
303
class C : B {}
 
304
class Test
 
305
{
 
306
        void F(B c)
 
307
        {
 
308
                c.Foo();
 
309
                c.Bar();
 
310
        }
 
311
}");
 
312
                }
 
313
 
 
314
                string baseInput = @"
 
315
interface IA
 
316
{
 
317
        void Foo();
 
318
}
 
319
interface IB : IA
 
320
{
 
321
        void Bar();
 
322
}
 
323
interface IC : IA
 
324
{
 
325
        new void Foo();
 
326
        void Baz();
 
327
}
 
328
class D : IB
 
329
{
 
330
        public void Foo() {}
 
331
        public void Bar() {}
 
332
}
 
333
class E : D, IC
 
334
{
 
335
        public void Baz() {}
 
336
        void IC.Foo() {}
 
337
}";
 
338
                
 
339
                [Ignore]
 
340
                [Test]
 
341
                public void FindsTopInterface()
 
342
                {
 
343
                        var input = baseInput + @"
 
344
class Test
 
345
{
 
346
        void F(E e)
 
347
        {
 
348
                e.Foo();
 
349
        }
 
350
}";
 
351
                        TestRefactoringContext context;
 
352
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(), input, out context);
 
353
                        Assert.AreEqual(1, issues.Count);
 
354
                        var issue = issues [0];
 
355
                        Assert.AreEqual(4, issue.Actions.Count);
 
356
                        
 
357
                        CheckFix(context, issues [0], baseInput + @"
 
358
class Test
 
359
{
 
360
        void F(IA e)
 
361
        {
 
362
                e.Foo();
 
363
        }
 
364
}");
 
365
                }
 
366
                
 
367
                [Test]
 
368
                public void DoesNotChangeOverload()
 
369
                {
 
370
                        var input = baseInput + @"
 
371
class Test
 
372
{
 
373
        void F(IB b)
 
374
        {
 
375
                Bar (b);
 
376
        }
 
377
        
 
378
        void Bar (IA a)
 
379
        {
 
380
        }
 
381
 
 
382
        void Bar (IB b)
 
383
        {
 
384
        }
 
385
}";
 
386
                        TestRefactoringContext context;
 
387
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(false), input, out context);
 
388
                        Assert.AreEqual(0, issues.Count);
 
389
                }
 
390
                
 
391
                [Test]
 
392
                public void AssignmentToExplicitlyTypedVariable()
 
393
                {
 
394
                        var input = baseInput + @"
 
395
class Test
 
396
{
 
397
        void F(IB b)
 
398
        {
 
399
                IB b2;
 
400
                b2 = b;
 
401
                object.Equals(b, b2);
 
402
        }
 
403
}";
 
404
                        TestRefactoringContext context;
 
405
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(false), input, out context);
 
406
                        Assert.AreEqual(0, issues.Count);
 
407
                }
 
408
                
 
409
                [Test]
 
410
                public void GenericMethod()
 
411
                {
 
412
                        var input = baseInput + @"
 
413
class Test
 
414
{
 
415
        void F(IB b)
 
416
        {
 
417
                Generic (b);
 
418
        }
 
419
 
 
420
        void Generic<T> (T arg) where T : IA
 
421
        {
 
422
        }
 
423
}";
 
424
                        TestRefactoringContext context;
 
425
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(), input, out context);
 
426
                        Assert.AreEqual(0, issues.Count);
 
427
                }
 
428
 
 
429
                [Test]
 
430
                public void VariableDeclarationWithTypeInference()
 
431
                {
 
432
                        var input = baseInput + @"
 
433
class Test
 
434
{
 
435
        void Foo (IB b)
 
436
        {
 
437
                var b2 = b;
 
438
                Foo (b2);
 
439
        }
 
440
 
 
441
        void Foo (IA a)
 
442
        {
 
443
        }
 
444
}";
 
445
                        TestRefactoringContext context;
 
446
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(), input, out context);
 
447
                        Assert.AreEqual(0, issues.Count);
 
448
                }
 
449
 
 
450
                [Test]
 
451
                public void RespectsOutgoingCallsTypeRestrictions()
 
452
                {
 
453
                        var input = baseInput + @"
 
454
class Test
 
455
{
 
456
        void F(E e)
 
457
        {
 
458
                e.Foo();
 
459
                DemandType(e);
 
460
        }
 
461
 
 
462
        void DemandType(D d)
 
463
        {
 
464
        }
 
465
}";
 
466
                        TestRefactoringContext context;
 
467
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(), input, out context);
 
468
                        Assert.AreEqual(1, issues.Count);
 
469
                        var issue = issues [0];
 
470
                        Assert.AreEqual(1, issue.Actions.Count);
 
471
                        
 
472
                        CheckFix(context, issues [0], baseInput + @"
 
473
class Test
 
474
{
 
475
        void F(D e)
 
476
        {
 
477
                e.Foo();
 
478
                DemandType(e);
 
479
        }
 
480
 
 
481
        void DemandType(D d)
 
482
        {
 
483
        }
 
484
}");
 
485
                }
 
486
                
 
487
                [Test]
 
488
                public void AccountsForNonInvocationMethodGroupUsageInMethodCall()
 
489
                {
 
490
                        var input = @"
 
491
delegate void FooDelegate (string s);
 
492
interface IBase
 
493
{
 
494
        void Bar();
 
495
}
 
496
interface IDerived : IBase
 
497
{
 
498
        void Foo(string s);
 
499
}
 
500
class TestClass
 
501
{
 
502
        public void Bar (IDerived derived)
 
503
        {
 
504
                derived.Bar();
 
505
                Baz (derived.Foo);
 
506
        }
 
507
 
 
508
        void Baz (FooDelegate fd)
 
509
        {
 
510
        }
 
511
}";
 
512
                        TestRefactoringContext context;
 
513
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(false), input, out context);
 
514
                        Assert.AreEqual(0, issues.Count);
 
515
                }
 
516
                
 
517
                [Test]
 
518
                public void AccountsForNonInvocationMethodGroupUsageInVariableDeclaration()
 
519
                {
 
520
                        var input = @"
 
521
delegate void FooDelegate (string s);
 
522
interface IBase
 
523
{
 
524
        void Bar();
 
525
}
 
526
interface IDerived : IBase
 
527
{
 
528
        void Foo(string s);
 
529
}
 
530
class TestClass
 
531
{
 
532
        public void Bar (IDerived derived)
 
533
        {
 
534
                derived.Bar();
 
535
                FooDelegate d = derived.Foo;
 
536
        }
 
537
}";
 
538
                        TestRefactoringContext context;
 
539
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(false), input, out context);
 
540
                        Assert.AreEqual(0, issues.Count);
 
541
                }
 
542
                
 
543
                [Test]
 
544
                public void AccountsForNonInvocationMethodGroupUsageInAssignmentExpression()
 
545
                {
 
546
                        var input = @"
 
547
delegate void FooDelegate (string s);
 
548
interface IBase
 
549
{
 
550
        void Bar();
 
551
}
 
552
interface IDerived : IBase
 
553
{
 
554
        void Foo(string s);
 
555
}
 
556
class TestClass
 
557
{
 
558
        public void Bar (IDerived derived)
 
559
        {
 
560
                derived.Bar();
 
561
                FooDelegate d;
 
562
                d = derived.Foo;
 
563
        }
 
564
}";
 
565
                        TestRefactoringContext context;
 
566
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(false), input, out context);
 
567
                        Assert.AreEqual(0, issues.Count);
 
568
                }
 
569
                
 
570
                [Ignore]
 
571
                [Test]
 
572
                public void AccountsForIndexers()
 
573
                {
 
574
                        var input = @"
 
575
class TestClass
 
576
{
 
577
        void Write(string[] s)
 
578
        {
 
579
                object.Equals(s, s);
 
580
                var element = s[1];
 
581
        }
 
582
}";
 
583
                        TestRefactoringContext context;
 
584
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(), input, out context);
 
585
                        Assert.AreEqual(1, issues.Count);
 
586
                        var issue = issues[0];
 
587
                        // Suggested types: IList<T> and IReadOnlyList<T>
 
588
                        Assert.AreEqual(2, issue.Actions.Count);
 
589
 
 
590
                        CheckFix(context, issues [0], @"
 
591
class TestClass
 
592
{
 
593
        void Write(System.Collections.Generic.IList<string> s)
 
594
        {
 
595
                object.Equals(s, s);
 
596
                var element = s[1];
 
597
        }
 
598
}");
 
599
                }
 
600
                
 
601
                [Test]
 
602
                public void AccountsForArrays()
 
603
                {
 
604
                        var input = @"
 
605
class TestClass
 
606
{
 
607
        void Write(string[] s)
 
608
        {
 
609
                var i = s.Length;
 
610
                SetValue (out s[1]);
 
611
        }
 
612
 
 
613
        void SetValue (out string s)
 
614
        {
 
615
        } 
 
616
}";
 
617
                        TestRefactoringContext context;
 
618
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(false), input, out context);
 
619
                        Assert.AreEqual(0, issues.Count);
 
620
                }
 
621
                
 
622
                [Test]
 
623
                public void LimitsParamsParametersToArrays()
 
624
                {
 
625
                        var input = @"
 
626
class TestClass
 
627
{
 
628
        void Write(params string[] s)
 
629
        {
 
630
                System.Console.WriteLine (s);
 
631
        }
 
632
}";
 
633
                        TestRefactoringContext context;
 
634
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(false), input, out context);
 
635
                        Assert.AreEqual(0, issues.Count);
 
636
                }
 
637
                
 
638
                [Test]
 
639
                public void DoesNotSuggestProgramEntryPointChanges()
 
640
                {
 
641
                        var input = @"
 
642
class TestClass
 
643
{
 
644
        public static void Main (string[] args)
 
645
        {
 
646
                if (args.Length > 2) {
 
647
                }
 
648
        }
 
649
}";
 
650
                        TestRefactoringContext context;
 
651
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(false), input, out context);
 
652
                        Assert.AreEqual(0, issues.Count);
 
653
                }
 
654
                
 
655
                [Test]
 
656
                public void IgnoresImplicitInterfaceImplementations()
 
657
                {
 
658
                        var input = @"
 
659
interface IHasFoo
 
660
{
 
661
        void Foo (string s);
 
662
}
 
663
class TestClass : IHasFoo
 
664
{
 
665
        public void Foo(string s)
 
666
        {
 
667
                object o = s;
 
668
        } 
 
669
}";
 
670
                        TestRefactoringContext context;
 
671
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(false), input, out context);
 
672
                        Assert.AreEqual(0, issues.Count);
 
673
                }
 
674
 
 
675
                [Test]
 
676
                public void IgnoresEnumParameters()
 
677
                {
 
678
                        var input = @"
 
679
enum ApplicableValues
 
680
{
 
681
        None,
 
682
        Some
 
683
}
 
684
class TestClass
 
685
{
 
686
        public void Foo(ApplicableValues av)
 
687
        {
 
688
                object o = av;
 
689
        } 
 
690
}";
 
691
                        TestRefactoringContext context;
 
692
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(false), input, out context);
 
693
                        Assert.AreEqual(0, issues.Count);
 
694
                }
 
695
                
 
696
                [Test]
 
697
                public void CallToOverriddenMember()
 
698
                {
 
699
                        var input = @"
 
700
class TestBase
 
701
{
 
702
        public virtual void Foo()
 
703
        {
 
704
        }
 
705
}
 
706
class Test : TestBase
 
707
{
 
708
        void F (Test t)
 
709
        {
 
710
                t.Foo();
 
711
        }
 
712
        
 
713
        public override void Foo()
 
714
        {
 
715
        }
 
716
}";
 
717
                        TestRefactoringContext context;
 
718
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(), input, out context);
 
719
                        Assert.AreEqual(1, issues.Count);
 
720
                        var issue = issues[0];
 
721
                        Assert.AreEqual(1, issue.Actions.Count);
 
722
                        
 
723
                        CheckFix(context, issue, @"
 
724
class TestBase
 
725
{
 
726
        public virtual void Foo()
 
727
        {
 
728
        }
 
729
}
 
730
class Test : TestBase
 
731
{
 
732
        void F (TestBase t)
 
733
        {
 
734
                t.Foo();
 
735
        }
 
736
        
 
737
        public override void Foo()
 
738
        {
 
739
        }
 
740
}");
 
741
                }
 
742
                
 
743
                [Test]
 
744
                public void CallToShadowingMember()
 
745
                {
 
746
                        var input = @"
 
747
class TestBase
 
748
{
 
749
        public virtual void Foo()
 
750
        {
 
751
        }
 
752
}
 
753
class Test : TestBase
 
754
{
 
755
        void F (Test t)
 
756
        {
 
757
                t.Foo();
 
758
        }
 
759
        
 
760
        public new void Foo()
 
761
        {
 
762
        }
 
763
}";
 
764
                        TestRefactoringContext context;
 
765
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(false), input, out context);
 
766
                        Assert.AreEqual(0, issues.Count);
 
767
                }
 
768
                
 
769
                [Test]
 
770
                public void CallToShadowingMember2()
 
771
                {
 
772
                        var input = @"
 
773
class TestBaseBase
 
774
{
 
775
        public virtual void Foo()
 
776
        {
 
777
        }
 
778
}
 
779
class TestBase : TestBaseBase
 
780
{
 
781
        protected virtual new void Foo()
 
782
        {
 
783
        }
 
784
}
 
785
class Test : TestBase
 
786
{
 
787
        void F (Test t)
 
788
        {
 
789
                t.Foo();
 
790
        }
 
791
        
 
792
        public override void Foo()
 
793
        {
 
794
        }
 
795
}";
 
796
                        TestRefactoringContext context;
 
797
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(false), input, out context);
 
798
                        Assert.AreEqual(1, issues.Count);
 
799
                        var issue = issues[0];
 
800
                        Assert.AreEqual(1, issue.Actions.Count);
 
801
                        
 
802
                        CheckFix(context, issue, @"
 
803
class TestBaseBase
 
804
{
 
805
        public virtual void Foo()
 
806
        {
 
807
        }
 
808
}
 
809
class TestBase : TestBaseBase
 
810
{
 
811
        protected virtual new void Foo()
 
812
        {
 
813
        }
 
814
}
 
815
class Test : TestBase
 
816
{
 
817
        void F (TestBase t)
 
818
        {
 
819
                t.Foo();
 
820
        }
 
821
        
 
822
        public override void Foo()
 
823
        {
 
824
        }
 
825
}");
 
826
                }
 
827
                
 
828
                [Test]
 
829
                public void CallToShadowingMemberWithBaseInterface()
 
830
                {
 
831
                        var input = @"
 
832
interface IFoo
 
833
{
 
834
        void Foo();
 
835
}
 
836
class TestBaseBase : IFoo
 
837
{
 
838
        public virtual void Foo()
 
839
        {
 
840
        }
 
841
}
 
842
class TestBase : TestBaseBase
 
843
{
 
844
        protected virtual new void Foo()
 
845
        {
 
846
        }
 
847
}
 
848
class Test : TestBase
 
849
{
 
850
        void F (Test t)
 
851
        {
 
852
                t.Foo();
 
853
        }
 
854
        
 
855
        protected override void Foo()
 
856
        {
 
857
        }
 
858
}";
 
859
                        TestRefactoringContext context;
 
860
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(false), input, out context);
 
861
                        Assert.AreEqual(1, issues.Count);
 
862
                        var issue = issues[0];
 
863
                        Assert.AreEqual(1, issue.Actions.Count);
 
864
                        
 
865
                        CheckFix(context, issue, @"
 
866
interface IFoo
 
867
{
 
868
        void Foo();
 
869
}
 
870
class TestBaseBase : IFoo
 
871
{
 
872
        public virtual void Foo()
 
873
        {
 
874
        }
 
875
}
 
876
class TestBase : TestBaseBase
 
877
{
 
878
        protected virtual new void Foo()
 
879
        {
 
880
        }
 
881
}
 
882
class Test : TestBase
 
883
{
 
884
        void F (TestBase t)
 
885
        {
 
886
                t.Foo();
 
887
        }
 
888
        
 
889
        protected override void Foo()
 
890
        {
 
891
        }
 
892
}");
 
893
                }
 
894
 
 
895
                /// <summary>
 
896
                /// Bug 9617 - Incorrect "parameter can be demoted to base class" warning for arrays
 
897
                /// </summary>
 
898
                [Test]
 
899
                public void TestBug9617()
 
900
                {
 
901
                        Test<ParameterCanBeDemotedIssue>(@"class Test
 
902
{
 
903
        object Foo (object[] arr)
 
904
        {
 
905
            return arr [0];
 
906
        }
 
907
}", 0);
 
908
                }
 
909
                
 
910
                [Test]
 
911
                public void DoNotDemoteStringComparisonToReferenceComparison_WithinLambda()
 
912
                {
 
913
                        Test<ParameterCanBeDemotedIssue>(@"using System; using System.Linq; using System.Collections.Generic;
 
914
class Test
 
915
{
 
916
        IEnumerable<User> users;
 
917
        User GetUser (String id)
 
918
        {
 
919
                return users.Where(u => u.Name == id).SingleOrDefault();
 
920
        }
 
921
}
 
922
class User {
 
923
        public string Name;
 
924
}
 
925
", 0);
 
926
                }
 
927
 
 
928
                [Test]
 
929
                public void TestMicrosoftSuppressMessage()
 
930
                {
 
931
                        var input = @"
 
932
class A
 
933
{
 
934
        public virtual void Foo() {}
 
935
}
 
936
class B : A
 
937
{
 
938
        public virtual void Bar() {}
 
939
}
 
940
class C
 
941
{
 
942
        [System.Diagnostics.CodeAnalysis.SuppressMessage(""Microsoft.Design"", ""CA1011:ConsiderPassingBaseTypesAsParameters"")]
 
943
        void F(B b)
 
944
        {
 
945
                b.Foo();
 
946
        }
 
947
}";
 
948
                        TestRefactoringContext context;
 
949
                        var issues = GetIssues(new ParameterCanBeDemotedIssue(), input, out context);
 
950
                        Assert.AreEqual(0, issues.Count);
 
951
                }
 
952
        }
 
953
}
 
954