← 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.VB.Tests/Parser/TypeLevel/MethodDeclarationTests.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.VB.Tests/Parser/TypeLevel/MethodDeclarationTests.cs
 
1
ļ»æ// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 
2
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
3
 
 
4
using System;
 
5
using ICSharpCode.NRefactory.VB.Ast;
 
6
using NUnit.Framework;
 
7
 
 
8
namespace ICSharpCode.NRefactory.VB.Tests.Ast
 
9
{
 
10
        [TestFixture]
 
11
        public class MethodDeclarationTests
 
12
        {
 
13
                #region VB.NET
 
14
                
 
15
                [Test]
 
16
                public void VBNetDefiningPartialMethodDeclarationTest()
 
17
                {
 
18
                        MethodDeclaration md = ParseUtil.ParseTypeMember<MethodDeclaration>(@"Partial Sub MyMethod()
 
19
                                                                                                 End Sub");
 
20
                        Assert.AreEqual(0, md.Parameters.Count);
 
21
                        Assert.AreEqual("MyMethod", md.Name);
 
22
                        Assert.IsFalse(md.IsExtensionMethod);
 
23
                        Assert.AreEqual(Modifiers.Partial, md.Modifier);
 
24
                }
 
25
                
 
26
                [Test]
 
27
                public void VBNetMethodWithModifiersRegionTest()
 
28
                {
 
29
                        const string program = @"public shared sub MyMethod()
 
30
                                OtherMethod()
 
31
                        end sub";
 
32
                        
 
33
                        MethodDeclaration md = ParseUtil.ParseTypeMember<MethodDeclaration>(program);
 
34
                        Assert.AreEqual(Modifiers.Public | Modifiers.Static, md.Modifier);
 
35
                        Assert.AreEqual(2, md.StartLocation.Line, "StartLocation.Y");
 
36
                        Assert.AreEqual(2, md.EndLocation.Line, "EndLocation.Y");
 
37
                        Assert.AreEqual(2, md.StartLocation.Column, "StartLocation.X");
 
38
                }
 
39
                
 
40
                [Test]
 
41
                public void VBNetFunctionMethodDeclarationTest()
 
42
                {
 
43
                        const string program = @"public function MyFunction() as Integer
 
44
                                return 1
 
45
                        end function";
 
46
                        
 
47
                        MethodDeclaration md = ParseUtil.ParseTypeMember<MethodDeclaration>(program);
 
48
                        Assert.AreEqual(Modifiers.Public, md.Modifier);
 
49
                        Assert.AreEqual(2, md.StartLocation.Line, "StartLocation.Y");
 
50
                        Assert.AreEqual(2, md.StartLocation.Column, "StartLocation.X");
 
51
                        Assert.AreEqual(2, md.EndLocation.Line, "EndLocation.Y");
 
52
                }
 
53
                
 
54
                [Test]
 
55
                public void VBNetSubroutineMethodDeclarationTest()
 
56
                {
 
57
                        const string program = @"public Sub MyMethod()
 
58
                                OtherMethod()
 
59
                        end Sub";
 
60
                        
 
61
                        MethodDeclaration md = ParseUtil.ParseTypeMember<MethodDeclaration>(program);
 
62
                        Assert.AreEqual(Modifiers.Public, md.Modifier);
 
63
                        Assert.AreEqual(2, md.StartLocation.Line, "StartLocation.Y");
 
64
                        Assert.AreEqual(2, md.StartLocation.Column, "StartLocation.X");
 
65
                        Assert.AreEqual(2, md.EndLocation.Line, "EndLocation.Y");
 
66
                }
 
67
                
 
68
                [Test]
 
69
                public void VBNetGenericFunctionMethodDeclarationTest()
 
70
                {
 
71
                        MethodDeclaration md = ParseUtil.ParseTypeMember<MethodDeclaration>("function MyMethod(Of T)(a As T) As Double\nEnd Function");
 
72
                        Assert.AreEqual("System.Double", md.TypeReference.Type);
 
73
                        Assert.AreEqual(1, md.Parameters.Count);
 
74
                        Assert.AreEqual("T", ((ParameterDeclarationExpression)md.Parameters[0]).TypeReference.Type);
 
75
                        Assert.AreEqual("a", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName);
 
76
                        
 
77
                        Assert.AreEqual(1, md.Templates.Count);
 
78
                        Assert.AreEqual("T", md.Templates[0].Name);
 
79
                }
 
80
                
 
81
                [Test]
 
82
                public void VBNetGenericMethodDeclarationTest()
 
83
                {
 
84
                        MethodDeclaration md = ParseUtil.ParseTypeMember<MethodDeclaration>("Function MyMethod(Of T)(a As T) As T\nEnd Function ");
 
85
                        Assert.AreEqual("T", md.TypeReference.Type);
 
86
                        Assert.AreEqual(1, md.Parameters.Count);
 
87
                        Assert.AreEqual("T", ((ParameterDeclarationExpression)md.Parameters[0]).TypeReference.Type);
 
88
                        Assert.AreEqual("a", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName);
 
89
                        
 
90
                        Assert.AreEqual(1, md.Templates.Count);
 
91
                        Assert.AreEqual("T", md.Templates[0].Name);
 
92
                }
 
93
                
 
94
                [Test]
 
95
                public void VBNetGenericMethodDeclarationWithConstraintTest()
 
96
                {
 
97
                        string program = "Function MyMethod(Of T As { ISomeInterface })(a As T) As T\n End Function";
 
98
                        MethodDeclaration md = ParseUtil.ParseTypeMember<MethodDeclaration>(program);
 
99
                        Assert.AreEqual("T", md.TypeReference.Type);
 
100
                        Assert.AreEqual(1, md.Parameters.Count);
 
101
                        Assert.AreEqual("T", ((ParameterDeclarationExpression)md.Parameters[0]).TypeReference.Type);
 
102
                        Assert.AreEqual("a", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName);
 
103
                        
 
104
                        Assert.AreEqual(1, md.Templates.Count);
 
105
                        Assert.AreEqual("T", md.Templates[0].Name);
 
106
                        Assert.AreEqual(1, md.Templates[0].Bases.Count);
 
107
                        Assert.AreEqual("ISomeInterface", md.Templates[0].Bases[0].Type);
 
108
                }
 
109
                
 
110
                [Test]
 
111
                public void VBNetExtensionMethodDeclaration()
 
112
                {
 
113
                        MethodDeclaration md = ParseUtil.ParseTypeMember<MethodDeclaration>(
 
114
                                @"<Extension> _
 
115
                                Sub Print(s As String)
 
116
                                        Console.WriteLine(s)
 
117
                                End Sub");
 
118
                        
 
119
                        Assert.AreEqual("Print", md.Name);
 
120
                        
 
121
                        // IsExtensionMethod is only valid for c#.
 
122
                        // Assert.IsTrue(md.IsExtensionMethod);
 
123
                        
 
124
                        Assert.AreEqual("s", md.Parameters[0].ParameterName);
 
125
                        Assert.AreEqual("System.String", md.Parameters[0].TypeReference.Type);
 
126
                }
 
127
                
 
128
                [Test]
 
129
                public void VBNetGenericMethodInInterface()
 
130
                {
 
131
                        const string program = @"Interface MyInterface
 
132
                                Function MyMethod(Of T As {ISomeInterface})(a As T) As T
 
133
                                End Interface";
 
134
                        TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
 
135
                        MethodDeclaration md = (MethodDeclaration)td.Children[0];
 
136
                        Assert.AreEqual("T", md.TypeReference.Type);
 
137
                        Assert.AreEqual(1, md.Parameters.Count);
 
138
                        Assert.AreEqual("T", ((ParameterDeclarationExpression)md.Parameters[0]).TypeReference.Type);
 
139
                        Assert.AreEqual("a", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName);
 
140
                        
 
141
                        Assert.AreEqual(1, md.Templates.Count);
 
142
                        Assert.AreEqual("T", md.Templates[0].Name);
 
143
                        Assert.AreEqual(1, md.Templates[0].Bases.Count);
 
144
                        Assert.AreEqual("ISomeInterface", md.Templates[0].Bases[0].Type);
 
145
                }
 
146
                
 
147
                [Test]
 
148
                public void VBNetGenericVoidMethodInInterface()
 
149
                {
 
150
                        const string program = @"interface MyInterface
 
151
        Sub MyMethod(Of T As {ISomeInterface})(a as T)
 
152
End Interface
 
153
";
 
154
                        TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
 
155
                        MethodDeclaration md = (MethodDeclaration)td.Children[0];
 
156
                        Assert.AreEqual("System.Void", md.TypeReference.Type);
 
157
                        Assert.AreEqual(1, md.Parameters.Count);
 
158
                        Assert.AreEqual("T", ((ParameterDeclarationExpression)md.Parameters[0]).TypeReference.Type);
 
159
                        Assert.AreEqual("a", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName);
 
160
                        
 
161
                        Assert.AreEqual(1, md.Templates.Count);
 
162
                        Assert.AreEqual("T", md.Templates[0].Name);
 
163
                        Assert.AreEqual(1, md.Templates[0].Bases.Count);
 
164
                        Assert.AreEqual("ISomeInterface", md.Templates[0].Bases[0].Type);
 
165
                }
 
166
                
 
167
                [Test]
 
168
                public void VBNetMethodWithHandlesClause()
 
169
                {
 
170
                        MethodDeclaration md = ParseUtil.ParseTypeMember<MethodDeclaration>(
 
171
                                @"Public Sub MyMethod(sender As Object, e As EventArgs) Handles x.y
 
172
                        End Sub");
 
173
                        Assert.AreEqual(new string[] { "x.y" }, md.HandlesClause.ToArray());
 
174
                        
 
175
                        md = ParseUtil.ParseTypeMember<MethodDeclaration>(
 
176
                                @"Public Sub MyMethod() Handles Me.FormClosing
 
177
                        End Sub");
 
178
                        Assert.AreEqual(new string[] { "Me.FormClosing" }, md.HandlesClause.ToArray());
 
179
                        
 
180
                        md = ParseUtil.ParseTypeMember<MethodDeclaration>(
 
181
                                @"Public Sub MyMethod() Handles MyBase.Event, Button1.Click
 
182
                        End Sub");
 
183
                        Assert.AreEqual(new string[] { "MyBase.Event", "Button1.Click" }, md.HandlesClause.ToArray());
 
184
                }
 
185
                
 
186
                [Test]
 
187
                public void VBNetMethodWithTypeCharactersTest()
 
188
                {
 
189
                        const string program = @"Public Function Func!(ByVal Param&)
 
190
                                Func! = CSingle(Param&)
 
191
                        End Function";
 
192
                        
 
193
                        MethodDeclaration md = ParseUtil.ParseTypeMember<MethodDeclaration>(program);
 
194
                        Assert.AreEqual(Modifiers.Public, md.Modifier);
 
195
                }
 
196
                
 
197
                #endregion
 
198
        }
 
199
}