← 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/Resolver/ObjectCreationTests.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/Resolver/ObjectCreationTests.cs
 
1
ļ»æ// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team
 
2
// 
 
3
// Permission is hereby granted, free of charge, to any person obtaining a copy of this
 
4
// software and associated documentation files (the "Software"), to deal in the Software
 
5
// without restriction, including without limitation the rights to use, copy, modify, merge,
 
6
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
 
7
// to whom the Software is furnished to do so, subject to the following conditions:
 
8
// 
 
9
// The above copyright notice and this permission notice shall be included in all copies or
 
10
// substantial portions of the Software.
 
11
// 
 
12
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 
13
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 
14
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
 
15
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 
16
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 
17
// DEALINGS IN THE SOFTWARE.
 
18
 
 
19
using System;
 
20
using System.Collections.Generic;
 
21
using ICSharpCode.NRefactory.Semantics;
 
22
using ICSharpCode.NRefactory.TypeSystem;
 
23
using NUnit.Framework;
 
24
 
 
25
namespace ICSharpCode.NRefactory.CSharp.Resolver
 
26
{
 
27
        [TestFixture]
 
28
        public class ObjectCreationTests : ResolverTestBase
 
29
        {
 
30
                [Test]
 
31
                public void GenericObjectCreation()
 
32
                {
 
33
                        string program = @"using System.Collections.Generic;
 
34
class A {
 
35
        static void Main() {
 
36
                var a = $new List<string>()$;
 
37
        }
 
38
}
 
39
";
 
40
                        var result = Resolve<CSharpInvocationResolveResult>(program);
 
41
                        Assert.AreEqual("System.Collections.Generic.List..ctor", result.Member.FullName);
 
42
                        
 
43
                        Assert.AreEqual("System.Collections.Generic.List`1[[System.String]]", result.Type.ReflectionName);
 
44
                }
 
45
                
 
46
                [Test]
 
47
                public void NonExistingClass ()
 
48
                {
 
49
                        string program = @"class A {
 
50
        void Method() {
 
51
                var a = $new ThisClassDoesNotExist()$;
 
52
        }
 
53
}
 
54
";
 
55
                        ResolveResult result = Resolve (program);
 
56
                        Assert.IsTrue (result.IsError);
 
57
                        Assert.AreSame(SpecialType.UnknownType, result.Type);
 
58
                }
 
59
                
 
60
                [Test]
 
61
                public void NonExistingClassTypeName()
 
62
                {
 
63
                        string program = @"class A {
 
64
        void Method() {
 
65
                var a = new $ThisClassDoesNotExist$();
 
66
        }
 
67
}
 
68
";
 
69
                        UnknownIdentifierResolveResult result = Resolve<UnknownIdentifierResolveResult>(program);
 
70
                        Assert.AreEqual("ThisClassDoesNotExist", result.Identifier);
 
71
                        Assert.AreSame(SpecialType.UnknownType, result.Type);
 
72
                }
 
73
                
 
74
                [Test]
 
75
                public void CTorOverloadLookupTest()
 
76
                {
 
77
                        string program = @"class A {
 
78
        void Method() {
 
79
                $;
 
80
        }
 
81
        
 
82
        static A() {}
 
83
        A() {}
 
84
        A(int intVal) {}
 
85
        A(double dblVal) {}
 
86
}
 
87
";
 
88
                        var result = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$new A()$"));
 
89
                        Assert.IsFalse(result.Member.IsStatic, "new A() is static");
 
90
                        Assert.AreEqual(0, result.Member.Parameters.Count, "new A() parameter count");
 
91
                        Assert.AreEqual("A", result.Type.FullName);
 
92
                        
 
93
                        result = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$new A(10)$"));
 
94
                        Assert.AreEqual(1, result.Member.Parameters.Count, "new A(10) parameter count");
 
95
                        Assert.AreEqual("intVal", result.Member.Parameters[0].Name, "new A(10) parameter");
 
96
                        
 
97
                        result = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$new A(11.1)$"));
 
98
                        Assert.AreEqual(1, result.Member.Parameters.Count, "new A(11.1) parameter count");
 
99
                        Assert.AreEqual("dblVal", result.Member.Parameters[0].Name, "new A(11.1) parameter");
 
100
                }
 
101
                
 
102
                [Test]
 
103
                public void DefaultCTorOverloadLookupTest()
 
104
                {
 
105
                        string program = @"class A {
 
106
        void Method() {
 
107
                $new A()$;
 
108
        }
 
109
}
 
110
";
 
111
                        var result = Resolve<CSharpInvocationResolveResult>(program);
 
