← 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/ParameterCompletionTests.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/ParameterCompletionTests.cs
 
1
ļ»æ//
 
2
// ParameterCompletionTests.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 System.Collections.Generic;
 
31
using NUnit.Framework;
 
32
using ICSharpCode.NRefactory.Completion;
 
33
using ICSharpCode.NRefactory.CSharp.Completion;
 
34
using ICSharpCode.NRefactory.Editor;
 
35
using ICSharpCode.NRefactory.TypeSystem.Implementation;
 
36
using ICSharpCode.NRefactory.TypeSystem;
 
37
using System.Linq;
 
38
using ICSharpCode.NRefactory.CSharp.TypeSystem;
 
39
 
 
40
namespace ICSharpCode.NRefactory.CSharp.CodeCompletion
 
41
{
 
42
        [TestFixture()]
 
43
        public class ParameterCompletionTests : TestBase
 
44
        {
 
45
                internal class TestFactory : IParameterCompletionDataFactory
 
46
                {
 
47
                        IProjectContent ctx;
 
48
                        
 
49
                        public TestFactory (IProjectContent ctx)
 
50
                        {
 
51
                                this.ctx = ctx;
 
52
                        }
 
53
                        
 
54
                        class Provider : IParameterDataProvider
 
55
                        {
 
56
                                public IEnumerable<IMethod> Data { get; set; }
 
57
                                #region IParameterDataProvider implementation
 
58
                                public int StartOffset { get { return 0; } }
 
59
                                
 
60
                                public string GetHeading (int overload, string[] parameterDescription, int currentParameter)
 
61
                                {
 
62
                                        return "";
 
63
                                }
 
64
 
 
65
                                public string GetDescription (int overload, int currentParameter)
 
66
                                {
 
67
                                        return "";
 
68
                                }
 
69
 
 
70
                                public string GetParameterDescription (int overload, int paramIndex)
 
71
                                {
 
72
                                        return "";
 
73
                                }
 
74
 
 
75
                                public string GetParameterName(int overload, int currentParameter)
 
76
                                {
 
77
                                        return "";
 
78
                                }
 
79
 
 
80
                                public int GetParameterCount (int overload)
 
81
                                {
 
82
                                        var method = Data.ElementAt (overload);
 
83
                                        return method.Parameters.Count;
 
84
                                }
 
85
 
 
86
                                public bool AllowParameterList (int overload)
 
87
                                {
 
88
                                        return false;
 
89
                                }
 
90
 
 
91
                                public int Count {
 
92
                                        get {
 
93
                                                return Data.Count ();
 
94
                                        }
 
95
                                }
 
96
                                #endregion
 
97
                        }
 
98
                        
 
99
                        class IndexerProvider : IParameterDataProvider
 
100
                        {
 
101
                                public IEnumerable<IProperty> Data { get; set; }
 
102
                                
 
103
                                #region IParameterDataProvider implementation
 
104
                                public int StartOffset { get { return 0; } }
 
105
 
 
106
                                public string GetHeading (int overload, string[] parameterDescription, int currentParameter)
 
107
                                {
 
108
                                        return "";
 
109
                                }
 
110
 
 
111
                                public string GetDescription (int overload, int currentParameter)
 
112
                                {
 
113
                                        return "";
 
114
                                }
 
115
 
 
116
                                public string GetParameterDescription (int overload, int paramIndex)
 
117
                                {
 
118
                                        return "";
 
119
                                }
 
120
 
 
121
                                public string GetParameterName(int overload, int currentParameter)
 
122
                                {
 
123
                                        return "";
 
124
                                }
 
125
 
 
126
                                public int GetParameterCount (int overload)
 
127
                                {
 
128
                                        var method = Data.ElementAt (overload);
 
129
                                        return method.Parameters.Count;
 
130
                                }
 
131
 
 
132
                                public bool AllowParameterList (int overload)
 
133
                                {
 
134
                                        return false;
 
135
                                }
 
136
 
 
137
                                public int Count {
 
138
                                        get {
 
139
                                                return Data.Count ();
 
140
                                        }
 
141
                                }
 
142
                                #endregion
 
143
                        }
 
144
                        
 
145
                        
 
146
                        class ArrayProvider : IParameterDataProvider
 
147
                        {
 
148
                                #region IParameterDataProvider implementation
 
149
                                public int StartOffset { get { return 0; } }
 
150
 
 
151
                                public string GetHeading (int overload, string[] parameterDescription, int currentParameter)
 
152
                                {
 
153
                                        return "";
 
154
                                }
 
155
 
 
156
                                public string GetDescription (int overload, int currentParameter)
 
157
                                {
 
158
                                        return "";
 
159
                                }
 
160
 
 
161
                                public string GetParameterDescription (int overload, int paramIndex)
 
162
                                {
 
163
                                        return "";
 
164
                                }
 
165
 
 
166
                                public int GetParameterCount (int overload)
 
167
                                {
 
168
                                        return 1;
 
169
                                }
 
170
                                public string GetParameterName(int overload, int currentParameter)
 
171
                                {
 
172
                                        return "";
 
173
                                }
 
174
 
 
175
                                public bool AllowParameterList (int overload)
 
176
                                {
 
177
                                        return false;
 
178
                                }
 
179
 
 
180
                                public int Count {
 
181
                                        get {
 
182
                                                return 1;
 
183
                                        }
 
184
                                }
 
185
                                #endregion
 
186
                        }
 
187
                        
 
188
                        class TypeParameterDataProvider : IParameterDataProvider
 
189
                        {
 
190
                                public IEnumerable<IType> Data { get; set; }
 
191
                                #region IParameterDataProvider implementation
 
192
                                public int StartOffset { get { return 0; } }
 
193
                                
 
194
                                public string GetHeading (int overload, string[] parameterDescription, int currentParameter)
 
195
                                {
 
196
                                        return "";
 
197
                                }
 
198
                                
 
199
                                public string GetDescription (int overload, int currentParameter)
 
200
                                {
 
201
                                        return "";
 
202
                                }
 
203
                                
 
204
                                public string GetParameterDescription (int overload, int paramIndex)
 
205
                                {
 
206
                                        return "";
 
207
                                }
 
208
                                
 
209
                                public string GetParameterName(int overload, int currentParameter)
 
210
                                {
 
211
                                        return "";
 
212
                                }
 
213
                                
 
214
                                public int GetParameterCount (int overload)
 
215
                                {
 
216
                                        var data = Data.ElementAt (overload);
 
217
                                        return data.TypeParameterCount;
 
218
                                }
 
219
                                
 
220
                                public bool AllowParameterList (int overload)
 
221
                                {
 
222
                                        return false;
 
223
                                }
 
224
                                
 
225
                                public int Count {
 
226
                                        get {
 
227
                                                return Data.Count ();
 
228
                                        }
 
229
                                }
 
230
                                #endregion
 
231
                        }
 
232
 
 
233
                        class MethodTypeParameterDataProvider : IParameterDataProvider
 
234
                        {
 
235
                                public IEnumerable<IMethod> Data { get; set; }
 
236
                                #region IParameterDataProvider implementation
 
237
                                public int StartOffset { get { return 0; } }
 
238
                                
 
239
                                public string GetHeading (int overload, string[] parameterDescription, int currentParameter)
 
240
                                {
 
241
                                        return "";
 
242
                                }
 
243
                                
 
244
                                public string GetDescription (int overload, int currentParameter)
 
245
                                {
 
246
                                        return "";
 
247
                                }
 
248
                                
 
249
                                public string GetParameterDescription (int overload, int paramIndex)
 
250
                                {
 
251
                                        return "";
 
252
                                }
 
253
                                
 
254
                                public string GetParameterName(int overload, int currentParameter)
 
255
                                {
 
256
                                        return "";
 
257
                                }
 
258
                                
 
259
                                public int GetParameterCount (int overload)
 
260
                                {
 
261
                                        var data = Data.ElementAt (overload);
 
262
                                        return data.TypeArguments.Count;
 
263
                                }
 
264
                                
 
265
                                public bool AllowParameterList (int overload)
 
266
                                {
 
267
                                        return false;
 
268
                                }
 
269
                                
 
270
                                public int Count {
 
271
                                        get {
 
272
                                                return Data.Count ();
 
273
                                        }
 
274
                                }
 
275
                                #endregion
 
276
                        }
 
277
                        
 
278
                        #region IParameterCompletionDataFactory implementation
 
279
                        public IParameterDataProvider CreateConstructorProvider(int startOffset, ICSharpCode.NRefactory.TypeSystem.IType type)
 
280
                        {
 
281
                                Assert.IsTrue(type.Kind != TypeKind.Unknown);
 
282
                                return new Provider () {
 
283
                                        Data = type.GetConstructors (m => m.Accessibility == Accessibility.Public)
 
284
                                };
 
285
                        }
 
286
 
 
287
                        public IParameterDataProvider CreateConstructorProvider(int startOffset, ICSharpCode.NRefactory.TypeSystem.IType type, AstNode skipNode)
 
288
                        {
 
289
                                Assert.IsTrue(type.Kind != TypeKind.Unknown);
 
290
                                return new Provider () {
 
291
                                        Data = type.GetConstructors (m => m.Accessibility == Accessibility.Public)
 
292
                                };
 
293
                        }
 
294
 
 
295
                        public IParameterDataProvider CreateMethodDataProvider (int startOffset, IEnumerable<IMethod> methods)
 
296
                        {
 
297
                                return new Provider () {
 
298
                                        Data = methods
 
299
                                };
 
300
                        }
 
301
 
 
302
                        public IParameterDataProvider CreateDelegateDataProvider(int startOffset, ICSharpCode.NRefactory.TypeSystem.IType type)
 
303
                        {
 
304
                                Assert.IsTrue(type.Kind != TypeKind.Unknown);
 
305
                                return new Provider () {
 
306
                                        Data = new [] { type.GetDelegateInvokeMethod () }
 
307
                                };
 
308
                        }
 
309
                        
 
310
                        public IParameterDataProvider CreateIndexerParameterDataProvider(int startOffset, IType type, IEnumerable<IProperty> accessibleIndexers, AstNode resolvedNode)
 
311
                        {
 
312
                                Assert.IsTrue(type.Kind != TypeKind.Unknown);
 
313
                                if (type.Kind == TypeKind.Array)
 
314
                                        return new ArrayProvider ();
 
315
                                return new IndexerProvider () {
 
316
                                        Data = accessibleIndexers
 
317
                                };
 
318
                        }
 
319
                        
 
320
                        public IParameterDataProvider CreateTypeParameterDataProvider (int startOffset, IEnumerable<IType> types)
 
321
                        {
 
322
                                return new TypeParameterDataProvider () {
 
323
                                        Data = types
 
324
                                };
 
325
                        }
 
326
 
 
327
                        public IParameterDataProvider CreateTypeParameterDataProvider (int startOffset, IEnumerable<IMethod> methods)
 
328
                        {
 
329
                                return new MethodTypeParameterDataProvider () {
 
330
                                        Data = methods
 
331
                                };
 
332
                        }
 
333
                        #endregion
 
334
                }
 
335
                
 
336
                internal static IParameterDataProvider CreateProvider(string text)
 
337
                {
 
338
                        string parsedText;
 
339
                        string editorText;
 
340
                        int cursorPosition = text.IndexOf('$');
 
341
                        int endPos = text.IndexOf('$', cursorPosition + 1);
 
342
                        if (endPos == -1) {
 
343
                                parsedText = editorText = text.Substring(0, cursorPosition) + text.Substring(cursorPosition + 1);
 
344
                        } else {
 
345
                                parsedText = text.Substring(0, cursorPosition) + new string(' ', endPos - cursorPosition) + text.Substring(endPos + 1);
 
346
                                editorText = text.Substring(0, cursorPosition) + text.Substring(cursorPosition + 1, endPos - cursorPosition - 1) + text.Substring(endPos + 1);
 
347
                                cursorPosition = endPos - 1; 
 
348
                        }
 
349
                        var doc = new ReadOnlyDocument(editorText);
 
350
 
 
351
                        IProjectContent pctx = new CSharpProjectContent();
 
352
                        pctx = pctx.AddAssemblyReferences(new [] { CecilLoaderTests.Mscorlib, CecilLoaderTests.SystemCore });
 
353
                        
 
354
                        var syntaxTree = new CSharpParser().Parse(parsedText, "program.cs");
 
355
                        syntaxTree.Freeze();
 
356
                        
 
357
                        var unresolvedFile = syntaxTree.ToTypeSystem();
 
358
                        pctx = pctx.AddOrUpdateFiles(unresolvedFile);
 
359
                        var cmp = pctx.CreateCompilation();
 
360
                        var loc = doc.GetLocation(cursorPosition);
 
361
                        
 
362
                        
 
363
                        var rctx = new CSharpTypeResolveContext(cmp.MainAssembly);
 
364
                        rctx = rctx.WithUsingScope(unresolvedFile.GetUsingScope(loc).Resolve(cmp));
 
365
                        var curDef = unresolvedFile.GetInnermostTypeDefinition(loc);
 
366
                        if (curDef != null) {
 
367
                                rctx = rctx.WithCurrentTypeDefinition(curDef.Resolve(rctx).GetDefinition());
 
368
                                var curMember = unresolvedFile.GetMember(loc);
 
369
                                if (curMember != null) {
 
370
                                        rctx = rctx.WithCurrentMember(curMember.CreateResolved(rctx));
 
371
                                }
 
372
                        }
 
373
                        var mb = new DefaultCompletionContextProvider(doc, unresolvedFile);
 
374
                        var engine = new CSharpParameterCompletionEngine (doc, mb, new TestFactory (pctx), pctx, rctx);
 
375
                        return engine.GetParameterDataProvider (cursorPosition, doc.GetCharAt (cursorPosition - 1));
 
376
                }
 
377
                
 
378
                /// <summary>
 
379
                /// Bug 427448 - Code Completion: completion of constructor parameters not working
 
380
                /// </summary>
 
381
                [Test()]
 
382
                public void TestBug427448 ()
 
383
                {
 
384
                        IParameterDataProvider provider = CreateProvider (
 
385
@"class Test
 
386
{
 
387
        public Test (int a)
 
388
        {
 
389
        }
 
390
        
 
391
        public Test (string b)
 
392
        {
 
393
        }
 
394
        protected Test ()
 
395
        {
 
396
        }
 
397
        Test (double d, float m)
 
398
        {
 
399
        }
 
400
}
 
401
 
 
402
class AClass
 
403
{
 
404
        void A()
 
405
        {
 
406
                $Test t = new Test ($
 
407
        }
 
408
}");
 
409
                        Assert.IsNotNull (provider, "provider was not created.");
 
410
                        Assert.AreEqual (2, provider.Count);
 
411
                }
 
412
 
 
413
                /// <summary>
 
414
                /// Bug 432437 - No completion when invoking delegates
 
415
                /// </summary>
 
416
                [Test()]
 
417
                public void TestBug432437 ()
 
418
                {
 
419
                        IParameterDataProvider provider = CreateProvider (
 
420
@"public delegate void MyDel (int value);
 
421
 
 
422
class Test
 
423
{
 
424
        MyDel d;
 
425
 
 
426
        void A()
 
427
        {
 
428
                $d ($
 
429
        }
 
430
}");
 
431
                        Assert.IsNotNull (provider, "provider was not created.");
 
432
                        Assert.AreEqual (1, provider.Count);
 
433
                }
 
434
 
 
435
                /// <summary>
 
436
                /// Bug 432658 - Incorrect completion when calling an extension method from inside another extension method
 
437
                /// </summary>
 
438
                [Test()]
 
439
                public void TestBug432658 ()
 
440
                {
 
441
                        IParameterDataProvider provider = CreateProvider (
 
442
@"static class Extensions
 
443
{
 
444
        public static void Ext1 (this int start)
 
445
        {
 
446
        }
 
447
        public static void Ext2 (this int end)
 
448
        {
 
449
                $Ext1($
 
450
        }
 
451
}");
 
452
                        Assert.IsNotNull (provider, "provider was not created.");
 
453
                        Assert.AreEqual (1, provider.Count, "There should be one overload");
 
454
                        Assert.AreEqual (1, provider.GetParameterCount(0), "Parameter 'start' should exist");
 
455
                }
 
456
 
 
457
                /// <summary>
 
458
                /// Bug 432727 - No completion if no constructor
 
459
                /// </summary>
 
460
                [Test()]
 
461
                public void TestBug432727 ()
 
462
                {
 
463
                        IParameterDataProvider provider = CreateProvider (
 
464
@"class A
 
465
{
 
466
        void Method ()
 
467
        {
 
468
                $A aTest = new A ($
 
469
        }
 
470
}");
 
471
                        Assert.IsNotNull (provider, "provider was not created.");
 
472
                        Assert.AreEqual (1, provider.Count);
 
473
                }
 
474
 
 
475
                /// <summary>
 
476
                /// Bug 434705 - No autocomplete offered if not assigning result of 'new' to a variable
 
477
                /// </summary>
 
478
                [Test()]
 
479
                public void TestBug434705 ()
 
480
                {
 
481
                        IParameterDataProvider provider = CreateProvider (
 
482
@"class Test
 
483
{
 
484
        public Test (int a)
 
485
        {
 
486
        }
 
487
}
 
488
 
 
489
class AClass
 
490
{
 
491
        Test A()
 
492
        {
 
493
                $return new Test ($
 
494
        }
 
495
}");
 
496
                        Assert.IsNotNull (provider, "provider was not created.");
 
497
                        Assert.AreEqual (1, provider.Count);
 
498
                }
 
499
                
 
500
                /// <summary>
 
501
                /// Bug 434705 - No autocomplete offered if not assigning result of 'new' to a variable
 
502
                /// </summary>
 
503
                [Test()]
 
504
                public void TestBug434705B ()
 
505
                {
 
506
                        IParameterDataProvider provider = CreateProvider (
 
507
@"
 
508
class Test<T>
 
509
{
 
510
        public Test (T t)
 
511
        {
 
512
        }
 
513
}
 
514
class TestClass
 
515
{
 
516
        void TestMethod ()
 
517
        {
 
518
                $Test<int> l = new Test<int> ($
 
519
        }
 
520
}");
 
521
                        Assert.IsNotNull (provider, "provider was not created.");
 
522
                        Assert.AreEqual (1, provider.Count);
 
523
                }
 
524
        
 
525
                
 
526
                /// <summary>
 
527
                /// Bug 434701 - No autocomplete in attributes
 
528
                /// </summary>
 
529
                [Test()]
 
530
                public void TestBug434701 ()
 
531
                {
 
532
                        IParameterDataProvider provider = CreateProvider (
 
533
@"namespace Test {
 
534
class TestAttribute : System.Attribute
 
535
{
 
536
        public Test (int a)
 
537
        {
 
538
        }
 
539
}
 
540
 
 
541
$[Test ($
 
542
class AClass
 
543
{
 
544
}
 
545
}");
 
546
                        Assert.IsNotNull (provider, "provider was not created.");
 
547
                        Assert.AreEqual (1, provider.Count);
 
548
                }
 
549
                
 
550
                /// <summary>
 
551
                /// Bug 447985 - Exception display tip is inaccurate for derived (custom) exceptions
 
552
                /// </summary>
 
553
                [Test()]
 
554
                public void TestBug447985 ()
 
555
                {
 
556
                        IParameterDataProvider provider = CreateProvider (
 
557
@"
 
558
namespace System {
 
559
        public class Exception
 
560
        {
 
561
                public Exception () {}
 
562
        }
 
563
}
 
564
 
 
565
class MyException : System.Exception
 
566
{
 
567
        public MyException (int test)
 
568
        {}
 
569
}
 
570
 
 
571
class AClass
 
572
{
 
573
        public void Test ()
 
574
        {
 
575
                $throw new MyException($
 
576
        }
 
577
 
 
578
}");
 
579
                        Assert.IsNotNull (provider, "provider was not created.");
 
580
                        Assert.AreEqual (1, provider.Count);
 
581
                        Assert.AreEqual (1, provider.GetParameterCount(0), "Parameter 'test' should exist");
 
582
                }
 
583
                
 
584
                
 
585
                /// <summary>
 
586
                /// Bug 1760 - [New Resolver] Parameter tooltip not shown for indexers 
 
587
                /// </summary>
 
588
                [Test()]
 
589
                public void Test1760 ()
 
590
                {
 
591
                        var provider = CreateProvider (
 
592
@"
 
593
class TestClass
 
594
{
 
595
        public static void Main (string[] args)
 
596
        {
 
597
                $args[$
 
598
        }
 
599
}");
 
600
                        Assert.IsNotNull (provider, "provider was not created.");
 
601
                        Assert.AreEqual (1, provider.Count);
 
602
                }
 
603
                
 
604
                [Test()]
 
605
                public void TestSecondIndexerParameter ()
 
606
                {
 
607
                        var provider = CreateProvider (
 
608
@"
 
609
class TestClass
 
610
{
 
611
        public int this[int i, int j] { get { return 0; } } 
 
612
        public void Test ()
 
613
        {
 
614
                $this[1,$
 
615
        }
 
616
}");
 
617
                        Assert.IsNotNull (provider, "provider was not created.");
 
618
                        Assert.AreEqual (1, provider.Count);
 
619
                }
 
620
                
 
621
                [Test()]
 
622
                public void TestSecondMethodParameter ()
 
623
                {
 
624
                        var provider = CreateProvider (
 
625
@"
 
626
class TestClass
 
627
{
 
628
        public int TestMe (int i, int j) { return 0; } 
 
629
        public void Test ()
 
630
        {
 
631
                $TestMe (1,$
 
632
        }
 
633
}");
 
634
                        Assert.IsNotNull (provider, "provider was not created.");
 
635
                        Assert.AreEqual (1, provider.Count);
 
636
                }
 
637
                
 
638
                
 
639
                /// Bug 599 - Regression: No intellisense over Func delegate
 
640
                [Test()]
 
641
                public void TestBug599 ()
 
642
                {
 
643
                        var provider = CreateProvider (
 
644
@"using System;
 
645
using System.Core;
 
646
 
 
647
class TestClass
 
648
{
 
649
        void A (Func<int, int> f)
 
650
        {
 
651
                $f ($
 
652
        }
 
653
}");
 
654
                        Assert.IsNotNull (provider, "provider was not created.");
 
655
                        Assert.AreEqual (1, provider.Count);
 
656
                }
 
657
                
 
658
                /// Bug 3307 - Chained linq methods do not work correctly
 
659
                [Test()]
 
660
                public void TestBug3307 ()
 
661
                {
 
662
                        var provider = CreateProvider (
 
663
@"using System;
 
664
using System.Linq;
 
665
 
 
666
class TestClass
 
667
{
 
668
        public static void Main (string[] args)
 
669
        {
 
670
                $args.Select ($
 
671
        }
 
672
}");
 
673
                        Assert.IsNotNull (provider, "provider was not created.");
 
674
                        Assert.IsTrue (provider.Count > 0);
 
675
                }
 
676
                
 
677
                [Test()]
 
678
                public void TestBug3307FollowUp ()
 
679
                {
 
680
                        var provider = CodeCompletionBugTests.CreateProvider (
 
681
@"using System;
 
682
using System.Linq;
 
683
 
 
684
public class MainClass
 
685
{
 
686
        static void TestMe (Action<int> act)
 
687
        {
 
688
        }
 
689
        
 
690
        public static void Main (string[] args)
 
691
        {
 
692
                $TestMe (x$
 
693
        }
 
694
}");
 
695
                        Assert.IsNotNull (provider, "provider was not created.");
 
696
                        Assert.IsFalse (provider.AutoSelect, "auto select enabled !");
 
697
                }
 
698
                
 
699
                [Test()]
 
700
                public void TestBug3307FollowUp2 ()
 
701
                {
 
702
                        var provider = CodeCompletionBugTests.CreateProvider (
 
703
@"using System;
 
704
using System.Linq;
 
705
 
 
706
public class MainClass
 
707
{
 
708
        public static void Main (string[] args)
 
709
        {
 
710
                $args.Select (x$
 
711
        }
 
712
}");
 
713
                        Assert.IsNotNull (provider, "provider was not created.");
 
714
                        Assert.IsFalse (provider.AutoSelect, "auto select enabled !");
 
715
                }
 
716
                
 
717
                [Test()]
 
718
                public void TestConstructor ()
 
719
                {
 
720
                        IParameterDataProvider provider = CreateProvider (
 
721
@"class Foo { public Foo (int a) {} }
 
722
 
 
723
class A
 
724
{
 
725
        void Method ()
 
726
        {
 
727
                $Bar = new Foo ($
 
728
        }
 
729
}");
 
730
                        Assert.IsNotNull (provider, "provider was not created.");
 
731
                        Assert.AreEqual (1, provider.Count);
 
732
                }
 
733
                
 
734
                
 
735
                [Test()]
 
736
                public void TestConstructorCase2 ()
 
737
                {
 
738
                        IParameterDataProvider provider = CreateProvider (
 
739
@"
 
740
namespace Test 
 
741
{
 
742
        struct TestMe 
 
743
        {
 
744
                public TestMe (string a)
 
745
                {
 
746
                }
 
747
        }
 
748
        
 
749
        class A
 
750
        {
 
751
                void Method ()
 
752
                {
 
753
                        $new TestMe ($
 
754
                }
 
755
        }
 
756
}");
 
757
                        Assert.IsNotNull (provider, "provider was not created.");
 
758
                        Assert.AreEqual (2, provider.Count);
 
759
                }
 
760
                
 
761
                [Test()]
 
762
                public void TestTypeParameter ()
 
763
                {
 
764
                        IParameterDataProvider provider = CreateProvider (
 
765
@"using System;
 
766
 
 
767
namespace Test 
 
768
{
 
769
        class A
 
770
        {
 
771
                void Method ()
 
772
                {
 
773
                        $Action<$
 
774
                }
 
775
        }
 
776
}");
 
777
                        Assert.IsNotNull (provider, "provider was not created.");
 
778
                        Assert.AreEqual (16, provider.Count);
 
779
                }
 
780
                
 
781
                [Test()]
 
782
                public void TestSecondTypeParameter ()
 
783
                {
 
784
                        IParameterDataProvider provider = CreateProvider (
 
785
@"using System;
 
786
 
 
787
namespace Test 
 
788
{
 
789
        class A
 
790
        {
 
791
                void Method ()
 
792
                {
 
793
                        $Action<string,$
 
794
                }
 
795
        }
 
796
}");
 
797
                        Assert.IsNotNull (provider, "provider was not created.");
 
798
                        Assert.AreEqual (16, provider.Count);
 
799
                }
 
800
                
 
801
                [Ignore("TODO")]
 
802
                [Test()]
 
803
                public void TestMethodTypeParameter ()
 
804
                {
 
805
                        IParameterDataProvider provider = CreateProvider (
 
806
@"using System;
 
807
 
 
808
namespace Test 
 
809
{
 
810
        class A
 
811
        {
 
812
                void TestMethod<T, S>()
 
813
                {
 
814
                }
 
815
 
 
816
                void Method ()
 
817
                {
 
818
                        $TestMethod<$
 
819
                }
 
820
        }
 
821
}");
 
822
                        Assert.IsNotNull (provider, "provider was not created.");
 
823
                        Assert.AreEqual (1, provider.Count);
 
824
                }
 
825
                
 
826
                [Ignore("TODO")]
 
827
                [Test()]
 
828
                public void TestSecondMethodTypeParameter ()
 
829
                {
 
830
                        IParameterDataProvider provider = CreateProvider (
 
831
@"using System;
 
832
 
 
833
namespace Test 
 
834
{
 
835
        class A
 
836
        {
 
837
                void TestMethod<T, S>()
 
838
                {
 
839
                }
 
840
 
 
841
                void Method ()
 
842
                {
 
843
                        $TestMethod<string,$
 
844
                }
 
845
        }
 
846
}");
 
847
                        Assert.IsNotNull (provider, "provider was not created.");
 
848
                        Assert.AreEqual (1, provider.Count);
 
849
                }               
 
850
        
 
851
                [Test()]
 
852
                public void TestArrayParameter ()
 
853
                {
 
854
                        var provider = CreateProvider (
 
855
@"
 
856
class TestClass
 
857
{
 
858
        public void Method()
 
859
        {
 
860
                int[,,,] arr;
 
861
                $arr[$
 
862
        }
 
863
}");
 
864
                        Assert.IsNotNull (provider, "provider was not created.");
 
865
                        Assert.AreEqual (1, provider.Count);
 
866
                }
 
867
                
 
868
                [Test()]
 
869
                public void TestSecondArrayParameter ()
 
870
                {
 
871
                        var provider = CreateProvider (
 
872
@"
 
873
class TestClass
 
874
{
 
875
        public void Method()
 
876
        {
 
877
                int[,,,] arr;
 
878
                $arr[5,$
 
879
        }
 
880
}");
 
881
                        Assert.IsNotNull (provider, "provider was not created.");
 
882
                        Assert.AreEqual (1, provider.Count);
 
883
                }
 
884
                
 
885
                [Ignore("TODO!")]
 
886
                [Test()]
 
887
                public void TestTypeParameterInBaseType ()
 
888
                {
 
889
                        IParameterDataProvider provider = CreateProvider (
 
890
@"using System;
 
891
 
 
892
namespace Test 
 
893
{
 
894
        $class A : Tuple<$
 
895
}");
 
896
                        Assert.IsNotNull (provider, "provider was not created.");
 
897
                        Assert.AreEqual (16, provider.Count);
 
898
                }
 
899
                
 
900
                
 
901
                [Test()]
 
902
                public void TestBaseConstructorCall ()
 
903
                {
 
904
                        IParameterDataProvider provider = CreateProvider (
 
905
@"class Base
 
906
{
 
907
        public Base (int i)
 
908
        {
 
909
                        
 
910
        }
 
911
        public Base (int i, string s)
 
912
        {
 
913
                        
 
914
        }
 
915
}
 
916
 
 
917
namespace Test 
 
918
{
 
919
        class A : Base
 
920
        {
 
921
                $public A () : base($
 
922
        }
 
923
}");
 
924
                        Assert.IsNotNull (provider, "provider was not created.");
 
925
                        Assert.AreEqual (2, provider.Count);
 
926
                }
 
927
                
 
928
                [Test()]
 
929
                public void TestThisConstructorCall ()
 
930
                {
 
931
                        IParameterDataProvider provider = CreateProvider (
 
932
@"class Base
 
933
{
 
934
        public Base (int i)
 
935
        {
 
936
                        
 
937
        }
 
938
        public Base (int i, string s)
 
939
        {
 
940
                        
 
941
        }
 
942
}
 
943
 
 
944
namespace Test 
 
945
{
 
946
        class A : Base
 
947
        {
 
948
                public A (int a, int b) : base(a) {}
 
949
 
 
950
                $public A () : this($
 
951
        }
 
952
}");
 
953
                        Assert.IsNotNull (provider, "provider was not created.");
 
954
                        Assert.AreEqual (1, provider.Count);
 
955
                }
 
956
                
 
957
                /// <summary>
 
958
                /// Bug 3645 - [New Resolver]Parameter completion shows all static and non-static overloads
 
959
                /// </summary>
 
960
                [Test()]
 
961
                public void TestBug3645 ()
 
962
                {
 
963
                        IParameterDataProvider provider = CreateProvider (
 
964
@"class Main
 
965
{
 
966
        public static void FooBar (string str)
 
967
        {
 
968
        }
 
969
        
 
970
        public void FooBar (int i)
 
971
        {
 
972
                
 
973
        }
 
974
        
 
975
        public static void Main (string[] args)
 
976
        {
 
977
                $FooBar ($
 
978
        }
 
979
}");
 
980
                        Assert.IsNotNull (provider, "provider was not created.");
 
981
                        Assert.AreEqual (1, provider.Count);
 
982
                }
 
983
 
 
984
                /// <summary>
 
985
                /// Bug 3991 - constructor argument completion not working for attributes applied to methods or parameters
 
986
                /// </summary>
 
987
                [Test()]
 
988
                public void TestBug3991()
 
989
                {
 
990
                        IParameterDataProvider provider = CreateProvider(
 
991
@"using System;
 
992
namespace Test
 
993
{
 
994
        class TestClass
 
995
        {
 
996
                [Obsolete$($]
 
997
                TestClass()
 
998
                {
 
999
                }
 
1000
        }
 
1001
}
 
1002
");
 
1003
                        Assert.IsNotNull(provider, "provider was not created.");
 
1004
                        Assert.Greater(provider.Count, 0);
 
1005
                }
 
1006
 
 
1007
                /// <summary>
 
1008
                /// Bug 4087 - code completion handles object and collection initializers (braces) incorrectly in method calls
 
1009
                /// </summary>
 
1010
                [Test()]
 
1011
                public void TestBug4087()
 
1012
                {
 
1013
                        IParameterDataProvider provider = CreateProvider(
 
1014
@"using System;
 
1015
class TestClass
 
1016
{
 
1017
        TestClass()
 
1018
        {
 
1019
                $Console.WriteLine (new int[]{ 4, 5,$
 
1020
        }
 
1021
}
 
1022
");
 
1023
                        Assert.IsTrue (provider == null || provider.Count == 0);
 
1024
                }
 
1025
 
 
1026
                /// <summary>
 
1027
                /// Bug 4927 - [New Resolver] Autocomplete shows non-static methods when using class name
 
1028
                /// </summary>
 
1029
                [Test()]
 
1030
                public void TestBug4927 ()
 
1031
                {
 
1032
                        IParameterDataProvider provider = CreateProvider (
 
1033
@"
 
1034
public class A
 
1035
{
 
1036
  // static method
 
1037
  public static void Method(string someParameter, object anotherParameter)
 
1038
  {
 
1039
  }
 
1040
 
 
1041
  // instance method
 
1042
  public void Method()
 
1043
  {
 
1044
  }
 
1045
}
 
1046
 
 
1047
 
 
1048
public class B
 
1049
{
 
1050
  public static void Main()
 
1051
  {
 
1052
    $A.Method($
 
1053
  }
 
1054
}
 
1055
");
 
1056
                        Assert.IsNotNull (provider, "provider was not created.");
 
1057
                        Assert.AreEqual (1, provider.Count);
 
1058
                }
 
1059
 
 
1060
 
 
1061
                [Test()]
 
1062
                public void TestLambdaCase()
 
1063
                {
 
1064
                        IParameterDataProvider provider = CreateProvider(
 
1065
                                @"using System;
 
1066
class TestClass
 
1067
{    
 
1068
        void F (Action i, int foo)
 
1069
        {
 
1070
                $F (()=> Something(),$
 
1071
 
 
1072
        }
 
1073
}
 
1074
");
 
1075
                        Assert.IsTrue (provider != null && provider.Count == 1);
 
1076
                }
 
1077
 
 
1078
                [Test()]
 
1079
                public void TestJaggedArrayCreation()
 
1080
                {
 
1081
                        IParameterDataProvider provider = CreateProvider(
 
1082
                                @"using System;
 
1083
class TestClass
 
1084
{    
 
1085
        void F (Action i, int foo)
 
1086
        {
 
1087
                $new foo[1,2][$
 
1088
 
 
1089
        }
 
1090
}
 
1091
");
 
1092
                        Assert.IsTrue (provider == null || provider.Count == 0);
 
1093
                }
 
1094
 
 
1095
                [Test]
 
1096
                public void TestJaggedArrayCreationCase2()
 
1097
                {
 
1098
                        IParameterDataProvider provider = CreateProvider(
 
1099
                                @"using System;
 
1100
class TestClass
 
1101
{    
 
1102
        void F (Action i, int foo)
 
1103
        {
 
1104
                $new foo[1,2][1,$
 
1105
 
 
1106
        }
 
1107
}
 
1108
");
 
1109
                        Assert.IsTrue (provider == null || provider.Count == 0);
 
1110
                }
 
1111
 
 
1112
                /// <summary>
 
1113
                /// Bug 9301 - Inaccessible indexer overload in completion 
 
1114
                /// </summary>
 
1115
                [Test]
 
1116
                public void TestBug9301()
 
1117
                {
 
1118
                        IParameterDataProvider provider = CreateProvider(
 
1119
                                @"using System;
 
1120
 
 
1121
public class A
 
1122
{
 
1123
        public virtual int this [int i, string s] {
 
1124
                get {
 
1125
                        return 1;
 
1126
                }
 
1127
        }
 
1128
}
 
1129
 
 
1130
public class B : A
 
1131
{
 
1132
        public new bool this [int i, string s2] {
 
1133
                get {
 
1134
                        return true;
 
1135
                }
 
1136
        }
 
1137
}
 
1138
 
 
1139
public class Test
 
1140
{
 
1141
        public static int Main ()
 
1142
        {
 
1143
                B p = new B ();
 
1144
                $p[$
 
1145
                return 0;
 
1146
        }
 
1147
}
 
1148
");
 
1149
                        Assert.AreEqual (1, provider.Count);
 
1150
                }
 
1151
 
 
1152
                [Test]
 
1153
                public void TestBug9301Case2()
 
1154
                {
 
1155
                        IParameterDataProvider provider = CreateProvider(
 
1156
                                @"using System;
 
1157
 
 
1158
public class A
 
1159
{
 
1160
        public virtual int Test (int i, string s) {
 
1161
                return 1;
 
1162
        }
 
1163
}
 
1164
 
 
1165
public class B : A
 
1166
{
 
1167
        public new bool Test (int i, string s2) {
 
1168
                return true;
 
1169
        }
 
1170
}
 
1171
 
 
1172
public class Test
 
1173
{
 
1174
        public static int Main ()
 
1175
        {
 
1176
                B p = new B ();
 
1177
                $p.Test($
 
1178
                return 0;
 
1179
        }
 
1180
}
 
1181
");
 
1182
                        Assert.AreEqual (1, provider.Count);
 
1183
                }
 
1184
 
 
1185
                [Test]
 
1186
                public void TestExtensionMethod()
 
1187
                {
 
1188
                        var provider = CreateProvider(@"static class Ext { public static void Foo(this object o, string str) {} }
 
1189
class Test
 
1190
{
 
1191
        public static void Main (string[] args)
 
1192
        {
 
1193
                $args.Foo($
 
1194
        }
 
1195
}");
 
1196
                        Assert.AreEqual (1, provider.Count);
 
1197
                        Assert.AreEqual (1, provider.GetParameterCount (0));
 
1198
                }
 
1199
                
 
1200
                
 
1201
                [Test]
 
1202
                public void TestExtensionMethodStaticInvocation()
 
1203
                {
 
1204
                        var provider = CreateProvider(@"static class Ext { public static void Foo(this object o, string str) {} }
 
1205
class Test
 
1206
{
 
1207
        public static void Main (string[] args)
 
1208
        {
 
1209
                $Ext.Foo($
 
1210
        }
 
1211
}");
 
1212
                        Assert.AreEqual (1, provider.Count);
 
1213
                        Assert.AreEqual (2, provider.GetParameterCount (0));
 
1214
                }
 
1215
 
 
1216
                [Test]
 
1217
                public void TypeArgumentsInIncompleteMethodCall ()
 
1218
                {
 
1219
                        var provider = CreateProvider (
 
1220
                                @"using System.Collections.Generic;
 
1221
using System.Linq;
 
1222
class NUnitTestClass {
 
1223
    public ICollection<ITest> NestedTestCollection { get; set; }
 
1224
    public NUnitTestMethod FindTestMethodWithShortName(string name)
 
1225
    {
 
1226
        this.NestedTestCollection$.OfType<$.LastOrDefault(
 
1227
    }
 
1228
}");
 
1229
                        Assert.AreEqual (1, provider.Count);
 
1230
                }
 
1231
        }
 
1232
}
 
 
b'\\ No newline at end of file'