← 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/CodeCompletionAccessibleTests.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/CodeCompletionAccessibleTests.cs
 
1
//
 
2
// CodeCompletionAccessibleTests.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
using System.Diagnostics;
 
32
using System.Linq;
 
33
 
 
34
namespace ICSharpCode.NRefactory.CSharp.CodeCompletion
 
35
{
 
36
        [TestFixture]
 
37
        public class CodeCompletionAccessibleTests : TestBase
 
38
        {
 
39
                
 
40
                static string testClass = @"
 
41
using System;
 
42
 
 
43
public class TestClass
 
44
{
 
45
        public int PubField;
 
46
        public int PubProperty { get; set; }
 
47
        public void PubMethod () { }
 
48
 
 
49
        protected int ProtField;
 
50
        protected int ProtProperty { get; set; }
 
51
        protected void ProtMethod () { }
 
52
 
 
53
        internal protected int ProtOrInternalField;
 
54
        internal protected int ProtOrInternalProperty { get; set; }
 
55
        internal protected void ProtOrInternalMethod () { }
 
56
        
 
57
        protected internal int ProtAndInternalField;
 
58
        protected internal int ProtAndInternalProperty { get; set; }
 
59
        protected internal void ProtAndInternalMethod () { }
 
60
 
 
61
        internal int InternalField;
 
62
        internal int InternalProperty { get; set; }
 
63
        internal void InternalMethod () { }
 
64
 
 
65
        private int PrivField;
 
66
        private int PrivProperty { get; set; }
 
67
        private void PrivMethod () { }
 
68
 
 
69
        public static int PubStaticField;
 
70
        public static int PubStaticProperty { get; set; }
 
71
        public static void PubStaticMethod () { }
 
72
 
 
73
        protected static int ProtStaticField;
 
74
        protected static int ProtStaticProperty { get; set; }
 
75
        protected static void ProtStaticMethod () { }
 
76
        
 
77
        private static int PrivStaticField;
 
78
        private static int PrivStaticProperty { get; set; }
 
79
        private static void PrivStaticMethod () { }
 
80
";
 
81
                [Test()]
 
82
                public void TestDerivedClassGeneralAccess ()
 
83
                {
 
84
                        CodeCompletionBugTests.CombinedProviderTest(testClass + @"}
 
85
// from
 
86
class Test : TestClass {
 
87
        public void Foo ()
 
88
        {
 
89
                $a$
 
90
        }
 
91
}", provider => {
 
92
                                Assert.IsNotNull (provider.Find ("PubField"), "'PubField' not found.");
 
93
                                Assert.IsNotNull (provider.Find ("PubProperty"), "'PubProperty' not found.");
 
94
                                Assert.IsNotNull (provider.Find ("PubMethod"), "'PubMethod' not found.");
 
95
        
 
96
                                Assert.IsNotNull (provider.Find ("ProtField"), "'ProtField' not found.");
 
97
                                Assert.IsNotNull (provider.Find ("ProtProperty"), "'ProtProperty' not found.");
 
98
                                Assert.IsNotNull (provider.Find ("ProtMethod"), "'ProtMethod' not found.");
 
99
        
 
100
                                Assert.IsNotNull (provider.Find ("ProtOrInternalField"), "'ProtOrInternalField' not found.");
 
101
                                Assert.IsNotNull (provider.Find ("ProtOrInternalProperty"), "'ProtOrInternalProperty' not found.");
 
102
                                Assert.IsNotNull (provider.Find ("ProtOrInternalMethod"), "'ProtOrInternalMethod' not found.");
 
103
        
 
104
                                Assert.IsNotNull (provider.Find ("ProtAndInternalField"), "'ProtAndInternalField' not found.");
 
105
                                Assert.IsNotNull (provider.Find ("ProtAndInternalProperty"), "'ProtAndInternalProperty' not found.");
 
106
                                Assert.IsNotNull (provider.Find ("ProtAndInternalMethod"), "'ProtAndInternalMethod' not found.");
 
107
        
 
108
                                Assert.IsNotNull (provider.Find ("InternalField"), "'InternalField' not found.");
 
109
                                Assert.IsNotNull (provider.Find ("InternalProperty"), "'InternalProperty' not found.");
 
110
                                Assert.IsNotNull (provider.Find ("InternalMethod"), "'InternalMethod' not found.");
 
111
        
 
112
                                Assert.IsNotNull (provider.Find ("PubStaticField"), "'PubStaticField' not found.");
 
113
                                Assert.IsNotNull (provider.Find ("PubStaticProperty"), "'PubStaticProperty' not found.");
 
114
                                Assert.IsNotNull (provider.Find ("PubStaticMethod"), "'PubStaticMethod' not found.");
 
115
                                
 
116
                                Assert.IsNotNull (provider.Find ("ProtStaticField"), "'ProtStaticField' not found.");
 
117
                                Assert.IsNotNull (provider.Find ("ProtStaticProperty"), "'ProtStaticProperty' not found.");
 
118
                                Assert.IsNotNull (provider.Find ("ProtStaticMethod"), "'ProtStaticMethod' not found.");
 
119
                                
 
120
                                Assert.IsNull (provider.Find ("PrivField"), "'PrivField' found.");
 
121
                                Assert.IsNull (provider.Find ("PrivProperty"), "'PrivProperty' found.");
 
122
                                Assert.IsNull (provider.Find ("PrivMethod"), "'PrivMethod' found.");
 
123
 
 
124
                                Assert.IsNull (provider.Find ("PrivStaticField"), "'PrivStaticField' found.");
 
125
                                Assert.IsNull (provider.Find ("PrivStaticProperty"), "'PrivStaticProperty' found.");
 
126
                                Assert.IsNull (provider.Find ("PrivStaticMethod"), "'PrivStaticMethod' found.");
 
127
                        });
 
128
                }
 
129
        
 
130
                [Test()]
 
131
                public void TestDerivedClassMemberReferenceAccess ()
 
132
                {
 
133
                        CodeCompletionBugTests.CombinedProviderTest(testClass + @"}
 
134
// from
 
135
class Test : TestClass {
 
136
        public void Foo ()
 
137
        {
 
138
                $this.$
 
139
        }
 
140
}", provider => {
 
141
                                Assert.IsNotNull (provider.Find ("PubField"), "'PubField' not found.");
 
142
                                Assert.IsNotNull (provider.Find ("PubProperty"), "'PubProperty' not found.");
 
143
                                Assert.IsNotNull (provider.Find ("PubMethod"), "'PubMethod' not found.");
 
144
        
 
145
                                Assert.IsNotNull (provider.Find ("ProtField"), "'ProtField' not found.");
 
146
                                Assert.IsNotNull (provider.Find ("ProtProperty"), "'ProtProperty' not found.");
 
147
                                Assert.IsNotNull (provider.Find ("ProtMethod"), "'ProtMethod' not found.");
 
148
        
 
149
                                Assert.IsNotNull (provider.Find ("ProtOrInternalField"), "'ProtOrInternalField' not found.");
 
150
                                Assert.IsNotNull (provider.Find ("ProtOrInternalProperty"), "'ProtOrInternalProperty' not found.");
 
151
                                Assert.IsNotNull (provider.Find ("ProtOrInternalMethod"), "'ProtOrInternalMethod' not found.");
 
152
        
 
153
                                Assert.IsNotNull (provider.Find ("ProtAndInternalField"), "'ProtAndInternalField' not found.");
 
154
                                Assert.IsNotNull (provider.Find ("ProtAndInternalProperty"), "'ProtAndInternalProperty' not found.");
 
155
                                Assert.IsNotNull (provider.Find ("ProtAndInternalMethod"), "'ProtAndInternalMethod' not found.");
 
156
        
 
157
                                Assert.IsNotNull (provider.Find ("InternalField"), "'InternalField' not found.");
 
158
                                Assert.IsNotNull (provider.Find ("InternalProperty"), "'InternalProperty' not found.");
 
159
                                Assert.IsNotNull (provider.Find ("InternalMethod"), "'InternalMethod' not found.");
 
160
        
 
161
//                              Assert.IsNotNull (provider.Find ("PubStaticField"), "'PubStaticField' not found.");
 
162
//                              Assert.IsNotNull (provider.Find ("PubStaticProperty"), "'PubStaticProperty' not found.");
 
163
//                              Assert.IsNotNull (provider.Find ("PubStaticMethod"), "'PubStaticMethod' not found.");
 
164
//                              
 
165
//                              Assert.IsNotNull (provider.Find ("ProtStaticField"), "'ProtStaticField' not found.");
 
166
//                              Assert.IsNotNull (provider.Find ("ProtStaticProperty"), "'ProtStaticProperty' not found.");
 
167
//                              Assert.IsNotNull (provider.Find ("ProtStaticMethod"), "'ProtStaticMethod' not found.");
 
168
//                              
 
169
                                Assert.IsNull (provider.Find ("PrivField"), "'PrivField' found.");
 
170
                                Assert.IsNull (provider.Find ("PrivProperty"), "'PrivProperty' found.");
 
171
                                Assert.IsNull (provider.Find ("PrivMethod"), "'PrivMethod' found.");
 
172
 
 
173
                                Assert.IsNull (provider.Find ("PrivStaticField"), "'PrivStaticField' found.");
 
174
                                Assert.IsNull (provider.Find ("PrivStaticProperty"), "'PrivStaticProperty' found.");
 
175
                                Assert.IsNull (provider.Find ("PrivStaticMethod"), "'PrivStaticMethod' found.");
 
176
                        });
 
177
                }
 
178
        
 
179
 
 
180
 
 
181
                [Test()]
 
182
                public void TestNonStaticClassAccess ()
 
183
                {
 
184
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (testClass +
 
185
@"
 
186
        void TestMethod () 
 
187
        {
 
188
                $this.$
 
189
        }
 
190
}");
 
191
                        Assert.IsNotNull (provider, "provider == null");
 
192
                        
 
193
                        CodeCompletionBugTests.CheckProtectedObjectMembers (provider); // 5 from System.Object
 
194
                        Assert.IsNotNull (provider.Find ("PubField"));
 
195
                        Assert.IsNotNull (provider.Find ("PubProperty"));
 
196
                        Assert.IsNotNull (provider.Find ("PubMethod"));
 
197
                        
 
198
                        Assert.IsNotNull (provider.Find ("ProtField"));
 
199
                        Assert.IsNotNull (provider.Find ("ProtProperty"));
 
200
                        Assert.IsNotNull (provider.Find ("ProtMethod"));
 
201
                        
 
202
                        Assert.IsNotNull (provider.Find ("PrivField"));
 
203
                        Assert.IsNotNull (provider.Find ("PrivProperty"));
 
204
                        Assert.IsNotNull (provider.Find ("PrivMethod"));
 
205
                }
 
206
                
 
207
                [Test()]
 
208
                public void TestInternalAccess ()
 
209
                {
 
210
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (testClass +
 
211
@"
 
212
        void TestMethod () 
 
213
        {
 
214
                $this.$
 
215
        }
 
216
}");
 
217
                        Assert.IsNotNull (provider, "provider == null");
 
218
                        
 
219
                        Assert.IsNotNull (provider.Find ("InternalField"));
 
220
                        Assert.IsNotNull (provider.Find ("InternalProperty"));
 
221
                        Assert.IsNotNull (provider.Find ("InternalMethod"));
 
222
                        
 
223
                        Assert.IsNotNull (provider.Find ("ProtAndInternalField"));
 
224
                        Assert.IsNotNull (provider.Find ("ProtAndInternalProperty"));
 
225
                        Assert.IsNotNull (provider.Find ("ProtAndInternalMethod"));
 
226
                        
 
227
                        Assert.IsNotNull (provider.Find ("ProtOrInternalField"));
 
228
                        Assert.IsNotNull (provider.Find ("ProtOrInternalProperty"));
 
229
                        Assert.IsNotNull (provider.Find ("ProtOrInternalMethod"));
 
230
                }
 
231
                
 
232
                [Test()]
 
233
                public void TestInternalAccessOutside ()
 
234
                {
 
235
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (testClass +
 
236
@"
 
237
} 
 
238
class Test2 {
 
239
        void TestMethod () 
 
240
        {
 
241
                TestClass tc;
 
242
                $tc.$
 
243
        }
 
244
}");
 
245
                        Assert.IsNotNull (provider, "provider == null");
 
246
                        
 
247
                        Assert.IsNotNull (provider.Find ("InternalField"), "InternalField == null");
 
248
                        Assert.IsNotNull (provider.Find ("InternalProperty"), "InternalProperty == null");
 
249
                        Assert.IsNotNull (provider.Find ("InternalMethod"), "InternalMethod == null");
 
250
                        
 
251
                        Assert.IsNotNull (provider.Find ("ProtOrInternalField"), "ProtOrInternalField == null");
 
252
                        Assert.IsNotNull (provider.Find ("ProtOrInternalProperty"), "ProtOrInternalProperty == null");
 
253
                        Assert.IsNotNull (provider.Find ("ProtOrInternalMethod"), "ProtOrInternalMethod == null");
 
254
                }
 
255
                
 
256
                [Test()]
 
257
                public void TestStaticClassAccess ()
 
258
                {
 
259
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (testClass +
 
260
@"
 
261
        void TestMethod () 
 
262
        {
 
263
                $TestClass.$
 
264
        }
 
265
}");
 
266
                        Assert.IsNotNull (provider, "provider == null");
 
267
                        
 
268
                        CodeCompletionBugTests.CheckStaticObjectMembers (provider); // 2 from System.Object
 
269
                        Assert.IsNotNull (provider.Find ("PubStaticField"));
 
270
                        Assert.IsNotNull (provider.Find ("PubStaticProperty"));
 
271
                        Assert.IsNotNull (provider.Find ("PubStaticMethod"));
 
272
                        
 
273
                        Assert.IsNotNull (provider.Find ("ProtStaticField"));
 
274
                        Assert.IsNotNull (provider.Find ("ProtStaticProperty"));
 
275
                        Assert.IsNotNull (provider.Find ("ProtStaticMethod"));
 
276
                        
 
277
                        Assert.IsNotNull (provider.Find ("PrivStaticField"));
 
278
                        Assert.IsNotNull (provider.Find ("PrivStaticProperty"));
 
279
                        Assert.IsNotNull (provider.Find ("PrivStaticMethod"));
 
280
                }
 
281
                
 
282
                [Test()]
 
283
                public void TestExternalNonStaticClassAccess ()
 
284
                {
 
285
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (testClass +
 
286
@"}
 
287
class AClass {
 
288
        void TestMethod () 
 
289
        {
 
290
                TestClass c;
 
291
                $c.$ 
 
292
        }
 
293
}");
 
294
                        Assert.IsNotNull (provider, "provider == null");
 
295
                        
 
296
                        CodeCompletionBugTests.CheckObjectMembers (provider);
 
297
                        Assert.IsNotNull (provider.Find ("PubField"));
 
298
                        Assert.IsNotNull (provider.Find ("PubProperty"));
 
299
                        Assert.IsNotNull (provider.Find ("PubMethod"));
 
300
                }
 
301
                
 
302
                [Test()]
 
303
                public void TestExternalStaticClassAccess ()
 
304
                {
 
305
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (testClass +
 
306
@"}
 
307
class AClass {
 
308
        void TestMethod () 
 
309
        {
 
310
                $TestClass.$ 
 
311
        }
 
312
}");
 
313
                        Assert.IsNotNull (provider, "provider == null");
 
314
                        
 
315
                        CodeCompletionBugTests.CheckStaticObjectMembers (provider); // 2 members
 
316
                        Assert.IsNotNull (provider.Find ("PubStaticField"));
 
317
                        Assert.IsNotNull (provider.Find ("PubStaticProperty"));
 
318
                        Assert.IsNotNull (provider.Find ("PubStaticMethod"));
 
319
                }
 
320
                
 
321
                [Test()]
 
322
                public void TestExternalNonStaticSubclassAccess ()
 
323
                {
 
324
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (testClass +
 
325
@"}
 
326
class AClass : TestClass {
 
327
        void TestMethod () 
 
328
        {
 
329
                $this.$ 
 
330
        }
 
331
}");
 
332
                        Assert.IsNotNull (provider, "provider == null");
 
333
                        
 
334
                        CodeCompletionBugTests.CheckProtectedObjectMembers (provider);
 
335
                        Assert.IsNotNull (provider.Find ("PubField"));
 
336
                        Assert.IsNotNull (provider.Find ("PubProperty"));
 
337
                        Assert.IsNotNull (provider.Find ("PubMethod"));
 
338
                        Assert.IsNotNull (provider.Find ("ProtField"));
 
339
                        Assert.IsNotNull (provider.Find ("ProtProperty"));
 
340
                        Assert.IsNotNull (provider.Find ("ProtMethod"));
 
341
                }
 
342
 
 
343
                [Test()]
 
344
                public void TestThisProtectedMemberAccess ()
 
345
                {
 
346
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
347
@"
 
348
class Test
 
349
{
 
350
        protected void Test ()
 
351
        {
 
352
        }
 
353
}
 
354
 
 
355
class Test2 : Test
 
356
{
 
357
        void Test2 ()
 
358
        {
 
359
                $this.$
 
360
        }
 
361
}");
 
362
                        Assert.IsNotNull (provider, "provider == null");
 
363
                        Assert.IsNotNull (provider.Find ("Test"), "method 'Test' not found.");
 
364
                }
 
365
 
 
366
                [Test()]
 
367
                public void TestBasePrivateMemberAccess ()
 
368
                {
 
369
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
370
testClass + @"
 
371
}
 
372
 
 
373
class Test : TestClass
 
374
{
 
375
        void Test ()
 
376
        {
 
377
                $base.$
 
378
        }
 
379
}");
 
380
                        Assert.IsNotNull (provider, "provider == null");
 
381
                        Assert.IsNull (provider.Find ("PrivField"), "field 'PrivField' found, but shouldn't.");
 
382
                        Assert.IsNull (provider.Find ("PrivProperty"), "property 'PrivProperty' found, but shouldn't.");
 
383
                        Assert.IsNull (provider.Find ("PrivMethod"), "method 'PrivMethod' found, but shouldn't.");
 
384
                        
 
385
                }
 
386
                [Test()]
 
387
                public void TestBaseProtectedMemberAccess ()
 
388
                {
 
389
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
390
@"
 
391
class Test
 
392
{
 
393
        protected void Test ()
 
394
        {
 
395
        }
 
396
}
 
397
 
 
398
class Test2 : Test
 
399
{
 
400
        void Test2 ()
 
401
        {
 
402
                $base.$
 
403
        }
 
404
}");
 
405
                        Assert.IsNotNull (provider, "provider == null");
 
406
                        Assert.IsNotNull (provider.Find ("Test"), "method 'Test' not found.");
 
407
                }
 
408
                [Test()]
 
409
                public void TestBasePublicMemberAccess ()
 
410
                {
 
411
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
412
testClass + @"
 
413
class Test : TestClass
 
414
{
 
415
        void Test ()
 
416
        {
 
417
                $base.$
 
418
        }
 
419
} }");
 
420
                        Assert.IsNotNull (provider, "provider == null");
 
421
                        CodeCompletionBugTests.CheckObjectMembers (provider);
 
422
                        Assert.IsNotNull (provider.Find ("PubField"), "field 'PubField' not found.");
 
423
                        Assert.IsNotNull (provider.Find ("PubProperty"), "property 'PubProperty' not found.");
 
424
                        Assert.IsNotNull (provider.Find ("PubMethod"), "method 'PubMethod' not found.");
 
425
                        
 
426
                }
 
427
                [Test()]
 
428
                public void TestProtectedMemberAccess2 ()
 
429
                {
 
430
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
431
@"
 
432
class Test
 
433
{
 
434
        protected void Test ()
 
435
        {
 
436
        }
 
437
}
 
438
 
 
439
class Test2
 
440
{
 
441
        void Test2 ()
 
442
        {
 
443
                $(new Test ()).$
 
444
        }
 
445
}");
 
446
                        Assert.IsNotNull (provider, "provider == null");
 
447
                        Assert.IsNull (provider.Find ("Test"), "method 'Test' found, but shouldn't.");
 
448
                }
 
449
 
 
450
                [Test()]
 
451
                public void TestGenericParameter ()
 
452
                {
 
453
                        CompletionDataList provider = CodeCompletionBugTests.CreateCtrlSpaceProvider (
 
454
@"
 
455
class Foo<T>
 
456
{
 
457
        $public $
 
458
}
 
459
");
 
460
                        Assert.IsNotNull (provider, "provider == null");
 
461
                        Assert.IsNotNull (provider.Find ("T"), "generic parameter 'T' not found");
 
462
                }
 
463
                
 
464
                [Test()]
 
465
                public void TestUnclosedMember ()
 
466
                {
 
467
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
468
@"
 
469
 
 
470
class C
 
471
{
 
472
        
 
473
        public void Hello ()
 
474
        {
 
475
                $C$
 
476
 
 
477
}
 
478
");
 
479
                        Assert.IsNotNull (provider, "provider == null");
 
480
                        Assert.IsNotNull (provider.Find ("C"), "class 'C' not found");
 
481
                }
 
482
                
 
483
                
 
484
                [Test()]
 
485
                public void TestUnclosedMember2 ()
 
486
                {
 
487
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
488
@"using System;
 
489
 
 
490
namespace ConsoleTest
 
491
{
 
492
        class MainClass
 
493
        {
 
494
                public static void Main (string[] args)
 
495
                {
 
496
                }
 
497
                
 
498
                public void Hello ()
 
499
                {
 
500
                }
 
501
        }
 
502
        
 
503
        class Foo
 
504
        {
 
505
                void Hello ()
 
506
                {
 
507
                        $M$
 
508
}
 
509
");
 
510
                        Assert.IsNotNull (provider, "provider == null");
 
511
                        Assert.IsNotNull (provider.Find ("MainClass"), "class 'MainClass' not found");
 
512
                }
 
513
                
 
514
                [Test()]
 
515
                public void TestGenericParameterB ()
 
516
                {
 
517
                        CompletionDataList provider = CodeCompletionBugTests.CreateCtrlSpaceProvider (
 
518
@"
 
519
class Foo<T>
 
520
{
 
521
        public void Bar<TValue> ()
 
522
        {
 
523
                $
 
524
        }
 
525
}
 
526
");
 
527
                        Assert.IsNotNull (provider, "provider == null");
 
528
                        Assert.IsNotNull (provider.Find ("T"), "generic parameter 'T' not found");
 
529
                        Assert.IsNotNull (provider.Find ("TValue"), "generic parameter 'TValue' found");
 
530
                }
 
531
                
 
532
                [Test()]
 
533
                public void TestGenericParameterC ()
 
534
                {
 
535
                        CompletionDataList provider = CodeCompletionBugTests.CreateCtrlSpaceProvider (
 
536
@"
 
537
class Foo<T>
 
538
{
 
539
        public static void Bar<TValue> ()
 
540
        {
 
541
                $
 
542
        }
 
543
}
 
544
");
 
545
                        Assert.IsNotNull (provider, "provider == null");
 
546
                        Assert.IsNotNull (provider.Find ("T"), "generic parameter 'T' not found");
 
547
                        Assert.IsNotNull (provider.Find ("TValue"), "generic parameter 'TValue' not found");
 
548
                }
 
549
                
 
550
                [Test()]
 
551
                public void TestInheritedInnerClasses ()
 
552
                {
 
553
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
554
@"
 
555
public class A {
 
556
        public class B {
 
557
                public void MethodB () 
 
558
                {
 
559
                }
 
560
        }
 
561
}
 
562
public class C : A 
 
563
{
 
564
        public override void MethodA (B something)
 
565
        {
 
566
                $something.$
 
567
        }
 
568
}");
 
569
                        Assert.IsNotNull (provider, "provider == null");
 
570
                        Assert.IsNotNull (provider.Find ("MethodB"), "method 'MethodB' not found");
 
571
                }
 
572
                
 
573
                [Test()]
 
574
                public void TestNamespaceAccess ()
 
575
                {
 
576
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
577
@"
 
578
namespace Foo.Bar {
 
579
        class B
 
580
        {
 
581
        }
 
582
}
 
583
 
 
584
namespace Foo {
 
585
        class Test
 
586
        {
 
587
                void TestMethod ()
 
588
                {
 
589
                        $Bar.$
 
590
                }
 
591
        }
 
592
}");
 
593
                        Assert.IsNotNull (provider, "provider == null");
 
594
                        Assert.IsNotNull (provider.Find ("B"), "class 'B' not found");
 
595
                }
 
596
                
 
597
                [Test()]
 
598
                public void TestNamespaceAccess2 ()
 
599
                {
 
600
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
601
@"
 
602
namespace Foo.Bar {
 
603
        class B
 
604
        {
 
605
        }
 
606
}
 
607
 
 
608
namespace FooBar {
 
609
        using Foo;
 
610
        class Test
 
611
        {
 
612
                void TestMethod ()
 
613
                {
 
614
                        $Bar.$
 
615
                }
 
616
        }
 
617
}");
 
618
                        // either provider == null, or B not found
 
619
                        if (provider != null)
 
620
                                Assert.IsNull (provider.Find ("B"), "class 'B' found, but shouldn't");
 
621
                }
 
622
                
 
623
                
 
624
                [Test()]
 
625
                public void TestNamespaceAccess3 ()
 
626
                {
 
627
                        CompletionDataList provider = CodeCompletionBugTests.CreateCtrlSpaceProvider (
 
628
@"
 
629
namespace SomeTest.TestNS {
 
630
        class TestClass 
 
631
        {
 
632
                
 
633
        }
 
634
}
 
635
 
 
636
namespace A {
 
637
        using SomeTest;
 
638
        
 
639
        public class Program2
 
640
        {
 
641
                public void Main () 
 
642
                {
 
643
                        $$
 
644
                }
 
645
        }
 
646
}               
 
647
");
 
648
                        Assert.IsNotNull (provider, "provider == null");
 
649
                        Assert.IsNull (provider.Find ("TestNS"), "namespace 'TestNS' found, but shouldn't");
 
650
                }
 
651
                
 
652
                [Test()]
 
653
                public void TestNamespaceAccess4 ()
 
654
                {
 
655
                        CompletionDataList provider = CodeCompletionBugTests.CreateCtrlSpaceProvider (
 
656
@"
 
657
namespace SomeTest.TestNS {
 
658
        class TestClass 
 
659
        {
 
660
                
 
661
        }
 
662
}
 
663
 
 
664
namespace SomeTest {
 
665
        
 
666
        public class Program2
 
667
        {
 
668
                public void Main () 
 
669
                {
 
670
                        $$
 
671
                }
 
672
        }
 
673
}               
 
674
");
 
675
                        Assert.IsNotNull (provider, "provider == null");
 
676
                        Assert.IsNotNull (provider.Find ("TestNS"), "namespace 'TestNS' not found");
 
677
                }
 
678
                
 
679
                [Test()]
 
680
                public void TestHideClassesWithPrivateConstructor ()
 
681
                {
 
682
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
683
@"
 
684
class A
 
685
{
 
686
}
 
687
 
 
688
class TestClass : A
 
689
{
 
690
        TestClass ()
 
691
        {
 
692
        }
 
693
        
 
694
}
 
695
 
 
696
class Example
 
697
{
 
698
        void TestMe ()
 
699
        {
 
700
                $A a = new $
 
701
        }
 
702
}               
 
703
");
 
704
                        Assert.IsNotNull (provider, "provider == null");
 
705
                        Assert.IsNotNull (provider.Find ("A"), "class 'A' not found");
 
706
                        Assert.IsNull (provider.Find ("TestClass"), "class 'TestClass' found, but shouldn't.");
 
707
                }
 
708
                
 
709
                [Test()]
 
710
                public void TestAttributePropertyAccess ()
 
711
                {
 
712
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
713
@"
 
714
public class TestAttribute : System.Attribute
 
715
{
 
716
        public int MyIntProperty {
 
717
                get;
 
718
                set;
 
719
        }
 
720
        
 
721
        public string MyStringProperty {
 
722
                get;
 
723
                set;
 
724
        }
 
725
}
 
726
 
 
727
[Test($M$)]
 
728
public class Program
 
729
{
 
730
        
 
731
}       
 
732
");
 
733
                        Assert.IsNotNull (provider, "provider == null");
 
734
                        Assert.IsNotNull (provider.Find ("MyIntProperty"), "property 'MyIntProperty' not found");
 
735
                        Assert.IsNotNull (provider.Find ("MyStringProperty"), "property 'MyStringProperty' not found");
 
736
                }
 
737
                
 
738
                [Test()]
 
739
                public void TestInnerClassEnumAccess ()
 
740
                {
 
741
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
742
@"
 
743
public class TestInnerEnum
 
744
{
 
745
        enum InnerEnum { A, B, C }
 
746
 
 
747
        public class InnerClass
 
748
        {
 
749
                void TestMethod (InnerEnum e)
 
750
                {
 
751
                        $e = InnerEnum.$
 
752
                }
 
753
        }
 
754
}");
 
755
                        Assert.IsNotNull (provider, "provider == null");
 
756
                        Assert.IsNotNull (provider.Find ("A"), "field 'A' not found");
 
757
                        Assert.IsNotNull (provider.Find ("B"), "field 'B' not found");
 
758
                        Assert.IsNotNull (provider.Find ("C"), "field 'C' not found");
 
759
                }
 
760
                
 
761
                [Test()]
 
762
                public void TestInnerClassPrivateOuterMembersAccess ()
 
763
                {
 
764
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
765
@"
 
766
public class TestClass
 
767
{
 
768
        void TestMethod ()
 
769
        {
 
770
        }
 
771
        
 
772
        public class InnerClass
 
773
        {
 
774
                void TestMethod ()
 
775
                {
 
776
                        TestClass tc = new TestClass ();
 
777
                        $tc.$
 
778
                }
 
779
        }
 
780
}");
 
781
                        Assert.IsNotNull (provider, "provider == null");
 
782
                        Assert.IsNotNull (provider.Find ("TestMethod"), "method 'TestMethod' not found");
 
783
                }
 
784
                
 
785
                [Test()]
 
786
                public void TestExplicitGenericMethodParameter ()
 
787
                {
 
788
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
789
@"
 
790
public class TestClass
 
791
{
 
792
        public static T TestMethod<T> ()
 
793
        {
 
794
                return default(T);
 
795
        }
 
796
}
 
797
 
 
798
public class Test
 
799
{
 
800
        public void TestMethod ()
 
801
        {
 
802
                $TestClass.TestMethod<Test> ().$
 
803
        }
 
804
}
 
805
");
 
806
                        Assert.IsNotNull (provider, "provider == null");
 
807
                        Assert.IsNotNull (provider.Find ("TestMethod"), "method 'TestMethod' not found");
 
808
                }
 
809
 
 
810
                [Test()]
 
811
                public void TestImplicitGenericMethodParameter ()
 
812
                {
 
813
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
814
@"
 
815
public class TestClass
 
816
{
 
817
        public static T TestMethod<T> (T t)
 
818
        {
 
819
                return t;
 
820
        }
 
821
}
 
822
 
 
823
public class Test
 
824
{
 
825
        public void TestMethod ()
 
826
        {
 
827
                $TestClass.TestMethod (this).$
 
828
        }
 
829
}
 
830
 ");
 
831
                        Assert.IsNotNull (provider, "provider == null");
 
832
                        Assert.IsNotNull (provider.Find ("TestMethod"), "method 'TestMethod' not found");
 
833
                }
 
834
                
 
835
                [Test()]
 
836
                public void TestImplicitGenericMethodParameterComplex ()
 
837
                {
 
838
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
839
@"
 
840
using System;
 
841
 
 
842
class SomeTemplate<T>
 
843
{
 
844
        public T Val { get; set; }
 
845
        public SomeTemplate (T val)
 
846
        {
 
847
                this.Val = val;
 
848
        }
 
849
}
 
850
 
 
851
class Test
 
852
{
 
853
        public T GetVal<T> (SomeTemplate<T> t)
 
854
        {
 
855
                return t.Val;
 
856
        }
 
857
        
 
858
        public void TestMethod ()
 
859
        {
 
860
                SomeTemplate<Test> c = SomeTemplate<Test> (this);
 
861
                var x = GetVal (c);
 
862
                $x.$
 
863
                
 
864
        }
 
865
}");
 
866
                        Assert.IsNotNull (provider, "provider == null");
 
867
                        Assert.IsNotNull (provider.Find ("TestMethod"), "method 'TestMethod' not found");
 
868
                }
 
869
 
 
870
                [Test()]
 
871
                public void TestImplicitGenericArrayMethodParameter ()
 
872
                {
 
873
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
874
@"
 
875
public class TestClass
 
876
{
 
877
        public static T[] Test<T> ()
 
878
        {
 
879
                return default(T[]);
 
880
        }
 
881
}
 
882
 
 
883
public class Test
 
884
{
 
885
        public void TestMethod ()
 
886
        {
 
887
                var v = TestClass.Test<Test>();
 
888
                $v[0].$
 
889
        }
 
890
}
 
891
");
 
892
                        Assert.IsNotNull (provider, "provider == null");
 
893
                        Assert.IsNotNull (provider.Find ("TestMethod"), "method 'TestMethod' not found");
 
894
                }
 
895
                
 
896
                [Test()]
 
897
                public void TestExplicitResolving ()
 
898
                {
 
899
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
900
@"
 
901
interface IMyInterface {
 
902
        object this [object i] { get; }
 
903
}
 
904
 
 
905
class MyClass<S, T> : IMyInterface
 
906
{
 
907
        object IMyInterface.this[object i] {
 
908
                get {
 
909
                        return null;
 
910
                }
 
911
        }
 
912
        
 
913
        public S this[T i] {
 
914
                get {
 
915
                        return default(S);
 
916
                }
 
917
        }
 
918
}
 
919
        
 
920
class TestClass
 
921
{
 
922
        void TestMethod ()
 
923
        {
 
924
                MyClass<TestClass, string> myClass = new MyClass<TestClass, string> ();
 
925
                $myClass[""test""].$
 
926
        }
 
927
}
 
928
");
 
929
                        Assert.IsNotNull (provider, "provider == null");
 
930
                        Assert.IsNotNull (provider.Find ("TestMethod"), "method 'TestMethod' not found");
 
931
                }
 
932
                
 
933
                [Test()]
 
934
                public void TestAlias ()
 
935
                        
 
936
                {
 
937
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
938
@"
 
939
namespace A
 
940
{
 
941
        public class MyClass 
 
942
        {
 
943
                public void MyMethod ()
 
944
                {
 
945
                }
 
946
        }
 
947
}
 
948
 
 
949
namespace X
 
950
{
 
951
        using GG = A.MyClass;
 
952
        
 
953
        public abstract class I
 
954
        {
 
955
                protected virtual GG Foo ()
 
956
                {
 
957
                        return null;
 
958
                }
 
959
        }
 
960
}
 
961
 
 
962
namespace X
 
963
{
 
964
        public class B : I
 
965
        {
 
966
                public void A ()
 
967
                {
 
968
                        $Foo ().$
 
969
                }
 
970
        }
 
971
}");
 
972
                        Assert.IsNotNull (provider, "provider == null");
 
973
                        Assert.IsNotNull (provider.Find ("MyMethod"), "method 'MyMethod' not found");                   
 
974
                }
 
975
 
 
976
                [Test()]
 
977
                public void TestEnumInnerClass ()
 
978
                {
 
979
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
980
@"
 
981
using System;
 
982
namespace CaptainHook.Mail
 
983
{
 
984
        public class TestClass
 
985
        {
 
986
                enum ParsingState
 
987
                {
 
988
                        Any,
 
989
                        Start,
 
990
                        InMacro,
 
991
                        InMacroArgumentList,
 
992
                        InQuotedMacroArgument,
 
993
                        PlainText
 
994
                }
 
995
 
 
996
                ParsingState state;
 
997
 
 
998
                public TestClass ()
 
999
                {
 
1000
                        $state = $
 
1001
                }
 
1002
        }
 
1003
}");
 
1004
                        Assert.IsNotNull (provider, "provider == null");
 
1005
                        Assert.IsNull (provider.Find ("CaptainHook.Mail.TestClass.ParsingState"), "class 'CaptainHook.Mail.TestClass.ParsingState' found!");
 
1006
                        Assert.IsNull (provider.Find ("TestClass.ParsingState"), "class 'TestClass.ParsingState' found!");
 
1007
                        Assert.IsNotNull (provider.Find ("ParsingState"), "class 'ParsingState' not found");
 
1008
                }
 
1009
                
 
1010
                [Test()]
 
1011
                public void TestInheritableTypeContext ()
 
1012
                {
 
1013
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
1014
@"
 
1015
class Test
 
1016
{
 
1017
        public class Inner {}
 
1018
        public static void Foo () {}
 
1019
}
 
1020
 
 
1021
$class Test2 : Test.$
 
1022
");
 
1023
                        Assert.IsNotNull (provider, "provider == null");
 
1024
                        Assert.IsNotNull (provider.Find ("Inner"), "class 'Inner' not found.");
 
1025
                        Assert.IsNull (provider.Find ("Foo"), "method 'Foo' found.");
 
1026
                }
 
1027
                
 
1028
                [Test()]
 
1029
                public void TestInheritableTypeContextCase2 ()
 
1030
                {
 
1031
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
1032
@"
 
1033
namespace A {
 
1034
        class Test
 
1035
        {
 
1036
                public class Inner {}
 
1037
                public static void Foo () {}
 
1038
        }
 
1039
        
 
1040
        class Test2 $: Test.$
 
1041
        {
 
1042
        }
 
1043
}
 
1044
");
 
1045
                        Assert.IsNotNull (provider, "provider == null");
 
1046
                        Assert.IsNotNull (provider.Find ("Inner"), "class 'Inner' not found.");
 
1047
                        Assert.IsNull (provider.Find ("Foo"), "method 'Foo' found.");
 
1048
                }
 
1049
                
 
1050
                
 
1051
                [Test()]
 
1052
                public void TestInheritableTypeWhereContext ()
 
1053
                {
 
1054
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
1055
@"
 
1056
class Test
 
1057
{
 
1058
        public class Inner {}
 
1059
        public static void Foo () {}
 
1060
}
 
1061
 
 
1062
$class Test2<T> where T : Test.$
 
1063
");
 
1064
                        Assert.IsNotNull (provider, "provider == null");
 
1065
                        Assert.IsNotNull (provider.Find ("Inner"), "class 'Inner' not found.");
 
1066
                        Assert.IsNull (provider.Find ("Foo"), "method 'Foo' found.");
 
1067
                }
 
1068
                
 
1069
                [Test()]
 
1070
                public void TestEnumAssignment ()
 
1071
                {
 
1072
                        CompletionDataList provider = CodeCompletionBugTests.CreateCtrlSpaceProvider (
 
1073
@"
 
1074
public enum TestEnum { A, B, C}
 
1075
 
 
1076
class TestClass
 
1077
{
 
1078
        public void Foo ()
 
1079
        {
 
1080
                $TestEnum test = $
 
1081
        }
 
1082
}");
 
1083
                        Assert.IsNotNull (provider, "provider not found.");
 
1084
                        Assert.IsNotNull (provider.Find ("TestEnum"), "enum 'TestEnum' not found.");
 
1085
                        Assert.IsNotNull (provider.Find ("TestEnum.A"), "enum 'TestEnum.A' not found.");
 
1086
                        Assert.IsNotNull (provider.Find ("TestEnum.B"), "enum 'TestEnum.B' not found.");
 
1087
                        Assert.IsNotNull (provider.Find ("TestEnum.C"), "enum 'TestEnum.C' not found.");
 
1088
                }
 
1089
                
 
1090
                [Test()]
 
1091
                public void TestEnumAssignmentCase2 ()
 
1092
                {
 
1093
                        CompletionDataList provider = CodeCompletionBugTests.CreateCtrlSpaceProvider (
 
1094
@"
 
1095
public enum TestEnum { A, B, C}
 
1096
 
 
1097
class TestClass
 
1098
{
 
1099
        public void Foo ()
 
1100
        {
 
1101
                TestEnum test;
 
1102
                $test = $
 
1103
        }
 
1104
}");
 
1105
                        Assert.IsNotNull (provider, "provider not found.");
 
1106
                        Assert.IsNotNull (provider.Find ("TestEnum"), "enum 'TestEnum' not found.");
 
1107
                        Assert.IsNotNull (provider.Find ("TestEnum.A"), "enum 'TestEnum.A' not found.");
 
1108
                        Assert.IsNotNull (provider.Find ("TestEnum.B"), "enum 'TestEnum.B' not found.");
 
1109
                        Assert.IsNotNull (provider.Find ("TestEnum.C"), "enum 'TestEnum.C' not found.");
 
1110
                }
 
1111
                
 
1112
                [Test()]
 
1113
                public void TestEnumAsParameter ()
 
1114
                {
 
1115
                        CompletionDataList provider = CodeCompletionBugTests.CreateCtrlSpaceProvider (
 
1116
@"
 
1117
public enum TestEnum { A, B, C}
 
1118
 
 
1119
class TestClass
 
1120
{
 
1121
        void Bar (TestEnum test) {}
 
1122
        public void Foo ()
 
1123
        {
 
1124
                $Bar ($
 
1125
        }
 
1126
}");
 
1127
                        Assert.IsNotNull (provider, "provider not found.");
 
1128
                        Assert.IsNotNull (provider.Find ("TestEnum"), "enum 'TestEnum' not found.");
 
1129
                        Assert.IsNotNull (provider.Find ("TestEnum.A"), "enum 'TestEnum.A' not found.");
 
1130
                        Assert.IsNotNull (provider.Find ("TestEnum.B"), "enum 'TestEnum.B' not found.");
 
1131
                        Assert.IsNotNull (provider.Find ("TestEnum.C"), "enum 'TestEnum.C' not found.");
 
1132
                }
 
1133
        
 
1134
                [Test]
 
1135
                public void TestEnumInExtensionMethod()
 
1136
                {
 
1137
                        var provider = CodeCompletionBugTests.CreateCtrlSpaceProvider(@"
 
1138
public enum TestEnum { A, B, C}
 
1139
static class Ext { public static void Foo(this object o, TestEnum str) {} }
 
1140
class Test
 
1141
{
 
1142
        public static void Main (string[] args)
 
1143
        {
 
1144
                $args.Foo($
 
1145
        }
 
1146
}");
 
1147
                        Assert.IsNotNull (provider.Find ("TestEnum"), "enum 'TestEnum' not found.");
 
1148
                        Assert.IsNotNull (provider.Find ("TestEnum.A"), "enum 'TestEnum.A' not found.");
 
1149
                        Assert.IsNotNull (provider.Find ("TestEnum.B"), "enum 'TestEnum.B' not found.");
 
1150
                        Assert.IsNotNull (provider.Find ("TestEnum.C"), "enum 'TestEnum.C' not found.");
 
1151
                }
 
1152
                
 
1153
                
 
1154
                [Test]
 
1155
                public void TestEnumInExtensionMethodStaticInvocation()
 
1156
                {
 
1157
                        var provider = CodeCompletionBugTests.CreateCtrlSpaceProvider(@"
 
1158
public enum TestEnum { A, B, C}
 
1159
static class Ext { public static void Foo(this object o, TestEnum str) {} }
 
1160
class Test
 
1161
{
 
1162
        public static void Main (string[] args)
 
1163
        {
 
1164
                $Ext.Foo(args, $
 
1165
        }
 
1166
}");
 
1167
                        Assert.IsNotNull (provider.Find ("TestEnum"), "enum 'TestEnum' not found.");
 
1168
                        Assert.IsNotNull (provider.Find ("TestEnum.A"), "enum 'TestEnum.A' not found.");
 
1169
                        Assert.IsNotNull (provider.Find ("TestEnum.B"), "enum 'TestEnum.B' not found.");
 
1170
                        Assert.IsNotNull (provider.Find ("TestEnum.C"), "enum 'TestEnum.C' not found.");
 
1171
                }
 
1172
 
 
1173
 
 
1174
                [Test()]
 
1175
                public void TestEnumAsParameterCase2 ()
 
1176
                {
 
1177
                        CompletionDataList provider = CodeCompletionBugTests.CreateCtrlSpaceProvider (
 
1178
@"
 
1179
public enum TestEnum { A, B, C}
 
1180
 
 
1181
class TestClass
 
1182
{
 
1183
        void Bar (int a, TestEnum test) {}
 
1184
        public void Foo ()
 
1185
        {
 
1186
                $Bar (5, $
 
1187
        }
 
1188
}");
 
1189
                        Assert.IsNotNull (provider, "provider not found.");
 
1190
                        Assert.IsNotNull (provider.Find ("TestEnum"), "enum 'TestEnum' not found.");
 
1191
                        Assert.IsNotNull (provider.Find ("TestEnum.A"), "enum 'TestEnum.A' not found.");
 
1192
                        Assert.IsNotNull (provider.Find ("TestEnum.B"), "enum 'TestEnum.B' not found.");
 
1193
                        Assert.IsNotNull (provider.Find ("TestEnum.C"), "enum 'TestEnum.C' not found.");
 
1194
                }
 
1195
                
 
1196
                [Test()]
 
1197
                public void TestInnerEnums ()
 
1198
                {
 
1199
                        CompletionDataList provider = CodeCompletionBugTests.CreateCtrlSpaceProvider (
 
1200
@"
 
1201
public class InnerEnumTest
 
1202
{
 
1203
        public enum TestEnum { A, B, C}
 
1204
        public void Bar (TestEnum test) {}
 
1205
}
 
1206
 
 
1207
class TestClass
 
1208
{
 
1209
        public void Foo ()
 
1210
        {
 
1211
                InnerEnumTest test;
 
1212
                $test.Bar ($
 
1213
        }
 
1214
}");
 
1215
                        Assert.IsNotNull (provider, "provider not found.");
 
1216
                        Assert.IsNotNull (provider.Find ("InnerEnumTest.TestEnum"), "enum 'InnerEnumTest.TestEnum' not found.");
 
1217
                        Assert.IsNotNull (provider.Find ("InnerEnumTest.TestEnum.A"), "enum 'InnerEnumTest.TestEnum.A' not found.");
 
1218
                        Assert.IsNotNull (provider.Find ("InnerEnumTest.TestEnum.B"), "enum 'InnerEnumTest.TestEnum.B' not found.");
 
1219
                        Assert.IsNotNull (provider.Find ("InnerEnumTest.TestEnum.C"), "enum 'InnerEnumTest.TestEnum.C' not found.");
 
1220
                }
 
1221
 
 
1222
                [Test()]
 
1223
                public void TestEnumInBinaryOperatorExpression ()
 
1224
                {
 
1225
                        CodeCompletionBugTests.CombinedProviderTest (
 
1226
                                @"
 
1227
[Flags]
 
1228
public enum TestEnum { A, B, C}
 
1229
 
 
1230
class TestClass
 
1231
{
 
1232
public void Foo ()
 
1233
{
 
1234
$TestEnum test = TestEnum.A | T$
 
1235
}
 
1236
}", provider => {
 
1237
                                Assert.IsNotNull (provider.Find ("TestEnum"), "enum 'TestEnum' not found.");
 
1238
                                Assert.IsNotNull (provider.Find ("TestEnum.A"), "enum 'TestEnum.A' not found.");
 
1239
                                Assert.IsNotNull (provider.Find ("TestEnum.B"), "enum 'TestEnum.B' not found.");
 
1240
                                Assert.IsNotNull (provider.Find ("TestEnum.C"), "enum 'TestEnum.C' not found.");
 
1241
                        });
 
1242
                }
 
1243
                
 
1244
                [Test()]
 
1245
                public void TestEnumComparison ()
 
1246
                {
 
1247
                        var provider = CodeCompletionBugTests.CreateProvider(
 
1248
                                @"
 
1249
public enum TestEnum { A, B, C}
 
1250
 
 
1251
class TestClass
 
1252
{
 
1253
        public static TestEnum A (int i, int j, string s) {}
 
1254
 
 
1255
        public void Foo ()
 
1256
        {
 
1257
                $if (A(1,2,""foo"") == $
 
1258
        }
 
1259
}");
 
1260
                        Assert.IsFalse(provider.AutoCompleteEmptyMatch);
 
1261
                        Assert.IsNotNull (provider.Find ("TestEnum"), "enum 'TestEnum' not found.");
 
1262
                        Assert.IsNotNull (provider.Find ("TestEnum.A"), "enum 'TestEnum.A' not found.");
 
1263
                        Assert.IsNotNull (provider.Find ("TestEnum.B"), "enum 'TestEnum.B' not found.");
 
1264
                        Assert.IsNotNull (provider.Find ("TestEnum.C"), "enum 'TestEnum.C' not found.");
 
1265
                }
 
1266
 
 
1267
                
 
1268
                [Test()]
 
1269
                public void TestEnumComparisonCase2 ()
 
1270
                {
 
1271
                        var provider = CodeCompletionBugTests.CreateProvider(
 
1272
                                @"
 
1273
public enum TestEnum { A, B, C}
 
1274
 
 
1275
class TestClass
 
1276
{
 
1277
        public static TestEnum A (int i, int j, string s) {}
 
1278
 
 
1279
        public void Foo ()
 
1280
        {
 
1281
                $if (A(1,2,""foo"") != $
 
1282
        }
 
1283
}");
 
1284
                        Assert.IsFalse(provider.AutoCompleteEmptyMatch);
 
1285
                        Assert.IsNotNull (provider.Find ("TestEnum"), "enum 'TestEnum' not found.");
 
1286
                        Assert.IsNotNull (provider.Find ("TestEnum.A"), "enum 'TestEnum.A' not found.");
 
1287
                        Assert.IsNotNull (provider.Find ("TestEnum.B"), "enum 'TestEnum.B' not found.");
 
1288
                        Assert.IsNotNull (provider.Find ("TestEnum.C"), "enum 'TestEnum.C' not found.");
 
1289
                }
 
1290
 
 
1291
                [Test()]
 
1292
                public void TestPrimimitiveTypeCompletionString ()
 
1293
                {
 
1294
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
 
1295
@"using System;
 
1296
 
 
1297
class Test
 
1298
{
 
1299
        public static void Foo () 
 
1300
        {
 
1301
                Console.WriteLine ($"""".$);
 
1302
        }
 
1303
}
 
1304
");
 
1305
                        Assert.IsNotNull (provider, "provider == null");
 
1306
                        Assert.IsNotNull (provider.Find ("ToString"), "method 'ToString' not found.");
 
1307
                }
 
1308
                
 
1309
                
 
1310
                [Test()]
 
1311
                public void TestUsingContext ()
 
1312
                {
 
1313
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (@"$using System.$");
 
1314
                        Assert.IsNotNull (provider, "provider == null");
 
1315
                        Assert.IsNotNull (provider.Find ("IO"), "namespace 'IO' not found.");
 
1316
                }
 
1317
                
 
1318
                [Test()]
 
1319
                public void TestNamedArgumentContext1 ()
 
1320
                {
 
1321
                        CompletionDataList provider = CodeCompletionBugTests.CreateProvider (@"
 
1322
using System;
 
1323
 
 
1324
class Test {
 
1325
public static void Query(MySqlConnection conn, string database, string table)
 
1326
                {
 
1327
                        conn.Query(string.Format(""SELECT * FROM {0}"", table))
 
1328
                        .On(row: delegate (Row data) {
 
1329
                                $Console.$
 
1330
                        });
 
1331
                }
 
1332
}");
 
1333
                        Assert.IsNotNull (provider, "provider == null");
 
1334
                        Assert.IsNotNull (provider.Find ("WriteLine"), "method 'WriteLine' not found.");
 
1335
                }
 
1336
                [Test()]
 
1337
                public void TestAttributeContextClass ()
 
1338
                {
 
1339
                        var provider = CodeCompletionBugTests.CreateProvider (@"
 
1340
using System;
 
1341
 
 
1342
$[O$
 
1343
class Test {
 
1344
}");
 
1345
                        Assert.IsNotNull (provider, "provider == null");
 
1346
                        Assert.IsNotNull (provider.Find ("Obsolete"), "attribute 'Obsolete' not found.");
 
1347
                        Assert.IsNotNull (provider.Find ("Serializable"), "attribute 'Serializable' not found.");
 
1348
                }
 
1349
                
 
1350
                [Test()]
 
1351
                public void TestAttributeContextInNamespace ()
 
1352
                {
 
1353
                        var provider = CodeCompletionBugTests.CreateProvider (@"
 
1354
using System;
 
1355
 
 
1356
namespace Test {
 
1357
        $[O$
 
1358
        class Test {
 
1359
        }
 
1360
}
 
1361
");
 
1362
                        Assert.IsNotNull (provider, "provider == null");
 
1363
                        Assert.IsNotNull (provider.Find ("Obsolete"), "attribute 'Obsolete' not found.");
 
1364
                        Assert.IsNotNull (provider.Find ("Serializable"), "attribute 'Serializable' not found.");
 
1365
                }
 
1366
                
 
1367
                [Test()]
 
1368
                public void TestAttributeContextMember ()
 
1369
                {
 
1370
                        var provider = CodeCompletionBugTests.CreateProvider (@"
 
1371
using System;
 
1372
 
 
1373
class Test {
 
1374
        $[O$
 
1375
}");
 
1376
                        Assert.IsNotNull (provider, "provider == null");
 
1377
                        Assert.IsNotNull (provider.Find ("Obsolete"), "attribute 'Obsolete' not found.");
 
1378
                        Assert.IsNotNull (provider.Find ("Serializable"), "attribute 'Serializable' not found.");
 
1379
                }
 
1380
                
 
1381
                [Test()]
 
1382
                public void TestAttributeInNonAttributeContext ()
 
1383
                {
 
1384
                        var provider = CodeCompletionBugTests.CreateCtrlSpaceProvider (@"
 
1385
using System;
 
1386
 
 
1387
class Test {
 
1388
$$
 
1389
}");
 
1390
                        Assert.IsNotNull (provider, "provider == null");
 
1391
                        Assert.IsNotNull (provider.Find ("ObsoleteAttribute"), "attribute 'ObsoleteAttribute' not found.");
 
1392
                }
 
1393
                
 
1394
                // 'from' in comment activates linq context
 
1395
                [Test()]
 
1396
                public void TestBreakingComment ()
 
1397
                {
 
1398
                        var provider = CodeCompletionBugTests.CreateCtrlSpaceProvider (@"
 
1399
using System;
 
1400
// from
 
1401
class Test {
 
1402
$$
 
1403
}");
 
1404
                        Assert.IsNotNull (provider, "provider == null");
 
1405
                        Assert.IsNotNull (provider.Find ("Test"), "class 'Test' not found.");
 
1406
                }
 
1407
                
 
1408
                [Test()]
 
1409
                public void TestAttributeContextParameterCompletion ()
 
1410
                {
 
1411
                        var provider = CodeCompletionBugTests.CreateProvider (@"$[Obsolete(System.$");
 
1412
                        Assert.IsNotNull (provider, "provider == null");
 
1413
                        Assert.IsNotNull (provider.Find ("Console"), "'Console' not found.");
 
1414
                }
 
1415
                
 
1416
                
 
1417
                /// <summary>
 
1418
                /// Bug 3320 - Constants accessed by class name do not show in completion list
 
1419
                /// </summary>
 
1420
                [Test()]
 
1421
                public void TestBug3320 ()
 
1422
                {
 
1423
                        CodeCompletionBugTests.CombinedProviderTest (@"
 
1424
public class Foo
 
1425
{
 
1426
    public const int Bar = 5;
 
1427
 
 
1428
    public void DoStuff()
 
1429
    {
 
1430
        $Foo.$
 
1431
    } 
 
1432
}", provider => {
 
1433
                                Assert.IsNotNull (provider.Find ("Bar"), "'Bar' not found.");
 
1434
                        });
 
1435
                }
 
1436
 
 
1437
                [Test()]
 
1438
                public void TestImplicitShadowing ()
 
1439
                {
 
1440
                        CodeCompletionBugTests.CombinedProviderTest (@"
 
1441
using System;
 
1442
 
 
1443
                namespace ConsoleApplication2
 
1444
                {
 
1445
                        class A
 
1446
                        {
 
1447
                                public int Foo;
 
1448
                        }
 
1449
 
 
1450
                        class B : A
 
1451
                        {
 
1452
                                public string Foo;
 
1453
                        }
 
1454
 
 
1455
                        class Program
 
1456
                        {
 
1457
                                static void Main (string[] args)
 
1458
                                {
 
1459
                                        var b = new B ();
 
1460
                                        $b.$
 
1461
                                }
 
1462
                        }
 
1463
                }", provider => {
 
1464
                                int count = 0;
 
1465
                                foreach (var data in provider.Data) 
 
1466
                                        if (data.DisplayText == "Foo")
 
1467
                                                count += data.HasOverloads ? data.OverloadedData.Count () : 1;
 
1468
                                Assert.AreEqual (1, count);
 
1469
                        });
 
1470
                }
 
1471
 
 
1472
                [Test()]
 
1473
                public void TestOverrideFiltering ()
 
1474
                {
 
1475
                        CodeCompletionBugTests.CombinedProviderTest (@"
 
1476
using System;
 
1477
 
 
1478
namespace ConsoleApplication2
 
1479
{
 
1480
    class A
 
1481
    {
 
1482
        public virtual int Foo { set {} }
 
1483
    }
 
1484
 
 
1485
    class B : A
 
1486
    {
 
1487
        public override int Foo {
 
1488
            set {
 
1489
                base.Foo = value;
 
1490
            }
 
1491
        }
 
1492
    }
 
1493
 
 
1494
    class Program
 
1495
    {
 
1496
        static void Main (string[] args)
 
1497
        {
 
1498
            var b = new B ();
 
1499
            $b.$
 
1500
        }
 
1501
    }
 
1502
}
 
1503
", provider => {
 
1504
                                int count = 0;
 
1505
                                foreach (var data in provider.Data) 
 
1506
                                        if (data.DisplayText == "Foo")
 
1507
                                                count += data.HasOverloads ? data.OverloadedData.Count () : 1;
 
1508
                                Assert.AreEqual (1, count);
 
1509
                        });
 
1510
                }
 
1511
 
 
1512
 
 
1513
                /// <summary>
 
1514
                /// Bug 5648 - Types are displayed even when cannot be used 
 
1515
                /// </summary>
 
1516
                [Test()]
 
1517
                public void TestBug5648 ()
 
1518
                {
 
1519
                        CodeCompletionBugTests.CombinedProviderTest (@"
 
1520
using System;
 
1521
 
 
1522
namespace N
 
1523
{
 
1524
        $e$
 
1525
}
 
1526
", provider => {
 
1527
                                Assert.IsNotNull (provider.Find ("enum"), "'enum' not found.");
 
1528
                                Assert.IsNotNull (provider.Find ("namespace"), "'namespace' not found.");
 
1529
                                Assert.IsNotNull (provider.Find ("public"), "'public' not found.");
 
1530
                                Assert.IsNull (provider.Find ("CharEnumerator"), "'CharEnumerator' found.");
 
1531
                                Assert.IsNull (provider.Find ("Console"), "'Console' found.");
 
1532
                        });
 
1533
                }
 
1534
 
 
1535
                [Test()]
 
1536
                public void CheckInstanceMembersAreHiddenInStaticMethod ()
 
1537
                {
 
1538
                        CodeCompletionBugTests.CombinedProviderTest (@"
 
1539
using System;
 
1540
 
 
1541
class Test
 
1542
{
 
1543
        int foo;
 
1544
        int Foo { get { return foo; } }
 
1545
        void TestMethod () {}
 
1546
 
 
1547
        public static void Main (string[] args)
 
1548
        {
 
1549
                $f$     
 
1550
        }
 
1551
}
 
1552
", provider => {
 
1553
                                Assert.IsNotNull (provider.Find ("Main"), "'Main' not found.");
 
1554
                                Assert.IsNotNull (provider.Find ("Test"), "'Test' not found.");
 
1555
                                Assert.IsNull (provider.Find ("foo"), "'foo' found.");
 
1556
                                Assert.IsNull (provider.Find ("Foo"), "'Foo' found.");
 
1557
                                Assert.IsNull (provider.Find ("TestMethod"), "'TestMethod' found.");
 
1558
                        });
 
1559
                }
 
1560
                
 
1561
                [Test]
 
1562
                public void TestVariableHiding ()
 
1563
                {
 
1564
                        CodeCompletionBugTests.CombinedProviderTest (@"
 
1565
using System;
 
1566
 
 
1567
class Test
 
1568
{
 
1569
        static string test;
 
1570
 
 
1571
        public static void Main (int test)
 
1572
        {
 
1573
                $f$     
 
1574
        }
 
1575
}
 
1576
", provider => {
 
1577
                                Assert.AreEqual (1, provider.Data.Count (p => p.DisplayText == "test"));
 
1578
                        });
 
1579
                }
 
1580
 
 
1581
                [Test]
 
1582
                public void TestOverloadCount ()
 
1583
                {
 
1584
                        CodeCompletionBugTests.CombinedProviderTest (@"
 
1585
using System;
 
1586
 
 
1587
class Test
 
1588
{
 
1589
        static void Foo () {}
 
1590
        static void Foo (int i) {}
 
1591
        static void Foo (int i, string s) {}
 
1592
 
 
1593
        public static void Main (int test)
 
1594
        {
 
1595
                $f$     
 
1596
        }
 
1597
}
 
1598
", provider => {
 
1599
                                Assert.AreEqual (1, provider.Data.Count (p => p.DisplayText == "Foo"));
 
1600
                                var data = provider.Find ("Foo");
 
1601
                                Assert.AreEqual (3, data.OverloadedData.Count ());
 
1602
 
 
1603
                        });
 
1604
                }
 
1605
        }
 
1606
}
 
 
b'\\ No newline at end of file'