112
                        Assert.AreEqual("A", result.Type.ReflectionName);
 
113
                        Assert.AreEqual(0, result.Member.Parameters.Count);
 
114
                }
 
115
                
 
116
                [Test]
 
117
                public void ChainedConstructorCall()
 
118
                {
 
119
                        string program = @"using System;
 
120
class A {
 
121
        public A(int a) {}
 
122
}
 
123
class B : A {
 
124
        public B(int b)
 
125
                : base(b)
 
126
        {}
 
127
}
 
128
class C : B {
 
129
        public C(int c)
 
130
                : base(c)
 
131
        {}
 
132
        
 
133
        public C()
 
134
                : this(0)
 
135
        {}
 
136
}
 
137
";
 
138
                        InvocationResolveResult mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("base(b)", "$base(b)$"));
 
139
                        Assert.AreEqual("A..ctor", mrr.Member.FullName);
 
140
                        
 
141
                        mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("base(c)", "$base(c)$"));
 
142
                        Assert.AreEqual("B..ctor", mrr.Member.FullName);
 
143
                        
 
144
                        mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("this(0)", "$this(0)$"));
 
145
                        Assert.AreEqual("C..ctor", mrr.Member.FullName);
 
146
                }
 
147
                
 
148
                [Test]
 
149
                public void FieldReferenceInObjectInitializer()
 
150
                {
 
151
                        string program = @"class A {
 
152
        public int Property;
 
153
}
 
154
class B {
 
155
        void Method() {
 
156
                var x = new A() { $Property = 0$ };
 
157
        }
 
158
}";
 
159
                        MemberResolveResult result = Resolve<MemberResolveResult>(program);
 
160
                        Assert.AreEqual("A.Property", result.Member.FullName);
 
161
                }
 
162
                
 
163
                [Test]
 
164
                public void FieldReferenceInNestedObjectInitializer()
 
165
                {
 
166
                        string program = @"class Point { public float X, Y; }
 
167
class Rect { public Point TopLeft, BottomRight; }
 
168
class B {
 
169
        void Method() {
 
170
                var x = new Rect() { TopLeft = { $X = 1$ } };
 
171
        }
 
172
}";
 
173
                        MemberResolveResult result = Resolve<MemberResolveResult>(program);
 
174
                        Assert.AreEqual("Point.X", result.Member.FullName);
 
175
                }
 
176
 
 
177
                [Test]
 
178
                public void CollectionInitializerTest()
 
179
                {
 
180
                        string program = @"using System.Collections.Generic;
 
181
class B {
 
182
        void Method() {
 
183
                var x = new List<int>() { ${ 0 }$ };
 
184
        }
 
185
}";
 
186
                        var result = Resolve<CSharpInvocationResolveResult>(program);
 
187
                        Assert.AreEqual("System.Collections.Generic.List.Add", result.Member.FullName);
 
188
                }
 
189
                
 
190
                [Test]
 
191
                public void DictionaryInitializerTest()
 
192
                {
 
193
                        string program = @"using System.Collections.Generic;
 
194
class B {
 
195
        void Method() {
 
196
                var x = new Dictionary<char, int>() { ${ 'a', 0 }$ };
 
197
        }
 
198
}";
 
199
                        var result = Resolve<CSharpInvocationResolveResult>(program);
 
200
                        Assert.AreEqual("System.Collections.Generic.Dictionary.Add", result.Member.FullName);
 
201
                }
 
202
                
 
203
                [Test]
 
204
                public void CanCallProtectedBaseConstructorInCtorInitializer()
 
205
                {
 
206
                        string program = @"using System.Collections.Generic;
 
207
class A { protected A(int x) {} }
 
208
class B : A { public B(int y) : $base(y)$ { } }";
 
209
                        var result = Resolve<CSharpInvocationResolveResult>(program);
 
210
                        Assert.IsFalse(result.IsError);
 
211
                        Assert.AreEqual("A..ctor", result.Member.FullName);
 
212
                }
 
213
                
 
214
                [Test]
 
215
                public void CannotCallProtectedBaseConstructorAsNewObject()
 
216
                {
 
217
                        string program = @"using System.Collections.Generic;
 
218
class A { protected A(int x) {} }
 
219
class B : A { public B(int y) { $new A(y)$; } }";
 
220
                        var result = Resolve<CSharpInvocationResolveResult>(program);
 
221
                        Assert.IsTrue(result.IsError);
 
222
                        Assert.AreEqual(OverloadResolutionErrors.Inaccessible, result.OverloadResolutionErrors);
 
223
                        Assert.AreEqual("A..ctor", result.Member.FullName); // should still find member even if it's not accessible
 
224
                }
 
