← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to external/nrefactory/ICSharpCode.NRefactory.Tests/CSharp/CodeIssues/InconsistentNamingTests.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
ImportĀ upstreamĀ versionĀ 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
external/nrefactory/ICSharpCode.NRefactory.Tests/CSharp/CodeIssues/InconsistentNamingTests.cs
 
1
ļ»æ// 
 
2
// InconsistentNamingTests.cs
 
3
//  
 
4
// Author:
 
5
//       Mike KrĆ¼ger <mkrueger@xamarin.com>
 
6
// 
 
7
// Copyright (c) 2012 Xamarin <http://xamarin.com>
 
8
// 
 
9
// Permission is hereby granted, free of charge, to any person obtaining a copy
 
10
// of this software and associated documentation files (the "Software"), to deal
 
11
// in the Software without restriction, including without limitation the rights
 
12
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 
13
// copies of the Software, and to permit persons to whom the Software is
 
14
// furnished to do so, subject to the following conditions:
 
15
// 
 
16
// The above copyright notice and this permission notice shall be included in
 
17
// all copies or substantial portions of the Software.
 
18
// 
 
19
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
20
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
21
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 
22
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
23
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
24
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 
25
// THE SOFTWARE.
 
26
using System;
 
27
using NUnit.Framework;
 
28
using ICSharpCode.NRefactory.CSharp.Refactoring;
 
29
using ICSharpCode.NRefactory.CSharp.CodeActions;
 
30
using System.Linq;
 
31
 
 
32
namespace ICSharpCode.NRefactory.CSharp.CodeIssues
 
