View Javadoc
1   ///////////////////////////////////////////////////////////////////////////////////////////////
2   // checkstyle: Checks Java source code and other text files for adherence to a set of rules.
3   // Copyright (C) 2001-2026 the original author or authors.
4   //
5   // This library is free software; you can redistribute it and/or
6   // modify it under the terms of the GNU Lesser General Public
7   // License as published by the Free Software Foundation; either
8   // version 2.1 of the License, or (at your option) any later version.
9   //
10  // This library is distributed in the hope that it will be useful,
11  // but WITHOUT ANY WARRANTY; without even the implied warranty of
12  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  // Lesser General Public License for more details.
14  //
15  // You should have received a copy of the GNU Lesser General Public
16  // License along with this library; if not, write to the Free Software
17  // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  ///////////////////////////////////////////////////////////////////////////////////////////////
19  
20  package com.puppycrawl.tools.checkstyle.checks.naming;
21  
22  import static com.puppycrawl.tools.checkstyle.checks.naming.AbbreviationAsWordInNameCheck.MSG_KEY;
23  
24  import org.junit.jupiter.api.Test;
25  
26  import com.puppycrawl.tools.checkstyle.AbstractModuleTestSupport;
27  import com.puppycrawl.tools.checkstyle.utils.CommonUtil;
28  
29  public class AbbreviationAsWordInNameCheckTest extends AbstractModuleTestSupport {
30  
31      @Override
32      public String getPackageLocation() {
33          return "com/puppycrawl/tools/checkstyle/checks/naming/abbreviationaswordinname";
34      }
35  
36      @Test
37      public void testDefault() throws Exception {
38          final int expectedCapitalCount = 4;
39  
40          final String[] expected = {
41              "25:16: " + getWarningMessage("FactoryWithHARDName", expectedCapitalCount),
42              "29:16: " + getWarningMessage("AbstractCLASSName1", expectedCapitalCount),
43              "50:11: " + getWarningMessage("AbstractINNERSClass", expectedCapitalCount),
44              "56:11: " + getWarningMessage("WellNamedFACTORY", expectedCapitalCount),
45              "58:21: " + getWarningMessage("systematicMETHODName", expectedCapitalCount),
46              "60:21: " + getWarningMessage("systematicVARIABLEName", expectedCapitalCount),
47              "62:21: " + getWarningMessage("SYSTEMATICVariableName", expectedCapitalCount),
48              "81:20: " + getWarningMessage("serialNUMBER", expectedCapitalCount),
49          };
50  
51          verifyWithInlineConfigParser(
52                  getPath("InputAbbreviationAsWordInNameType.java"), expected);
53      }
54  
55      @Test
56      public void testTypeNamesForThreePermittedCapitalLetters() throws Exception {
57          final int expectedCapitalCount = 4;
58  
59          final String[] expected = {
60              "23:16: " + getWarningMessage("FactoryWithHARDName2", expectedCapitalCount),
61              "27:16: " + getWarningMessage("AbstractCLASSName2", expectedCapitalCount),
62              "48:11: " + getWarningMessage("AbstractINNERSClass", expectedCapitalCount),
63              "54:11: " + getWarningMessage("WellNamedFACTORY", expectedCapitalCount),
64          };
65  
66          verifyWithInlineConfigParser(
67                  getPath("InputAbbreviationAsWordInNameType2.java"), expected);
68      }
69  
70      @Test
71      public void testTypeNamesForFourPermittedCapitalLetters() throws Exception {
72          final int expectedCapitalCount = 5;
73  
74          final String[] expected = {
75              "46:11: " + getWarningMessage("AbstractINNERSClass", expectedCapitalCount),
76          };
77  
78          verifyWithInlineConfigParser(
79                  getPath("InputAbbreviationAsWordInNameType3.java"), expected);
80      }
81  
82      @Test
83      public void testTypeNamesForFivePermittedCapitalLetters() throws Exception {
84          final int expectedCapitalCount = 6;
85          final String[] expected = {
86              "46:11: " + getWarningMessage("AbstractINNERSClass", expectedCapitalCount),
87              "52:11: " + getWarningMessage("WellNamedFACTORY", expectedCapitalCount),
88          };
89  
90          verifyWithInlineConfigParser(
91                  getPath("InputAbbreviationAsWordInNameType4.java"), expected);
92      }
93  
94      @Test
95      public void testTypeAndVariablesAndMethodNames() throws Exception {
96          final int expectedCapitalCount = 6;
97  
98          final String[] expected = {
99              "47:11: " + getWarningMessage("AbstractINNERSClass", expectedCapitalCount),
100             "53:11: " + getWarningMessage("WellNamedFACTORY", expectedCapitalCount),
101             "55:21: " + getWarningMessage("systematicMETHODName", expectedCapitalCount),
102             "57:17: " + getWarningMessage("systematicVARIABLEName", expectedCapitalCount),
103             "59:17: " + getWarningMessage("SYSTEMATICVariableName", expectedCapitalCount),
104         };
105 
106         verifyWithInlineConfigParser(
107                 getPath("InputAbbreviationAsWordInNameType5.java"), expected);
108     }
109 
110     @Test
111     public void testTypeAndVariablesAndMethodNamesWithNoIgnores() throws Exception {
112         final int expectedCapitalCount = 6;
113 
114         final String[] expected = {
115             "49:15: " + getWarningMessage("AbstractINNERSClass", expectedCapitalCount),
116             "55:15: " + getWarningMessage("WellNamedFACTORY", expectedCapitalCount),
117             "57:25: " + getWarningMessage("systematicMETHODName", expectedCapitalCount),
118             "86:16: " + getWarningMessage("VALUELONG", expectedCapitalCount),
119             "93:23: " + getWarningMessage("VALUELONG", expectedCapitalCount),
120             "100:22: " + getWarningMessage("VALUELONG", expectedCapitalCount),
121             "107:29: " + getWarningMessage("VALUELONG", expectedCapitalCount),
122         };
123 
124         verifyWithInlineConfigParser(
125                 getPath("InputAbbreviationAsWordInNameNoIgnore.java"), expected);
126     }
127 
128     @Test
129     public void testTypeAndVariablesAndMethodNamesWithNoIgnoresPart2() throws Exception {
130         final int expectedCapitalCount = 6;
131 
132         final String[] expected = {
133             "44:17: " + getWarningMessage("InnerClassOneVIOLATION", expectedCapitalCount),
134             "49:18: " + getWarningMessage("InnerClassTwoVIOLATION", expectedCapitalCount),
135             "54:24: " + getWarningMessage("InnerClassThreeVIOLATION", expectedCapitalCount),
136         };
137         verifyWithInlineConfigParser(
138                 getPath("InputAbbreviationAsWordInNameNoIgnorePart2.java"), expected);
139     }
140 
141     @Test
142     public void testTypeAndVariablesAndMethodNamesWithIgnores() throws Exception {
143         final int expectedCapitalCount = 6;
144 
145         final String[] expected = {
146             "49:15: " + getWarningMessage("AbstractINNERSClass", expectedCapitalCount),
147             "55:15: " + getWarningMessage("WellNamedFACTORY", expectedCapitalCount),
148             "57:25: " + getWarningMessage("systematicMETHODName", expectedCapitalCount),
149         };
150 
151         verifyWithInlineConfigParser(
152                 getPath("InputAbbreviationAsWordInNameIgnore.java"), expected);
153     }
154 
155     @Test
156     public void testTypeAndVariablesAndMethodNamesWithIgnoresPart2() throws Exception {
157         final int expectedCapitalCount = 6;
158 
159         final String[] expected = {
160             "45:17: " + getWarningMessage("InnerClassOneVIOLATION", expectedCapitalCount),
161             "50:18: " + getWarningMessage("InnerClassTwoVIOLATION", expectedCapitalCount),
162             "55:24: " + getWarningMessage("InnerClassThreeVIOLATION", expectedCapitalCount),
163         };
164         verifyWithInlineConfigParser(
165                 getPath("InputAbbreviationAsWordInNameIgnorePart2.java"), expected);
166     }
167 
168     @Test
169     public void testTypeAndVariablesAndMethodNamesWithIgnoresFinal() throws Exception {
170         final int expectedCapitalCount = 5;
171 
172         final String[] expected = {
173             "29:20: " + getWarningMessage("AbstractCLASSName", expectedCapitalCount),
174             "50:15: " + getWarningMessage("AbstractINNERSClass", expectedCapitalCount),
175             "56:15: " + getWarningMessage("WellNamedFACTORY", expectedCapitalCount),
176             "58:25: " + getWarningMessage("systematicMETHODName", expectedCapitalCount),
177             "79:20: "
178                     + getWarningMessage("serialNUMBER", expectedCapitalCount), // not in ignore list
179             "82:28: " + getWarningMessage("s2erialNUMBER",
180                     expectedCapitalCount), // no ignore for static
181         };
182 
183         verifyWithInlineConfigParser(
184                 getPath(
185                 "InputAbbreviationAsWordInNameIgnoreFinal.java"), expected);
186     }
187 
188     @Test
189     public void testTypeAndVariablesAndMethodNamesWithIgnoresStatic() throws Exception {
190         final int expectedCapitalCount = 5;
191 
192         final String[] expected = {
193             "29:20: " + getWarningMessage("AbstractCLASSName", expectedCapitalCount),
194             "50:15: " + getWarningMessage("AbstractINNERSClass", expectedCapitalCount),
195             "56:15: " + getWarningMessage("WellNamedFACTORY", expectedCapitalCount),
196             "58:25: " + getWarningMessage("systematicMETHODName", expectedCapitalCount),
197             "79:20: "
198                 + getWarningMessage("serialNUMBER", expectedCapitalCount), // not in ignore list
199             "81:26: "
200                 + getWarningMessage("s1erialNUMBER", expectedCapitalCount), // no ignore for final
201         };
202 
203         verifyWithInlineConfigParser(
204                 getPath(
205                 "InputAbbreviationAsWordInNameIgnoreStatic.java"), expected);
206     }
207 
208     @Test
209     public void testTypeAndVariablesAndMethodNamesWithIgnoresStaticFinal() throws Exception {
210         final int expectedCapitalCount = 5;
211 
212         final String[] expected = {
213             "29:20: " + getWarningMessage("AbstractCLASSName", expectedCapitalCount),
214             "50:15: " + getWarningMessage("AbstractINNERSClass", expectedCapitalCount),
215             "56:15: " + getWarningMessage("WellNamedFACTORY", expectedCapitalCount),
216             "58:25: " + getWarningMessage("systematicMETHODName", expectedCapitalCount),
217             "79:20: "
218                     + getWarningMessage("serialNUMBER", expectedCapitalCount), // not in ignore list
219             "81:26: " + getWarningMessage("s1erialNUMBER",
220                     expectedCapitalCount), // no ignore for final
221             "83:28: " + getWarningMessage("s2erialNUMBER",
222                     expectedCapitalCount), // no ignore for static
223         };
224 
225         verifyWithInlineConfigParser(
226                 getPath(
227                 "InputAbbreviationAsWordInNameIgnoreStaticFinal.java"), expected);
228     }
229 
230     @Test
231     public void testTypeAndVariablesAndMethodNamesWithIgnoresNonStaticFinal() throws Exception {
232         final int expectedCapitalCount = 5;
233 
234         final String[] expected = {
235             "26:20: " + getWarningMessage("AbstractCLASSName", expectedCapitalCount),
236             "44:15: " + getWarningMessage("AbstractINNERSClass", expectedCapitalCount),
237             "50:15: " + getWarningMessage("WellNamedFACTORY", expectedCapitalCount),
238             "52:25: " + getWarningMessage("systematicMETHODName", expectedCapitalCount),
239             "72:20: "
240                     + getWarningMessage("serialNUMBER", expectedCapitalCount), // not in ignore list
241             "76:34: " // no ignore for static final
242                     + getWarningMessage("s3erialNUMBER", expectedCapitalCount),
243             "81:16: "
244                     + getWarningMessage("VALUELONG", expectedCapitalCount),
245             "86:23: "
246                     + getWarningMessage("VALUELONG", expectedCapitalCount),
247             "91:22: "
248                     + getWarningMessage("VALUELONG", expectedCapitalCount),
249             "96:29: "
250                     + getWarningMessage("VALUELONG", expectedCapitalCount),
251         };
252 
253         verifyWithInlineConfigParser(
254                 getPath(
255                 "InputAbbreviationAsWordInNameIgnoreNonStaticFinal.java"), expected);
256     }
257 
258     @Test
259     public void testTypeAndVariablesAndMethodNamesWithIgnoresNonStaticFinalPart2()
260             throws Exception {
261         final int expectedCapitalCount = 5;
262 
263         final String[] expected = {
264             "29:16: " + getWarningMessage("VALUELONG", expectedCapitalCount),
265             "34:23: " + getWarningMessage("VALUELONG", expectedCapitalCount),
266             "39:22: " + getWarningMessage("VALUELONG", expectedCapitalCount),
267             "44:29: " + getWarningMessage("VALUELONG", expectedCapitalCount),
268             "48:17: " + getWarningMessage("InnerClassOneVIOLATION", expectedCapitalCount),
269             "53:18: " + getWarningMessage("InnerClassTwoVIOLATION", expectedCapitalCount),
270             "58:24: " + getWarningMessage("InnerClassThreeVIOLATION", expectedCapitalCount),
271         };
272         verifyWithInlineConfigParser(
273                 getPath(
274                 "InputAbbreviationAsWordInNameIgnoreNonStaticFinalPart2.java"), expected);
275     }
276 
277     @Test
278     public void testTypeAndVariablesAndMethodNamesWithIgnoresFinalKeepStaticFinal()
279             throws Exception {
280         final int expectedCapitalCount = 5;
281 
282         final String[] expected = {
283             "26:20: " + getWarningMessage("AbstractCLASSName", expectedCapitalCount),
284             "44:15: " + getWarningMessage("AbstractINNERSClass", expectedCapitalCount),
285             "50:15: " + getWarningMessage("WellNamedFACTORY", expectedCapitalCount),
286             "52:25: " + getWarningMessage("systematicMETHODName", expectedCapitalCount),
287             "72:20: "
288                     + getWarningMessage("serialNUMBER", expectedCapitalCount), // not in ignore list
289             "75:28: " + getWarningMessage("s2erialNUMBER",
290                     expectedCapitalCount), // no ignore for static
291             "77:34: " // no ignore for static final
292                     + getWarningMessage("s3erialNUMBER", expectedCapitalCount),
293             "82:16: "
294                     + getWarningMessage("VALUELONG", expectedCapitalCount),
295             "87:23: "
296                     + getWarningMessage("VALUELONG", expectedCapitalCount),
297             "92:22: "
298                     + getWarningMessage("VALUELONG", expectedCapitalCount),
299             "98:29: "
300                     + getWarningMessage("VALUELONG", expectedCapitalCount),
301         };
302 
303         verifyWithInlineConfigParser(
304                 getPath("InputAbbreviationAsWordInNameIgnoreFinalKeepStaticFinal.java"),
305                 expected);
306     }
307 
308     @Test
309     public void testTypeAndVariablesAndMethodNamesWithIgnoresStaticKeepStaticFinal()
310             throws Exception {
311         final int expectedCapitalCount = 5;
312 
313         final String[] expected = {
314             "26:20: " + getWarningMessage("AbstractCLASSName", expectedCapitalCount),
315             "45:15: " + getWarningMessage("AbstractINNERSClass", expectedCapitalCount),
316             "51:15: " + getWarningMessage("WellNamedFACTORY", expectedCapitalCount),
317             "53:25: " + getWarningMessage("systematicMETHODName", expectedCapitalCount),
318             "73:20: "
319                     + getWarningMessage("serialNUMBER", expectedCapitalCount), // not in ignore list
320             "75:26: " + getWarningMessage("s1erialNUMBER",
321                     expectedCapitalCount), // no ignore for final
322             "78:34: " // no ignore for static final
323                     + getWarningMessage("s3erialNUMBER", expectedCapitalCount),
324             "83:16: "
325                     + getWarningMessage("VALUELONG", expectedCapitalCount),
326             "88:23: "
327                     + getWarningMessage("VALUELONG", expectedCapitalCount),
328             "93:22: "
329                     + getWarningMessage("VALUELONG", expectedCapitalCount),
330             "98:29: "
331                     + getWarningMessage("VALUELONG", expectedCapitalCount),
332         };
333 
334         verifyWithInlineConfigParser(
335                 getPath("InputAbbreviationAsWordInNameIgnoreStaticKeepStaticFinal.java"),
336                 expected);
337     }
338 
339     @Test
340     public void testTypeNamesForThreePermittedCapitalLettersWithOverriddenMethod()
341             throws Exception {
342         final int expectedCapitalCount = 4;
343 
344         final String[] expected = {
345             "36:20: " + getWarningMessage("overRIDDENMethod", expectedCapitalCount),
346         };
347 
348         verifyWithInlineConfigParser(
349                 getPath("InputAbbreviationAsWordInNameOverridableMethod.java"), expected);
350     }
351 
352     @Test
353     public void testOverriddenMethod()
354             throws Exception {
355         final int expectedCapitalCount = 4;
356 
357         final String[] expected = {
358             "22:16: " + getWarningMessage("serialNUMBER", expectedCapitalCount),
359             "31:20: " + getWarningMessage("overRIDDENMethod", expectedCapitalCount),
360             "40:20: " + getWarningMessage("overRIDDENMethod", expectedCapitalCount),
361             "53:20: " + getWarningMessage("overRIDDENMethod", expectedCapitalCount),
362         };
363 
364         verifyWithInlineConfigParser(
365                 getPath("InputAbbreviationAsWordInNameOverridableMethod2.java"), expected);
366     }
367 
368     @Test
369     public void testTypeNamesForZeroPermittedCapitalLetter() throws Exception {
370         final int expectedCapitalCount = 1;
371         final String[] expected = {
372             "21:16: " + getWarningMessage("NonAAAAbstractClassName6", expectedCapitalCount),
373             "24:16: " + getWarningMessage("FactoryWithHARDName66", expectedCapitalCount),
374             "27:16: " + getWarningMessage("AbstractCLASSName6", expectedCapitalCount),
375             "45:11: " + getWarningMessage("AbstractINNERSClass", expectedCapitalCount),
376             "51:11: " + getWarningMessage("WellNamedFACTORY", expectedCapitalCount),
377             "53:21: " + getWarningMessage("systematicMETHODName", expectedCapitalCount),
378             "55:17: " + getWarningMessage("systematicVARIABLEName", expectedCapitalCount),
379             "57:17: " + getWarningMessage("SYSTEMATICVariableName", expectedCapitalCount),
380             "64:7: " + getWarningMessage("RIGHT", expectedCapitalCount),
381             "66:7: " + getWarningMessage("LEFT", expectedCapitalCount),
382             "68:7: " + getWarningMessage("UP", expectedCapitalCount),
383             "70:7: " + getWarningMessage("DOWN", expectedCapitalCount),
384             "78:16: " + getWarningMessage("NonAAAAbstractClassName26", expectedCapitalCount),
385             "80:16: " + getWarningMessage("serialNUMBER", expectedCapitalCount),
386             "82:22: " + getWarningMessage("s1erialNUMBER", expectedCapitalCount),
387             "84:24: " + getWarningMessage("s2erialNUMBER", expectedCapitalCount),
388             "86:30: " + getWarningMessage("s3erialNUMBER", expectedCapitalCount),
389             "91:12: " + getWarningMessage("VALUELONG", expectedCapitalCount),
390             "96:19: " + getWarningMessage("VALUELONG", expectedCapitalCount),
391             "101:18: " + getWarningMessage("VALUELONG", expectedCapitalCount),
392             "106:25: " + getWarningMessage("VALUELONG", expectedCapitalCount),
393             "110:7: " + getWarningMessage("FIleNameFormatException6", expectedCapitalCount),
394             "112:31: " + getWarningMessage("serialVersionUID", expectedCapitalCount),
395         };
396         verifyWithInlineConfigParser(
397                 getPath("InputAbbreviationAsWordInNameType6.java"), expected);
398     }
399 
400     @Test
401     public void testTypeNamesForZeroPermittedCapitalLetterPart2()
402             throws Exception {
403         final int expectedCapitalCount = 1;
404 
405         final String[] expected = {
406             "21:9: " + getWarningMessage("userID", expectedCapitalCount),
407             "31:12: " + getWarningMessage("VALUE", expectedCapitalCount),
408             "36:19: " + getWarningMessage("VALUE", expectedCapitalCount),
409             "41:18: " + getWarningMessage("VALUE", expectedCapitalCount),
410             "46:25: " + getWarningMessage("VALUE", expectedCapitalCount),
411         };
412 
413         verifyWithInlineConfigParser(
414                 getPath("InputAbbreviationAsWordInNameType6Part2.java"), expected);
415 
416     }
417 
418     @Test
419     public void testNullPointerException() throws Exception {
420 
421         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
422 
423         verifyWithInlineConfigParser(
424                 getPath("InputAbbreviationAsWordInNameAbstractMultisetSetCount.java"),
425                 expected);
426     }
427 
428     @Test
429     public void testAbbreviationAsWordInNameCheckEnhancedInstanceof()
430             throws Exception {
431 
432         final int expectedCapitalCount = 4;
433 
434         final String[] expected = {
435             "26:36: " + getWarningMessage("STRING", expectedCapitalCount),
436             "28:43: " + getWarningMessage("INTEGER", expectedCapitalCount),
437             "38:41: " + getWarningMessage("ssSTRING", expectedCapitalCount),
438             "42:35: " + getWarningMessage("XMLHTTP", expectedCapitalCount),
439         };
440 
441         verifyWithInlineConfigParser(
442                 getPath(
443                         "InputAbbreviationAsWordInNameCheckEnhancedInstanceof.java"),
444                 expected);
445     }
446 
447     @Test
448     public void testAbbreviationAsWordInNameCheckEnhancedInstanceofAllowXmlLength1()
449             throws Exception {
450 
451         final int expectedCapitalCount = 2;
452 
453         final String[] expected = {
454             "26:36: " + getWarningMessage("STRING", expectedCapitalCount),
455             "28:43: " + getWarningMessage("INTEGER", expectedCapitalCount),
456             "37:39: " + getWarningMessage("aTXT", expectedCapitalCount),
457             "39:41: " + getWarningMessage("ssSTRING", expectedCapitalCount),
458             "43:35: " + getWarningMessage("XMLHTTP", expectedCapitalCount),
459         };
460 
461         verifyWithInlineConfigParser(
462                 getPath(
463                         "InputAbbreviationAsWordInNameCheckEnhanced"
464                                 + "InstanceofAllowXmlLength1.java"),
465                 expected);
466     }
467 
468     @Test
469     public void testAbbreviationAsWordInNameCheckRecords()
470             throws Exception {
471 
472         final int expectedCapitalCount = 4;
473 
474         final String[] expected = {
475             "23:11: " + getWarningMessage("myCLASS", expectedCapitalCount),
476             "25:13: " + getWarningMessage("INTEGER", expectedCapitalCount),
477             "27:14: " + getWarningMessage("METHOD", expectedCapitalCount),
478             "30:31: " + getWarningMessage("STRING", expectedCapitalCount),
479             "32:17: " + getWarningMessage("INTEGER", expectedCapitalCount),
480             "38:12: " + getWarningMessage("myRECORD1", expectedCapitalCount),
481             "38:29: " + getWarningMessage("STRING", expectedCapitalCount),
482             "44:14: " + getWarningMessage("METHOD", expectedCapitalCount),
483             "50:17: " + getWarningMessage("INTEGER", expectedCapitalCount),
484             "56:12: " + getWarningMessage("myRECORD2", expectedCapitalCount),
485             "62:17: " + getWarningMessage("INTEGER", expectedCapitalCount),
486             "66:12: " + getWarningMessage("myRECORD3", expectedCapitalCount),
487             "66:29: " + getWarningMessage("STRING", expectedCapitalCount),
488             "66:41: " + getWarningMessage("INTEGER", expectedCapitalCount),
489             "66:57: " + getWarningMessage("NODES", expectedCapitalCount),
490         };
491 
492         verifyWithInlineConfigParser(
493                 getPath(
494                         "InputAbbreviationAsWordInNameCheckRecords.java"),
495                 expected);
496     }
497 
498     @Test
499     public void testAbbreviationAsWordInNameCheckRecordPatterns()
500             throws Exception {
501 
502         final int expectedCapitalCount = 4;
503 
504         final String[] expected = {
505             "23:39: " + getWarningMessage("POINT", expectedCapitalCount),
506             "27:60: " + getWarningMessage("COLOR", expectedCapitalCount),
507             "31:53: " + getWarningMessage("INTEGER", expectedCapitalCount),
508             "31:71: " + getWarningMessage("STRING", expectedCapitalCount),
509             "39:52: " + getWarningMessage("COLOR", expectedCapitalCount),
510             "40:52: " + getWarningMessage("INTEGER", expectedCapitalCount),
511             "40:68: " + getWarningMessage("COLOR", expectedCapitalCount),
512         };
513 
514         verifyWithInlineConfigParser(
515                 getNonCompilablePath(
516                         "InputAbbreviationAsWordInNameCheckRecordPatterns.java"),
517                 expected);
518     }
519 
520     private String getWarningMessage(String typeName, int expectedCapitalCount) {
521         return getCheckMessage(MSG_KEY, typeName, expectedCapitalCount);
522     }
523 
524     @Test
525     public void testReceiver() throws Exception {
526         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
527 
528         verifyWithInlineConfigParser(
529                 getPath("InputAbbreviationAsWordInNameReceiver.java"),
530                 expected);
531     }
532 
533     @Test
534     public void testInputAbbreviationAsWordInNameTypeSnakeStyle() throws Exception {
535         final String[] expected = {
536             "21:20: " + getWarningMessage("FLAG_IS_FIRST_RUN", 4),
537             "24:17: " + getWarningMessage("HYBRID_LOCK_PATH", 4),
538             "29:17: " + getWarningMessage("__DEMOS__TESTS_VAR", 4),
539             "36:16: " + getWarningMessage("TESTING_FAM_23456", 4),
540             "41:16: " + getWarningMessage("TESTING_23456_FAM", 4),
541             "46:16: " + getWarningMessage("_234VIOLATION", 4),
542             "49:16: " + getWarningMessage("VIOLATION23456", 4),
543             "80:21: " + getWarningMessage("getIsFIRST_Run", 4),
544             "85:21: " + getWarningMessage("getBoolean_VALUES", 4),
545         };
546 
547         verifyWithInlineConfigParser(
548                 getPath("InputAbbreviationAsWordInNameTypeSnakeStyle.java"), expected);
549     }
550 
551     @Test
552     public void testAnnotation() throws Exception {
553         final String[] expected = {
554             "26:12: " + getWarningMessage("readMETHOD", 4),
555         };
556 
557         verifyWithInlineConfigParser(
558                 getPath("InputAbbreviationAsWordInNameAnnotation.java"), expected);
559     }
560 
561     @Test
562     public void testCompactSourceFile() throws Exception {
563         final int expectedCapitalCount = 4;
564 
565         final String[] expected = {
566             "19:5: " + getWarningMessage("useHTTPSConnection", expectedCapitalCount),
567             "25:9: " + getWarningMessage("localHTTPSConnection", expectedCapitalCount),
568         };
569 
570         verifyWithInlineConfigParser(
571                 getNonCompilablePath(
572                         "InputAbbreviationAsWordInNameCompactSourceFile.java"), expected);
573     }
574 
575 }