225
                
 
226
                [Test]
 
227
                public void CannotCallProtectedDerivedConstructorAsNewObject()
 
228
                {
 
229
                        string program = @"using System.Collections.Generic;
 
230
class A { protected A(int x) { $new B(x)$; } }
 
231
class B : A { protected B(int y) {} }";
 
232
                        var result = Resolve<CSharpInvocationResolveResult>(program);
 
233
                        Assert.IsTrue(result.IsError);
 
234
                        Assert.AreEqual(OverloadResolutionErrors.Inaccessible, result.OverloadResolutionErrors);
 
235
                        Assert.AreEqual("B..ctor", result.Member.FullName); // should still find member even if it's not accessible
 
236
                }
 
237
                
 
238
                [Test]
 
239
                public void ComplexObjectInitializer()
 
240
                {
 
241
                        string program = @"using System;
 
242
using System.Collections.Generic;
 
243
struct Point { public int X, Y; }
 
244
class Test {
 
245
        public Point Pos;
 
246
        public List<string> List = new List<string>();
 
247
        public Dictionary<string, int> Dict = new Dictionary<string, int>();
 
248
        
 
249
        static object M() {
 
250
                return $new Test {
 
251
                        Pos = { X = 1, Y = 2 },
 
252
                        List = { ""Hello"", ""World"" },
 
253
                        Dict = { { ""A"", 1 } }
 
254
                }$;
 
255
        }
 
256
}";
 
257
                        var rr = Resolve<CSharpInvocationResolveResult>(program);
 
258
                        Assert.IsFalse(rr.IsError);
 
259
                        Assert.AreEqual("Test..ctor", rr.Member.FullName);
 
260
                        Assert.AreEqual("Test", rr.Type.ReflectionName);
 
261
                        Assert.AreEqual(5, rr.InitializerStatements.Count);
 
262
                }
 
263
                
 
264
                [Test]
 
265
                public void CreateGeneric()
 
266
                {
 
267
                        string program = @"using System;
 
268
class Test<T> where T : new() {
 
269
        object x = $new T()$;
 
270
}";
 
271
                        var rr = Resolve<CSharpInvocationResolveResult>(program);
 
272
                        Assert.IsFalse(rr.IsError);
 
273
                        Assert.AreEqual(TypeKind.TypeParameter, rr.Type.Kind);
 
274
                        Assert.AreEqual(TypeKind.TypeParameter, rr.Member.DeclaringType.Kind);
 
275
                }
 
276
                
 
277
                [Test]
 
278
                public void CreateDelegateFromMethodGroup()
 
279
                {
 
280
                        string program = @"using System;
 
281
delegate void D(int i);
 
282
class C {
 
283
        void M(int y) {
 
284
                D d = $new D(M)$;
 
285
        }
 
286
}";
 
287
                        var rr = Resolve<ConversionResolveResult>(program);
 
288
                        Assert.IsFalse(rr.IsError);
 
289
                        Assert.IsTrue(rr.Conversion.IsIdentityConversion);
 
290
                        var rr2 = (ConversionResolveResult)rr.Input;
 
291
                        Assert.IsFalse(rr2.IsError);
 
292
                        Assert.IsTrue(rr2.Conversion.IsMethodGroupConversion);
 
293
                        
 
294
                        Assert.AreEqual("C.M", rr2.Conversion.Method.FullName);
 
295
                        var mgrr = (MethodGroupResolveResult)rr2.Input;
 
296
                        Assert.IsInstanceOf<ThisResolveResult>(mgrr.TargetResult);
 
297
                }
 
298
                
 
299
                [Test]
 
300
                public void CreateDelegateFromDelegate()
 
301
                {
 
302
                        string program = @"using System;
 
303
delegate void D1(int i);
 
304
delegate void D2(int i);
 
305
class C {
 
306
        void M(D1 d1) {
 
307
                D2 d2 = $new D2(d1)$;
 
308
        }
 
309
}";
 
310
                        var rr = Resolve<ConversionResolveResult>(program);
 
311
                        Assert.IsFalse(rr.IsError);
 
312
                        Assert.IsTrue(rr.Conversion.IsMethodGroupConversion);
 
313
                        Assert.AreEqual("D1.Invoke", rr.Conversion.Method.FullName);
 
314
                        var mgrr = (MethodGroupResolveResult)rr.Input;
 
315
                        Assert.IsInstanceOf<LocalResolveResult>(mgrr.TargetResult);
 
316
                }
 
317
        }
 
318
}