33
{
 
34
        [TestFixture]
 
35
        public class InconsistentNamingTests : InspectionActionTestBase
 
36
        {
 
37
                void CheckNaming (string input, string output, bool shouldBeEmpty = false)
 
38
                {
 
39
                        TestRefactoringContext context;
 
40
                        var issues = GetIssues (new InconsistentNamingIssue (), input, out context);
 
41
                        if (shouldBeEmpty) {
 
42
                                Assert.AreEqual (0, issues.Count ());
 
43
                                return;
 
44
                        }
 
45
                        Assert.Greater (issues.Count, 0);
 
46
                        CheckFix (context, issues [0], output);
 
47
                }
 
48
 
 
49
                [Ignore]
 
50
                [Test]
 
51
                public void TestUnderscoreFix ()
 
52
                {
 
53
                        var input = @"namespace FIX_1 {}";
 
54
                        var output = @"namespace Fix1 {}";
 
55
                        CheckNaming (input, output);
 
56
                }
 
57
 
 
58
                [Ignore]
 
59
                [Test]
 
60
                public void TestNamespaceName ()
 
61
                {
 
62
                        var input = @"namespace anIssue {}";
 
63
                        var output = @"namespace AnIssue {}";
 
64
                        CheckNaming (input, output);
 
65
                }
 
66
                
 
67
                [Test]
 
68
                public void TestClassName ()
 
69
                {
 
70
                        var input = @"public class anIssue {}";
 
71
                        var output = @"public class AnIssue {}";
 
72
                        CheckNaming (input, output);
 
73
                }
 
74
 
 
75
                [Test]
 
76
                public void TestAttributeName ()
 
77
                {
 
78
                        var input = @"public class test : System.Attribute {}";
 
79
                        var output = @"public class TestAttribute : System.Attribute {}";
 
80
                        CheckNaming (input, output);
 
81
                }
 
82
                
 
83
                [Test]
 
84
                public void TestEventArgsName ()
 
85
                {
 
86
                        var input = @"public class test : System.EventArgs {}";
 
87
                        var output = @"public class TestEventArgs : System.EventArgs {}";
 
88
                        CheckNaming (input, output);
 
89
                }
 
90
 
 
91
                [Test]
 
92
                public void TestException ()
 
93
                {
 
94
                        var input = @"class test : System.Exception {}";
 
95
                        var output = @"class TestException : System.Exception {}";
 
96
                        CheckNaming (input, output);
 
97
                }
 
98
                
 
99
                [Test]
 
100
                public void TestStructName ()
 
101
                {
 
102
                        var input = @"public struct anIssue {}";
 
103
                        var output = @"public struct AnIssue {}";
 
104
                        CheckNaming (input, output);
 
105
                }
 
106
 
 
107
                [Test]
 
108
                public void TestInterfaceName ()
 
109
                {
 
110
                        var input = @"public interface anIssue {}";
 
111
                        var output = @"public interface IAnIssue {}";
 
112
                        CheckNaming (input, output);
 
113
                }
 
114
 
 
115
                [Test]
 
116
                public void TestEnumName ()
 
117
                {
 
118
                        var input = @"public enum anIssue {}";
 
119
                        var output = @"public enum AnIssue {}";
 
120
                        CheckNaming (input, output);
 
121
                }
 
122
 
 
123
                [Test]
 
124
                public void TestDelegateName ()
 
125
                {
 
126
                        var input = @"public delegate void anIssue ();";
 
127
                        var output = @"public delegate void AnIssue ();";
 
128
                        CheckNaming (input, output);
 
129
                }
 
130
 
 
131
//              [Test]
 
132
//              public void TestPrivateFieldName ()
 
133
//              {
 
134
//                      var input = @"class AClass { int Field; }";
 
135
//                      var output = @"class AClass { int field; }";
 
136
//                      CheckNaming (input, output);
 
137
//              }
 
138
                
 
139
//              [Test]
 
140
//              public void TestUnderscoreFieldName ()
 
141
//              {
 
142
//                      var input = @"class AClass { int _Field; }";
 
143
//                      var output = @"class AClass { int _field; }";
 
144
//                      CheckNaming (input, output);
 
145
//              }
 
146
                
 
147
                [Test]
 
148
                public void TestPublicFieldName ()
 
149
                {
 
150
                        var input = @"class AClass { public int field; }";
 
151
                        var output = @"class AClass { public int Field; }";
 
152
                        CheckNaming (input, output);
 
153
                }
 
154
                
 
155
//              [Test]
 
156
//              public void TestPrivateConstantFieldName ()
 
157
//              {
 
158
//                      var input = @"class AClass { const int field = 5; }";
 
159
//                      var output = @"class AClass { const int Field = 5; }";
 
160
//                      CheckNaming (input, output);
 
161
//              }
 
162
                
 
163
                [Test]
 
164
                public void TestPublicReadOnlyFieldName ()
 
165
                {
 
166
                        var input = @"class AClass { public readonly int field; }";
 
167
                        var output = @"class AClass { public readonly int Field; }";
 
168
                        CheckNaming (input, output);
 
169
                }
 
170
                
 
171
                [Test]
 
172
                public void TestPrivateStaticReadOnlyFieldName ()
 
173
                {
 
174
                        var input = @"class AClass { static readonly int Field; }";
 
175
                        var output = @"class AClass { static readonly int Field; }";
 
176
                        CheckNaming (input, output, true);
 
177
                }
 
178
                
 
179
                [Test]
 
180
                public void TestPrivateStaticReadOnlyFieldNameCase2 ()
 
181
                {
 
182
                        var input = @"class AClass { static readonly int field; }";
 
183
                        var output = @"class AClass { static readonly int field; }";
 
184
                        CheckNaming (input, output, true);
 
185
                }
 
186
 
 
187
//              [Test]
 
188
//              public void TestPrivateStaticFieldName ()
 
189
//              {
 
190
//                      var input = @"class AClass { static int Field; }";
 
191
//                      var output = @"class AClass { static int field; }";
 
192
//                      CheckNaming (input, output);
 
193
//              }
 
194
 
 
195
                [Test]
 
196
                public void TestPublicStaticReadOnlyFieldName ()
 
197
                {
 
198
                        var input = @"class AClass { public static readonly int field = 5; }";
 
199
                        var output = @"class AClass { public static readonly int Field = 5; }";
 
200
                        CheckNaming (input, output);
 
201
                }
 
202
                
 
203
//              [Test]
 
204
//              public void TestPrivateReadOnlyFieldName ()
 
205
//              {
 
206
//                      var input = @"class AClass { readonly int Field; }";
 
207
//                      var output = @"class AClass { readonly int field; }";
 
208
//                      CheckNaming (input, output);
 
209
//              }
 
210
                
 
211
                [Test]
 
212
                public void TestPublicConstantFieldName ()
 
213
                {
 
214
                        var input = @"class AClass { public const int field = 5; }";
 
215
                        var output = @"class AClass { public const int Field = 5; }";
 
216
                        CheckNaming (input, output);
 
217
                }
 
218
                
 
219
                [Test]
 
220
                public void TestMethodName ()
 
221
                {
 
222
                        var input = @"class AClass { public int method () {} }";
 
223
                        var output = @"class AClass { public int Method () {} }";
 
224
                        CheckNaming (input, output);
 
225
                }
 
226
 
 
227
                [Test]
 
228
                public void TestPropertyName ()
 
229
                {
 
230
                        var input = @"class AClass { public int property { get; set; } }";
 
231
                        var output = @"class AClass { public int Property { get; set; } }";
 
232
                        CheckNaming (input, output);
 
233
                }
 
234
 
 
235
                [Test]
 
236
                public void TestParameterName ()
 
237
                {
 
238
                        var input = @"class AClass { int Method (int Param) {} }";
 
239
                        var output = @"class AClass { int Method (int param) {} }";
 
240
                        CheckNaming (input, output);
 
241
                }
 
242
 
 
243
                [Test]
 
244
                public void TestTypeParameterName ()
 
245
                {
 
246
                        var input = @"struct Str<K> { K k;}";
 
247
                        var output = @"struct Str<TK> { TK k;}";
 
248
                        CheckNaming (input, output);
 
249
                }
 
250
 
 
251
 
 
252
                [Test]
 
253
                public void TestOverrideMembers ()
 
254
                {
 
255
                        var input = @"
 
256
class Base { public virtual int method (int Param) {} }
 
257
class MyClass : Base { public override int method (int Param) {} }";
 
258
                        TestRefactoringContext context;
 
259
                        var issues = GetIssues (new InconsistentNamingIssue (), input, out context);
 
260
                        Assert.AreEqual (2, issues.Count);
 
261
                }
 
262
 
 
263
                [Test]
 
264
                public void TestOverrideMembersParameterNameCaseMismatch ()
 
265
                {
 
266
                        var input = @"
 
267
class Base { public virtual int Method (int param) {} }
 
268
class MyClass : Base { public override int Method (int Param) {} }";
 
269
                        TestRefactoringContext context;
 
270
                        var issues = GetIssues (new InconsistentNamingIssue (), input, out context);
 
271
                        foreach (var issue in issues)
 
272
                                Console.WriteLine(issue.Description);
 
273
                        Assert.AreEqual (1, issues.Count);
 
274
                }
 
275
        }
 
276
 
 
277
        [TestFixture]
 
278
        public class WordParserTests
 
279
        {
 
280
                [Test]
 
281
                public void TestPascalCaseWords ()
 
282
                {
 
283
                        var result = WordParser.BreakWords ("SomeVeryLongName");
 
284
                        Assert.AreEqual (4, result.Count);
 
285
                        Assert.AreEqual ("Some", result [0]);
 
286
                        Assert.AreEqual ("Very", result [1]);
 
287
                        Assert.AreEqual ("Long", result [2]);
 
288
                        Assert.AreEqual ("Name", result [3]);
 
289
                }
 
290
 
 
291
                [Test]
 
292
                public void TestCamelCaseWords ()
 
293
                {
 
294
                        var result = WordParser.BreakWords ("someVeryLongName");
 
295
                        Assert.AreEqual (4, result.Count);
 
296
                        Assert.AreEqual ("some", result [0]);
 
297
                        Assert.AreEqual ("Very", result [1]);
 
298
                        Assert.AreEqual ("Long", result [2]);
 
299
                        Assert.AreEqual ("Name", result [3]);
 
300
                }
 
301
 
 
302
                [Test]
 
303
                public void TestUpperCaseSubWord ()
 
304
                {
 
305
                        var result = WordParser.BreakWords ("someVeryLongXMLName");
 
306
                        Assert.AreEqual (5, result.Count);
 
307
                        Assert.AreEqual ("some", result [0]);
 
308
                        Assert.AreEqual ("Very", result [1]);
 
309
                        Assert.AreEqual ("Long", result [2]);
 
310
                        Assert.AreEqual ("XML", result [3]);
 
311
                        Assert.AreEqual ("Name", result [4]);
 
312
                }
 
313
 
 
314
                [Test]
 
315
                public void TestUnderscore ()
 
316
                {
 
317
                        var result = WordParser.BreakWords ("some_Very_long_NAME");
 
318
                        Assert.AreEqual (4, result.Count);
 
319
                        Assert.AreEqual ("some", result [0]);
 
320
                        Assert.AreEqual ("Very", result [1]);
 
321
                        Assert.AreEqual ("long", result [2]);
 
322
                        Assert.AreEqual ("NAME", result [3]);
 
323
                }
 
324
 
 
325
                [Test]
 
326
                public void TestUnderscoreCase1 ()
 
327
                {
 
328
                        var result = WordParser.BreakWords ("FIX_1");
 
329
                        Assert.AreEqual (2, result.Count);
 
330
                        Assert.AreEqual ("FIX", result [0]);
 
331
                        Assert.AreEqual ("1", result [1]);
 
332
                }
 
333
 
 
334
        }
 
335
}
 
336