OLD | NEW |
1 // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 library test.services.refactoring.naming_conventions; | 5 library test.services.refactoring.naming_conventions; |
6 | 6 |
7 import 'package:analysis_server/src/protocol.dart' | 7 import 'package:analysis_server/src/protocol.dart' |
8 show RefactoringProblemSeverity; | 8 show RefactoringProblemSeverity; |
9 import 'package:analysis_server/src/services/refactoring/naming_conventions.dart
'; | 9 import 'package:analysis_server/src/services/refactoring/naming_conventions.dart
'; |
10 import 'package:analysis_server/src/services/refactoring/refactoring.dart'; | 10 import 'package:analysis_server/src/services/refactoring/refactoring.dart'; |
11 import 'package:test_reflective_loader/test_reflective_loader.dart'; | 11 import 'package:test_reflective_loader/test_reflective_loader.dart'; |
12 import 'package:unittest/unittest.dart'; | |
13 | 12 |
| 13 import '../../utils.dart'; |
14 import 'abstract_refactoring.dart'; | 14 import 'abstract_refactoring.dart'; |
15 | 15 |
16 main() { | 16 main() { |
17 groupSep = ' | '; | 17 initializeTestEnvironment(); |
18 defineReflectiveTests(NamingConventionsTest); | 18 defineReflectiveTests(NamingConventionsTest); |
19 } | 19 } |
20 | 20 |
21 @reflectiveTest | 21 @reflectiveTest |
22 class NamingConventionsTest extends RefactoringTest { | 22 class NamingConventionsTest extends RefactoringTest { |
23 @override | 23 @override |
24 Refactoring get refactoring => null; | 24 Refactoring get refactoring => null; |
25 | 25 |
26 void test_validateClassName_doesNotStartWithLowerCase() { | 26 void test_validateClassName_doesNotStartWithLowerCase() { |
27 assertRefactoringStatus( | 27 assertRefactoringStatus( |
(...skipping 15 matching lines...) Expand all Loading... |
43 | 43 |
44 void test_validateClassName_notIdentifierMiddle() { | 44 void test_validateClassName_notIdentifierMiddle() { |
45 assertRefactoringStatus( | 45 assertRefactoringStatus( |
46 validateClassName("New-Name"), RefactoringProblemSeverity.FATAL, | 46 validateClassName("New-Name"), RefactoringProblemSeverity.FATAL, |
47 expectedMessage: "Class name must not contain '-'."); | 47 expectedMessage: "Class name must not contain '-'."); |
48 } | 48 } |
49 | 49 |
50 void test_validateClassName_notIdentifierStart() { | 50 void test_validateClassName_notIdentifierStart() { |
51 assertRefactoringStatus( | 51 assertRefactoringStatus( |
52 validateClassName("-NewName"), RefactoringProblemSeverity.FATAL, | 52 validateClassName("-NewName"), RefactoringProblemSeverity.FATAL, |
53 expectedMessage: "Class name must begin with an uppercase letter or unde
rscore."); | 53 expectedMessage: |
| 54 "Class name must begin with an uppercase letter or underscore."); |
54 } | 55 } |
55 | 56 |
56 void test_validateClassName_null() { | 57 void test_validateClassName_null() { |
57 assertRefactoringStatus( | 58 assertRefactoringStatus( |
58 validateClassName(null), RefactoringProblemSeverity.FATAL, | 59 validateClassName(null), RefactoringProblemSeverity.FATAL, |
59 expectedMessage: "Class name must not be null."); | 60 expectedMessage: "Class name must not be null."); |
60 } | 61 } |
61 | 62 |
62 void test_validateClassName_OK() { | 63 void test_validateClassName_OK() { |
63 assertRefactoringStatusOK(validateClassName("NewName")); | 64 assertRefactoringStatusOK(validateClassName("NewName")); |
(...skipping 13 matching lines...) Expand all Loading... |
77 | 78 |
78 void test_validateClassName_trailingBlanks() { | 79 void test_validateClassName_trailingBlanks() { |
79 assertRefactoringStatus( | 80 assertRefactoringStatus( |
80 validateClassName("NewName "), RefactoringProblemSeverity.FATAL, | 81 validateClassName("NewName "), RefactoringProblemSeverity.FATAL, |
81 expectedMessage: "Class name must not start or end with a blank."); | 82 expectedMessage: "Class name must not start or end with a blank."); |
82 } | 83 } |
83 | 84 |
84 void test_validateConstructorName_doesNotStartWithLowerCase() { | 85 void test_validateConstructorName_doesNotStartWithLowerCase() { |
85 assertRefactoringStatus( | 86 assertRefactoringStatus( |
86 validateConstructorName("NewName"), RefactoringProblemSeverity.WARNING, | 87 validateConstructorName("NewName"), RefactoringProblemSeverity.WARNING, |
87 expectedMessage: "Constructor name should start with a lowercase letter.
"); | 88 expectedMessage: |
| 89 "Constructor name should start with a lowercase letter."); |
88 } | 90 } |
89 | 91 |
90 void test_validateConstructorName_empty() { | 92 void test_validateConstructorName_empty() { |
91 assertRefactoringStatusOK(validateConstructorName("")); | 93 assertRefactoringStatusOK(validateConstructorName("")); |
92 } | 94 } |
93 | 95 |
94 void test_validateConstructorName_leadingBlanks() { | 96 void test_validateConstructorName_leadingBlanks() { |
95 assertRefactoringStatus( | 97 assertRefactoringStatus( |
96 validateConstructorName(" newName"), RefactoringProblemSeverity.FATAL, | 98 validateConstructorName(" newName"), RefactoringProblemSeverity.FATAL, |
97 expectedMessage: "Constructor name must not start or end with a blank.")
; | 99 expectedMessage: |
| 100 "Constructor name must not start or end with a blank."); |
98 } | 101 } |
99 | 102 |
100 void test_validateConstructorName_notIdentifierMiddle() { | 103 void test_validateConstructorName_notIdentifierMiddle() { |
101 assertRefactoringStatus( | 104 assertRefactoringStatus( |
102 validateConstructorName("na-me"), RefactoringProblemSeverity.FATAL, | 105 validateConstructorName("na-me"), RefactoringProblemSeverity.FATAL, |
103 expectedMessage: "Constructor name must not contain '-'."); | 106 expectedMessage: "Constructor name must not contain '-'."); |
104 } | 107 } |
105 | 108 |
106 void test_validateConstructorName_notIdentifierStart() { | 109 void test_validateConstructorName_notIdentifierStart() { |
107 assertRefactoringStatus( | 110 assertRefactoringStatus( |
108 validateConstructorName("2name"), RefactoringProblemSeverity.FATAL, | 111 validateConstructorName("2name"), RefactoringProblemSeverity.FATAL, |
109 expectedMessage: "Constructor name must begin with a lowercase letter or
underscore."); | 112 expectedMessage: |
| 113 "Constructor name must begin with a lowercase letter or underscore."
); |
110 } | 114 } |
111 | 115 |
112 void test_validateConstructorName_null() { | 116 void test_validateConstructorName_null() { |
113 assertRefactoringStatus( | 117 assertRefactoringStatus( |
114 validateConstructorName(null), RefactoringProblemSeverity.FATAL, | 118 validateConstructorName(null), RefactoringProblemSeverity.FATAL, |
115 expectedMessage: "Constructor name must not be null."); | 119 expectedMessage: "Constructor name must not be null."); |
116 } | 120 } |
117 | 121 |
118 void test_validateConstructorName_OK() { | 122 void test_validateConstructorName_OK() { |
119 assertRefactoringStatusOK(validateConstructorName("newName")); | 123 assertRefactoringStatusOK(validateConstructorName("newName")); |
120 } | 124 } |
121 | 125 |
122 void test_validateConstructorName_OK_leadingUnderscore() { | 126 void test_validateConstructorName_OK_leadingUnderscore() { |
123 assertRefactoringStatusOK(validateConstructorName("_newName")); | 127 assertRefactoringStatusOK(validateConstructorName("_newName")); |
124 } | 128 } |
125 | 129 |
126 void test_validateConstructorName_trailingBlanks() { | 130 void test_validateConstructorName_trailingBlanks() { |
127 assertRefactoringStatus( | 131 assertRefactoringStatus( |
128 validateConstructorName("newName "), RefactoringProblemSeverity.FATAL, | 132 validateConstructorName("newName "), RefactoringProblemSeverity.FATAL, |
129 expectedMessage: "Constructor name must not start or end with a blank.")
; | 133 expectedMessage: |
| 134 "Constructor name must not start or end with a blank."); |
130 } | 135 } |
131 | 136 |
132 void test_validateFieldName_doesNotStartWithLowerCase() { | 137 void test_validateFieldName_doesNotStartWithLowerCase() { |
133 assertRefactoringStatus( | 138 assertRefactoringStatus( |
134 validateFieldName("NewName"), RefactoringProblemSeverity.WARNING, | 139 validateFieldName("NewName"), RefactoringProblemSeverity.WARNING, |
135 expectedMessage: "Field name should start with a lowercase letter."); | 140 expectedMessage: "Field name should start with a lowercase letter."); |
136 } | 141 } |
137 | 142 |
138 void test_validateFieldName_empty() { | 143 void test_validateFieldName_empty() { |
139 assertRefactoringStatus( | 144 assertRefactoringStatus( |
140 validateFieldName(""), RefactoringProblemSeverity.FATAL, | 145 validateFieldName(""), RefactoringProblemSeverity.FATAL, |
141 expectedMessage: "Field name must not be empty."); | 146 expectedMessage: "Field name must not be empty."); |
142 } | 147 } |
143 | 148 |
144 void test_validateFieldName_leadingBlanks() { | 149 void test_validateFieldName_leadingBlanks() { |
145 assertRefactoringStatus( | 150 assertRefactoringStatus( |
146 validateFieldName(" newName"), RefactoringProblemSeverity.FATAL, | 151 validateFieldName(" newName"), RefactoringProblemSeverity.FATAL, |
147 expectedMessage: "Field name must not start or end with a blank."); | 152 expectedMessage: "Field name must not start or end with a blank."); |
148 } | 153 } |
149 | 154 |
150 void test_validateFieldName_notIdentifierMiddle() { | 155 void test_validateFieldName_notIdentifierMiddle() { |
151 assertRefactoringStatus( | 156 assertRefactoringStatus( |
152 validateFieldName("new-Name"), RefactoringProblemSeverity.FATAL, | 157 validateFieldName("new-Name"), RefactoringProblemSeverity.FATAL, |
153 expectedMessage: "Field name must not contain '-'."); | 158 expectedMessage: "Field name must not contain '-'."); |
154 } | 159 } |
155 | 160 |
156 void test_validateFieldName_notIdentifierStart() { | 161 void test_validateFieldName_notIdentifierStart() { |
157 assertRefactoringStatus( | 162 assertRefactoringStatus( |
158 validateFieldName("2newName"), RefactoringProblemSeverity.FATAL, | 163 validateFieldName("2newName"), RefactoringProblemSeverity.FATAL, |
159 expectedMessage: "Field name must begin with a lowercase letter or under
score."); | 164 expectedMessage: |
| 165 "Field name must begin with a lowercase letter or underscore."); |
160 } | 166 } |
161 | 167 |
162 void test_validateFieldName_null() { | 168 void test_validateFieldName_null() { |
163 assertRefactoringStatus( | 169 assertRefactoringStatus( |
164 validateFieldName(null), RefactoringProblemSeverity.FATAL, | 170 validateFieldName(null), RefactoringProblemSeverity.FATAL, |
165 expectedMessage: "Field name must not be null."); | 171 expectedMessage: "Field name must not be null."); |
166 } | 172 } |
167 | 173 |
168 void test_validateFieldName_OK() { | 174 void test_validateFieldName_OK() { |
169 assertRefactoringStatusOK(validateFieldName("newName")); | 175 assertRefactoringStatusOK(validateFieldName("newName")); |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
203 | 209 |
204 void test_validateFunctionName_notIdentifierMiddle() { | 210 void test_validateFunctionName_notIdentifierMiddle() { |
205 assertRefactoringStatus( | 211 assertRefactoringStatus( |
206 validateFunctionName("new-Name"), RefactoringProblemSeverity.FATAL, | 212 validateFunctionName("new-Name"), RefactoringProblemSeverity.FATAL, |
207 expectedMessage: "Function name must not contain '-'."); | 213 expectedMessage: "Function name must not contain '-'."); |
208 } | 214 } |
209 | 215 |
210 void test_validateFunctionName_notIdentifierStart() { | 216 void test_validateFunctionName_notIdentifierStart() { |
211 assertRefactoringStatus( | 217 assertRefactoringStatus( |
212 validateFunctionName("2newName"), RefactoringProblemSeverity.FATAL, | 218 validateFunctionName("2newName"), RefactoringProblemSeverity.FATAL, |
213 expectedMessage: "Function name must begin with a lowercase letter or un
derscore."); | 219 expectedMessage: |
| 220 "Function name must begin with a lowercase letter or underscore."); |
214 } | 221 } |
215 | 222 |
216 void test_validateFunctionName_null() { | 223 void test_validateFunctionName_null() { |
217 assertRefactoringStatus( | 224 assertRefactoringStatus( |
218 validateFunctionName(null), RefactoringProblemSeverity.FATAL, | 225 validateFunctionName(null), RefactoringProblemSeverity.FATAL, |
219 expectedMessage: "Function name must not be null."); | 226 expectedMessage: "Function name must not be null."); |
220 } | 227 } |
221 | 228 |
222 void test_validateFunctionName_OK() { | 229 void test_validateFunctionName_OK() { |
223 assertRefactoringStatusOK(validateFunctionName("newName")); | 230 assertRefactoringStatusOK(validateFunctionName("newName")); |
224 } | 231 } |
225 | 232 |
226 void test_validateFunctionName_OK_leadingUnderscore() { | 233 void test_validateFunctionName_OK_leadingUnderscore() { |
227 assertRefactoringStatusOK(validateFunctionName("_newName")); | 234 assertRefactoringStatusOK(validateFunctionName("_newName")); |
228 } | 235 } |
229 | 236 |
230 void test_validateFunctionName_OK_middleUnderscore() { | 237 void test_validateFunctionName_OK_middleUnderscore() { |
231 assertRefactoringStatusOK(validateFunctionName("new_name")); | 238 assertRefactoringStatusOK(validateFunctionName("new_name")); |
232 } | 239 } |
233 | 240 |
234 void test_validateFunctionName_trailingBlanks() { | 241 void test_validateFunctionName_trailingBlanks() { |
235 assertRefactoringStatus( | 242 assertRefactoringStatus( |
236 validateFunctionName("newName "), RefactoringProblemSeverity.FATAL, | 243 validateFunctionName("newName "), RefactoringProblemSeverity.FATAL, |
237 expectedMessage: "Function name must not start or end with a blank."); | 244 expectedMessage: "Function name must not start or end with a blank."); |
238 } | 245 } |
239 | 246 |
240 void test_validateFunctionTypeAliasName_doesNotStartWithLowerCase() { | 247 void test_validateFunctionTypeAliasName_doesNotStartWithLowerCase() { |
241 assertRefactoringStatus(validateFunctionTypeAliasName("newName"), | 248 assertRefactoringStatus(validateFunctionTypeAliasName("newName"), |
242 RefactoringProblemSeverity.WARNING, | 249 RefactoringProblemSeverity.WARNING, |
243 expectedMessage: "Function type alias name should start with an uppercas
e letter."); | 250 expectedMessage: |
| 251 "Function type alias name should start with an uppercase letter."); |
244 } | 252 } |
245 | 253 |
246 void test_validateFunctionTypeAliasName_empty() { | 254 void test_validateFunctionTypeAliasName_empty() { |
247 assertRefactoringStatus( | 255 assertRefactoringStatus( |
248 validateFunctionTypeAliasName(""), RefactoringProblemSeverity.FATAL, | 256 validateFunctionTypeAliasName(""), RefactoringProblemSeverity.FATAL, |
249 expectedMessage: "Function type alias name must not be empty."); | 257 expectedMessage: "Function type alias name must not be empty."); |
250 } | 258 } |
251 | 259 |
252 void test_validateFunctionTypeAliasName_leadingBlanks() { | 260 void test_validateFunctionTypeAliasName_leadingBlanks() { |
253 assertRefactoringStatus(validateFunctionTypeAliasName(" NewName"), | 261 assertRefactoringStatus(validateFunctionTypeAliasName(" NewName"), |
254 RefactoringProblemSeverity.FATAL, | 262 RefactoringProblemSeverity.FATAL, |
255 expectedMessage: "Function type alias name must not start or end with a
blank."); | 263 expectedMessage: |
| 264 "Function type alias name must not start or end with a blank."); |
256 } | 265 } |
257 | 266 |
258 void test_validateFunctionTypeAliasName_notIdentifierMiddle() { | 267 void test_validateFunctionTypeAliasName_notIdentifierMiddle() { |
259 assertRefactoringStatus(validateFunctionTypeAliasName("New-Name"), | 268 assertRefactoringStatus(validateFunctionTypeAliasName("New-Name"), |
260 RefactoringProblemSeverity.FATAL, | 269 RefactoringProblemSeverity.FATAL, |
261 expectedMessage: "Function type alias name must not contain '-'."); | 270 expectedMessage: "Function type alias name must not contain '-'."); |
262 } | 271 } |
263 | 272 |
264 void test_validateFunctionTypeAliasName_notIdentifierStart() { | 273 void test_validateFunctionTypeAliasName_notIdentifierStart() { |
265 assertRefactoringStatus(validateFunctionTypeAliasName("-NewName"), | 274 assertRefactoringStatus(validateFunctionTypeAliasName("-NewName"), |
266 RefactoringProblemSeverity.FATAL, | 275 RefactoringProblemSeverity.FATAL, |
267 expectedMessage: "Function type alias name must begin with an uppercase
letter or underscore."); | 276 expectedMessage: |
| 277 "Function type alias name must begin with an uppercase letter or und
erscore."); |
268 } | 278 } |
269 | 279 |
270 void test_validateFunctionTypeAliasName_null() { | 280 void test_validateFunctionTypeAliasName_null() { |
271 assertRefactoringStatus( | 281 assertRefactoringStatus( |
272 validateFunctionTypeAliasName(null), RefactoringProblemSeverity.FATAL, | 282 validateFunctionTypeAliasName(null), RefactoringProblemSeverity.FATAL, |
273 expectedMessage: "Function type alias name must not be null."); | 283 expectedMessage: "Function type alias name must not be null."); |
274 } | 284 } |
275 | 285 |
276 void test_validateFunctionTypeAliasName_OK() { | 286 void test_validateFunctionTypeAliasName_OK() { |
277 assertRefactoringStatusOK(validateFunctionTypeAliasName("NewName")); | 287 assertRefactoringStatusOK(validateFunctionTypeAliasName("NewName")); |
278 } | 288 } |
279 | 289 |
280 void test_validateFunctionTypeAliasName_OK_leadingDollar() { | 290 void test_validateFunctionTypeAliasName_OK_leadingDollar() { |
281 assertRefactoringStatusOK(validateFunctionTypeAliasName("\$NewName")); | 291 assertRefactoringStatusOK(validateFunctionTypeAliasName("\$NewName")); |
282 } | 292 } |
283 | 293 |
284 void test_validateFunctionTypeAliasName_OK_leadingUnderscore() { | 294 void test_validateFunctionTypeAliasName_OK_leadingUnderscore() { |
285 assertRefactoringStatusOK(validateFunctionTypeAliasName("_NewName")); | 295 assertRefactoringStatusOK(validateFunctionTypeAliasName("_NewName")); |
286 } | 296 } |
287 | 297 |
288 void test_validateFunctionTypeAliasName_OK_middleDollar() { | 298 void test_validateFunctionTypeAliasName_OK_middleDollar() { |
289 assertRefactoringStatusOK(validateFunctionTypeAliasName("New\$Name")); | 299 assertRefactoringStatusOK(validateFunctionTypeAliasName("New\$Name")); |
290 } | 300 } |
291 | 301 |
292 void test_validateFunctionTypeAliasName_trailingBlanks() { | 302 void test_validateFunctionTypeAliasName_trailingBlanks() { |
293 assertRefactoringStatus(validateFunctionTypeAliasName("NewName "), | 303 assertRefactoringStatus(validateFunctionTypeAliasName("NewName "), |
294 RefactoringProblemSeverity.FATAL, | 304 RefactoringProblemSeverity.FATAL, |
295 expectedMessage: "Function type alias name must not start or end with a
blank."); | 305 expectedMessage: |
| 306 "Function type alias name must not start or end with a blank."); |
296 } | 307 } |
297 | 308 |
298 void test_validateImportPrefixName_doesNotStartWithLowerCase() { | 309 void test_validateImportPrefixName_doesNotStartWithLowerCase() { |
299 assertRefactoringStatus( | 310 assertRefactoringStatus( |
300 validateImportPrefixName("NewName"), RefactoringProblemSeverity.WARNING, | 311 validateImportPrefixName("NewName"), RefactoringProblemSeverity.WARNING, |
301 expectedMessage: "Import prefix name should start with a lowercase lette
r."); | 312 expectedMessage: |
| 313 "Import prefix name should start with a lowercase letter."); |
302 } | 314 } |
303 | 315 |
304 void test_validateImportPrefixName_empty() { | 316 void test_validateImportPrefixName_empty() { |
305 assertRefactoringStatusOK(validateImportPrefixName("")); | 317 assertRefactoringStatusOK(validateImportPrefixName("")); |
306 } | 318 } |
307 | 319 |
308 void test_validateImportPrefixName_leadingBlanks() { | 320 void test_validateImportPrefixName_leadingBlanks() { |
309 assertRefactoringStatus( | 321 assertRefactoringStatus( |
310 validateImportPrefixName(" newName"), RefactoringProblemSeverity.FATAL, | 322 validateImportPrefixName(" newName"), RefactoringProblemSeverity.FATAL, |
311 expectedMessage: "Import prefix name must not start or end with a blank.
"); | 323 expectedMessage: |
| 324 "Import prefix name must not start or end with a blank."); |
312 } | 325 } |
313 | 326 |
314 void test_validateImportPrefixName_notIdentifierMiddle() { | 327 void test_validateImportPrefixName_notIdentifierMiddle() { |
315 assertRefactoringStatus( | 328 assertRefactoringStatus( |
316 validateImportPrefixName("new-Name"), RefactoringProblemSeverity.FATAL, | 329 validateImportPrefixName("new-Name"), RefactoringProblemSeverity.FATAL, |
317 expectedMessage: "Import prefix name must not contain '-'."); | 330 expectedMessage: "Import prefix name must not contain '-'."); |
318 } | 331 } |
319 | 332 |
320 void test_validateImportPrefixName_notIdentifierStart() { | 333 void test_validateImportPrefixName_notIdentifierStart() { |
321 assertRefactoringStatus( | 334 assertRefactoringStatus( |
322 validateImportPrefixName("2newName"), RefactoringProblemSeverity.FATAL, | 335 validateImportPrefixName("2newName"), RefactoringProblemSeverity.FATAL, |
323 expectedMessage: "Import prefix name must begin with a lowercase letter
or underscore."); | 336 expectedMessage: |
| 337 "Import prefix name must begin with a lowercase letter or underscore
."); |
324 } | 338 } |
325 | 339 |
326 void test_validateImportPrefixName_null() { | 340 void test_validateImportPrefixName_null() { |
327 assertRefactoringStatus( | 341 assertRefactoringStatus( |
328 validateImportPrefixName(null), RefactoringProblemSeverity.FATAL, | 342 validateImportPrefixName(null), RefactoringProblemSeverity.FATAL, |
329 expectedMessage: "Import prefix name must not be null."); | 343 expectedMessage: "Import prefix name must not be null."); |
330 } | 344 } |
331 | 345 |
332 void test_validateImportPrefixName_OK() { | 346 void test_validateImportPrefixName_OK() { |
333 assertRefactoringStatusOK(validateImportPrefixName("newName")); | 347 assertRefactoringStatusOK(validateImportPrefixName("newName")); |
334 } | 348 } |
335 | 349 |
336 void test_validateImportPrefixName_OK_leadingUnderscore() { | 350 void test_validateImportPrefixName_OK_leadingUnderscore() { |
337 assertRefactoringStatusOK(validateImportPrefixName("_newName")); | 351 assertRefactoringStatusOK(validateImportPrefixName("_newName")); |
338 } | 352 } |
339 | 353 |
340 void test_validateImportPrefixName_OK_middleUnderscore() { | 354 void test_validateImportPrefixName_OK_middleUnderscore() { |
341 assertRefactoringStatusOK(validateImportPrefixName("new_name")); | 355 assertRefactoringStatusOK(validateImportPrefixName("new_name")); |
342 } | 356 } |
343 | 357 |
344 void test_validateImportPrefixName_trailingBlanks() { | 358 void test_validateImportPrefixName_trailingBlanks() { |
345 assertRefactoringStatus( | 359 assertRefactoringStatus( |
346 validateImportPrefixName("newName "), RefactoringProblemSeverity.FATAL, | 360 validateImportPrefixName("newName "), RefactoringProblemSeverity.FATAL, |
347 expectedMessage: "Import prefix name must not start or end with a blank.
"); | 361 expectedMessage: |
| 362 "Import prefix name must not start or end with a blank."); |
348 } | 363 } |
349 | 364 |
350 void test_validateLabelName_doesNotStartWithLowerCase() { | 365 void test_validateLabelName_doesNotStartWithLowerCase() { |
351 assertRefactoringStatus( | 366 assertRefactoringStatus( |
352 validateLabelName("NewName"), RefactoringProblemSeverity.WARNING, | 367 validateLabelName("NewName"), RefactoringProblemSeverity.WARNING, |
353 expectedMessage: "Label name should start with a lowercase letter."); | 368 expectedMessage: "Label name should start with a lowercase letter."); |
354 } | 369 } |
355 | 370 |
356 void test_validateLabelName_empty() { | 371 void test_validateLabelName_empty() { |
357 assertRefactoringStatus( | 372 assertRefactoringStatus( |
358 validateLabelName(""), RefactoringProblemSeverity.FATAL, | 373 validateLabelName(""), RefactoringProblemSeverity.FATAL, |
359 expectedMessage: "Label name must not be empty."); | 374 expectedMessage: "Label name must not be empty."); |
360 } | 375 } |
361 | 376 |
362 void test_validateLabelName_leadingBlanks() { | 377 void test_validateLabelName_leadingBlanks() { |
363 assertRefactoringStatus( | 378 assertRefactoringStatus( |
364 validateLabelName(" newName"), RefactoringProblemSeverity.FATAL, | 379 validateLabelName(" newName"), RefactoringProblemSeverity.FATAL, |
365 expectedMessage: "Label name must not start or end with a blank."); | 380 expectedMessage: "Label name must not start or end with a blank."); |
366 } | 381 } |
367 | 382 |
368 void test_validateLabelName_notIdentifierMiddle() { | 383 void test_validateLabelName_notIdentifierMiddle() { |
369 assertRefactoringStatus( | 384 assertRefactoringStatus( |
370 validateLabelName("new-Name"), RefactoringProblemSeverity.FATAL, | 385 validateLabelName("new-Name"), RefactoringProblemSeverity.FATAL, |
371 expectedMessage: "Label name must not contain '-'."); | 386 expectedMessage: "Label name must not contain '-'."); |
372 } | 387 } |
373 | 388 |
374 void test_validateLabelName_notIdentifierStart() { | 389 void test_validateLabelName_notIdentifierStart() { |
375 assertRefactoringStatus( | 390 assertRefactoringStatus( |
376 validateLabelName("2newName"), RefactoringProblemSeverity.FATAL, | 391 validateLabelName("2newName"), RefactoringProblemSeverity.FATAL, |
377 expectedMessage: "Label name must begin with a lowercase letter or under
score."); | 392 expectedMessage: |
| 393 "Label name must begin with a lowercase letter or underscore."); |
378 } | 394 } |
379 | 395 |
380 void test_validateLabelName_null() { | 396 void test_validateLabelName_null() { |
381 assertRefactoringStatus( | 397 assertRefactoringStatus( |
382 validateLabelName(null), RefactoringProblemSeverity.FATAL, | 398 validateLabelName(null), RefactoringProblemSeverity.FATAL, |
383 expectedMessage: "Label name must not be null."); | 399 expectedMessage: "Label name must not be null."); |
384 } | 400 } |
385 | 401 |
386 void test_validateLabelName_OK() { | 402 void test_validateLabelName_OK() { |
387 assertRefactoringStatusOK(validateLabelName("newName")); | 403 assertRefactoringStatusOK(validateLabelName("newName")); |
(...skipping 25 matching lines...) Expand all Loading... |
413 validateLibraryName(" "), RefactoringProblemSeverity.FATAL, | 429 validateLibraryName(" "), RefactoringProblemSeverity.FATAL, |
414 expectedMessage: "Library name must not be blank."); | 430 expectedMessage: "Library name must not be blank."); |
415 } | 431 } |
416 | 432 |
417 void test_validateLibraryName_blank_identifier() { | 433 void test_validateLibraryName_blank_identifier() { |
418 assertRefactoringStatus( | 434 assertRefactoringStatus( |
419 validateLibraryName("my..name"), RefactoringProblemSeverity.FATAL, | 435 validateLibraryName("my..name"), RefactoringProblemSeverity.FATAL, |
420 expectedMessage: "Library name identifier must not be empty."); | 436 expectedMessage: "Library name identifier must not be empty."); |
421 assertRefactoringStatus( | 437 assertRefactoringStatus( |
422 validateLibraryName("my. .name"), RefactoringProblemSeverity.FATAL, | 438 validateLibraryName("my. .name"), RefactoringProblemSeverity.FATAL, |
423 expectedMessage: "Library name identifier must not start or end with a b
lank."); | 439 expectedMessage: |
| 440 "Library name identifier must not start or end with a blank."); |
424 } | 441 } |
425 | 442 |
426 void test_validateLibraryName_hasUpperCase() { | 443 void test_validateLibraryName_hasUpperCase() { |
427 assertRefactoringStatus( | 444 assertRefactoringStatus( |
428 validateLibraryName("my.newName"), RefactoringProblemSeverity.WARNING, | 445 validateLibraryName("my.newName"), RefactoringProblemSeverity.WARNING, |
429 expectedMessage: "Library name should consist of lowercase identifier se
parated by dots."); | 446 expectedMessage: |
| 447 "Library name should consist of lowercase identifier separated by do
ts."); |
430 } | 448 } |
431 | 449 |
432 void test_validateLibraryName_leadingBlanks() { | 450 void test_validateLibraryName_leadingBlanks() { |
433 assertRefactoringStatus( | 451 assertRefactoringStatus( |
434 validateLibraryName("my. name"), RefactoringProblemSeverity.FATAL, | 452 validateLibraryName("my. name"), RefactoringProblemSeverity.FATAL, |
435 expectedMessage: "Library name identifier must not start or end with a b
lank."); | 453 expectedMessage: |
| 454 "Library name identifier must not start or end with a blank."); |
436 } | 455 } |
437 | 456 |
438 void test_validateLibraryName_notIdentifierMiddle() { | 457 void test_validateLibraryName_notIdentifierMiddle() { |
439 assertRefactoringStatus( | 458 assertRefactoringStatus( |
440 validateLibraryName("my.ba-d.name"), RefactoringProblemSeverity.FATAL, | 459 validateLibraryName("my.ba-d.name"), RefactoringProblemSeverity.FATAL, |
441 expectedMessage: "Library name identifier must not contain '-'."); | 460 expectedMessage: "Library name identifier must not contain '-'."); |
442 } | 461 } |
443 | 462 |
444 void test_validateLibraryName_notIdentifierStart() { | 463 void test_validateLibraryName_notIdentifierStart() { |
445 assertRefactoringStatus( | 464 assertRefactoringStatus( |
446 validateLibraryName("my.2bad.name"), RefactoringProblemSeverity.FATAL, | 465 validateLibraryName("my.2bad.name"), RefactoringProblemSeverity.FATAL, |
447 expectedMessage: "Library name identifier must begin with a lowercase le
tter or underscore."); | 466 expectedMessage: |
| 467 "Library name identifier must begin with a lowercase letter or under
score."); |
448 } | 468 } |
449 | 469 |
450 void test_validateLibraryName_null() { | 470 void test_validateLibraryName_null() { |
451 assertRefactoringStatus( | 471 assertRefactoringStatus( |
452 validateLibraryName(null), RefactoringProblemSeverity.FATAL, | 472 validateLibraryName(null), RefactoringProblemSeverity.FATAL, |
453 expectedMessage: "Library name must not be null."); | 473 expectedMessage: "Library name must not be null."); |
454 } | 474 } |
455 | 475 |
456 void test_validateLibraryName_OK_oneIdentifier() { | 476 void test_validateLibraryName_OK_oneIdentifier() { |
457 assertRefactoringStatusOK(validateLibraryName("name")); | 477 assertRefactoringStatusOK(validateLibraryName("name")); |
458 } | 478 } |
459 | 479 |
460 void test_validateLibraryName_OK_severalIdentifiers() { | 480 void test_validateLibraryName_OK_severalIdentifiers() { |
461 assertRefactoringStatusOK(validateLibraryName("my.library.name")); | 481 assertRefactoringStatusOK(validateLibraryName("my.library.name")); |
462 } | 482 } |
463 | 483 |
464 void test_validateLibraryName_trailingBlanks() { | 484 void test_validateLibraryName_trailingBlanks() { |
465 assertRefactoringStatus( | 485 assertRefactoringStatus( |
466 validateLibraryName("my.bad .name"), RefactoringProblemSeverity.FATAL, | 486 validateLibraryName("my.bad .name"), RefactoringProblemSeverity.FATAL, |
467 expectedMessage: "Library name identifier must not start or end with a b
lank."); | 487 expectedMessage: |
| 488 "Library name identifier must not start or end with a blank."); |
468 } | 489 } |
469 | 490 |
470 void test_validateMethodName_doesNotStartWithLowerCase() { | 491 void test_validateMethodName_doesNotStartWithLowerCase() { |
471 assertRefactoringStatus( | 492 assertRefactoringStatus( |
472 validateMethodName("NewName"), RefactoringProblemSeverity.WARNING, | 493 validateMethodName("NewName"), RefactoringProblemSeverity.WARNING, |
473 expectedMessage: "Method name should start with a lowercase letter."); | 494 expectedMessage: "Method name should start with a lowercase letter."); |
474 } | 495 } |
475 | 496 |
476 void test_validateMethodName_empty() { | 497 void test_validateMethodName_empty() { |
477 assertRefactoringStatus( | 498 assertRefactoringStatus( |
(...skipping 15 matching lines...) Expand all Loading... |
493 | 514 |
494 void test_validateMethodName_notIdentifierMiddle() { | 515 void test_validateMethodName_notIdentifierMiddle() { |
495 assertRefactoringStatus( | 516 assertRefactoringStatus( |
496 validateMethodName("new-Name"), RefactoringProblemSeverity.FATAL, | 517 validateMethodName("new-Name"), RefactoringProblemSeverity.FATAL, |
497 expectedMessage: "Method name must not contain '-'."); | 518 expectedMessage: "Method name must not contain '-'."); |
498 } | 519 } |
499 | 520 |
500 void test_validateMethodName_notIdentifierStart() { | 521 void test_validateMethodName_notIdentifierStart() { |
501 assertRefactoringStatus( | 522 assertRefactoringStatus( |
502 validateMethodName("2newName"), RefactoringProblemSeverity.FATAL, | 523 validateMethodName("2newName"), RefactoringProblemSeverity.FATAL, |
503 expectedMessage: "Method name must begin with a lowercase letter or unde
rscore."); | 524 expectedMessage: |
| 525 "Method name must begin with a lowercase letter or underscore."); |
504 } | 526 } |
505 | 527 |
506 void test_validateMethodName_null() { | 528 void test_validateMethodName_null() { |
507 assertRefactoringStatus( | 529 assertRefactoringStatus( |
508 validateMethodName(null), RefactoringProblemSeverity.FATAL, | 530 validateMethodName(null), RefactoringProblemSeverity.FATAL, |
509 expectedMessage: "Method name must not be null."); | 531 expectedMessage: "Method name must not be null."); |
510 } | 532 } |
511 | 533 |
512 void test_validateMethodName_OK() { | 534 void test_validateMethodName_OK() { |
513 assertRefactoringStatusOK(validateMethodName("newName")); | 535 assertRefactoringStatusOK(validateMethodName("newName")); |
514 } | 536 } |
515 | 537 |
516 void test_validateMethodName_OK_leadingUnderscore() { | 538 void test_validateMethodName_OK_leadingUnderscore() { |
517 assertRefactoringStatusOK(validateMethodName("_newName")); | 539 assertRefactoringStatusOK(validateMethodName("_newName")); |
518 } | 540 } |
519 | 541 |
520 void test_validateMethodName_OK_middleUnderscore() { | 542 void test_validateMethodName_OK_middleUnderscore() { |
521 assertRefactoringStatusOK(validateMethodName("new_name")); | 543 assertRefactoringStatusOK(validateMethodName("new_name")); |
522 } | 544 } |
523 | 545 |
524 void test_validateMethodName_trailingBlanks() { | 546 void test_validateMethodName_trailingBlanks() { |
525 assertRefactoringStatus( | 547 assertRefactoringStatus( |
526 validateMethodName("newName "), RefactoringProblemSeverity.FATAL, | 548 validateMethodName("newName "), RefactoringProblemSeverity.FATAL, |
527 expectedMessage: "Method name must not start or end with a blank."); | 549 expectedMessage: "Method name must not start or end with a blank."); |
528 } | 550 } |
529 | 551 |
530 void test_validateParameterName_doesNotStartWithLowerCase() { | 552 void test_validateParameterName_doesNotStartWithLowerCase() { |
531 assertRefactoringStatus( | 553 assertRefactoringStatus( |
532 validateParameterName("NewName"), RefactoringProblemSeverity.WARNING, | 554 validateParameterName("NewName"), RefactoringProblemSeverity.WARNING, |
533 expectedMessage: "Parameter name should start with a lowercase letter.")
; | 555 expectedMessage: |
| 556 "Parameter name should start with a lowercase letter."); |
534 } | 557 } |
535 | 558 |
536 void test_validateParameterName_empty() { | 559 void test_validateParameterName_empty() { |
537 assertRefactoringStatus( | 560 assertRefactoringStatus( |
538 validateParameterName(""), RefactoringProblemSeverity.FATAL, | 561 validateParameterName(""), RefactoringProblemSeverity.FATAL, |
539 expectedMessage: "Parameter name must not be empty."); | 562 expectedMessage: "Parameter name must not be empty."); |
540 } | 563 } |
541 | 564 |
542 void test_validateParameterName_leadingBlanks() { | 565 void test_validateParameterName_leadingBlanks() { |
543 assertRefactoringStatus( | 566 assertRefactoringStatus( |
544 validateParameterName(" newName"), RefactoringProblemSeverity.FATAL, | 567 validateParameterName(" newName"), RefactoringProblemSeverity.FATAL, |
545 expectedMessage: "Parameter name must not start or end with a blank."); | 568 expectedMessage: "Parameter name must not start or end with a blank."); |
546 } | 569 } |
547 | 570 |
548 void test_validateParameterName_notIdentifierMiddle() { | 571 void test_validateParameterName_notIdentifierMiddle() { |
549 assertRefactoringStatus( | 572 assertRefactoringStatus( |
550 validateParameterName("new-Name"), RefactoringProblemSeverity.FATAL, | 573 validateParameterName("new-Name"), RefactoringProblemSeverity.FATAL, |
551 expectedMessage: "Parameter name must not contain '-'."); | 574 expectedMessage: "Parameter name must not contain '-'."); |
552 } | 575 } |
553 | 576 |
554 void test_validateParameterName_notIdentifierStart() { | 577 void test_validateParameterName_notIdentifierStart() { |
555 assertRefactoringStatus( | 578 assertRefactoringStatus( |
556 validateParameterName("2newName"), RefactoringProblemSeverity.FATAL, | 579 validateParameterName("2newName"), RefactoringProblemSeverity.FATAL, |
557 expectedMessage: "Parameter name must begin with a lowercase letter or u
nderscore."); | 580 expectedMessage: |
| 581 "Parameter name must begin with a lowercase letter or underscore."); |
558 } | 582 } |
559 | 583 |
560 void test_validateParameterName_null() { | 584 void test_validateParameterName_null() { |
561 assertRefactoringStatus( | 585 assertRefactoringStatus( |
562 validateParameterName(null), RefactoringProblemSeverity.FATAL, | 586 validateParameterName(null), RefactoringProblemSeverity.FATAL, |
563 expectedMessage: "Parameter name must not be null."); | 587 expectedMessage: "Parameter name must not be null."); |
564 } | 588 } |
565 | 589 |
566 void test_validateParameterName_OK() { | 590 void test_validateParameterName_OK() { |
567 assertRefactoringStatusOK(validateParameterName("newName")); | 591 assertRefactoringStatusOK(validateParameterName("newName")); |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
601 | 625 |
602 void test_validateVariableName_notIdentifierMiddle() { | 626 void test_validateVariableName_notIdentifierMiddle() { |
603 assertRefactoringStatus( | 627 assertRefactoringStatus( |
604 validateVariableName("new-Name"), RefactoringProblemSeverity.FATAL, | 628 validateVariableName("new-Name"), RefactoringProblemSeverity.FATAL, |
605 expectedMessage: "Variable name must not contain '-'."); | 629 expectedMessage: "Variable name must not contain '-'."); |
606 } | 630 } |
607 | 631 |
608 void test_validateVariableName_notIdentifierStart() { | 632 void test_validateVariableName_notIdentifierStart() { |
609 assertRefactoringStatus( | 633 assertRefactoringStatus( |
610 validateVariableName("2newName"), RefactoringProblemSeverity.FATAL, | 634 validateVariableName("2newName"), RefactoringProblemSeverity.FATAL, |
611 expectedMessage: "Variable name must begin with a lowercase letter or un
derscore."); | 635 expectedMessage: |
| 636 "Variable name must begin with a lowercase letter or underscore."); |
612 } | 637 } |
613 | 638 |
614 void test_validateVariableName_null() { | 639 void test_validateVariableName_null() { |
615 assertRefactoringStatus( | 640 assertRefactoringStatus( |
616 validateVariableName(null), RefactoringProblemSeverity.FATAL, | 641 validateVariableName(null), RefactoringProblemSeverity.FATAL, |
617 expectedMessage: "Variable name must not be null."); | 642 expectedMessage: "Variable name must not be null."); |
618 } | 643 } |
619 | 644 |
620 void test_validateVariableName_OK() { | 645 void test_validateVariableName_OK() { |
621 assertRefactoringStatusOK(validateVariableName("newName")); | 646 assertRefactoringStatusOK(validateVariableName("newName")); |
(...skipping 10 matching lines...) Expand all Loading... |
632 void test_validateVariableName_OK_middleUnderscore() { | 657 void test_validateVariableName_OK_middleUnderscore() { |
633 assertRefactoringStatusOK(validateVariableName("new_name")); | 658 assertRefactoringStatusOK(validateVariableName("new_name")); |
634 } | 659 } |
635 | 660 |
636 void test_validateVariableName_trailingBlanks() { | 661 void test_validateVariableName_trailingBlanks() { |
637 assertRefactoringStatus( | 662 assertRefactoringStatus( |
638 validateVariableName("newName "), RefactoringProblemSeverity.FATAL, | 663 validateVariableName("newName "), RefactoringProblemSeverity.FATAL, |
639 expectedMessage: "Variable name must not start or end with a blank."); | 664 expectedMessage: "Variable name must not start or end with a blank."); |
640 } | 665 } |
641 } | 666 } |
OLD | NEW |