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.javadoc;
21  
22  import static com.google.common.truth.Truth.assertWithMessage;
23  import static com.puppycrawl.tools.checkstyle.checks.javadoc.MissingJavadocMethodCheck.MSG_JAVADOC_MISSING;
24  
25  import java.nio.file.Path;
26  
27  import org.junit.jupiter.api.Test;
28  
29  import com.puppycrawl.tools.checkstyle.AbstractModuleTestSupport;
30  import com.puppycrawl.tools.checkstyle.api.DetailAST;
31  import com.puppycrawl.tools.checkstyle.api.TokenTypes;
32  import com.puppycrawl.tools.checkstyle.utils.CheckUtilTest;
33  import com.puppycrawl.tools.checkstyle.utils.CommonUtil;
34  
35  public class MissingJavadocMethodCheckTest extends AbstractModuleTestSupport {
36  
37      @Override
38      public String getPackageLocation() {
39          return "com/puppycrawl/tools/checkstyle/checks/javadoc/missingjavadocmethod";
40      }
41  
42      @Test
43      public void testGetAcceptableTokens() {
44          final MissingJavadocMethodCheck missingJavadocMethodCheck = new MissingJavadocMethodCheck();
45  
46          final int[] actual = missingJavadocMethodCheck.getAcceptableTokens();
47          final int[] expected = {
48              TokenTypes.METHOD_DEF,
49              TokenTypes.CTOR_DEF,
50              TokenTypes.ANNOTATION_FIELD_DEF,
51              TokenTypes.COMPACT_CTOR_DEF,
52          };
53  
54          assertWithMessage("Default acceptable tokens are invalid")
55              .that(actual)
56              .isEqualTo(expected);
57      }
58  
59      @Test
60      public void testGetRequiredTokens() {
61          final MissingJavadocMethodCheck missingJavadocMethodCheck = new MissingJavadocMethodCheck();
62          final int[] actual = missingJavadocMethodCheck.getRequiredTokens();
63          final int[] expected = CommonUtil.EMPTY_INT_ARRAY;
64          assertWithMessage("Required tokens are invalid")
65              .that(actual)
66              .isEqualTo(expected);
67      }
68  
69      @Test
70      public void extendAnnotationTest() throws Exception {
71          final String[] expected = {
72              "44:1: " + getCheckMessage(MSG_JAVADOC_MISSING),
73          };
74          verifyWithInlineConfigParser(
75                  getPath("InputMissingJavadocMethodExtendAnnotation.java"), expected);
76      }
77  
78      @Test
79      public void newTest() throws Exception {
80          final String[] expected = {
81              "70:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
82          };
83          verifyWithInlineConfigParser(
84                  getPath("InputMissingJavadocMethodSmallMethods.java"), expected);
85      }
86  
87      @Test
88      public void allowedAnnotationsTest() throws Exception {
89          final String[] expected = {
90              "32:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
91          };
92          verifyWithInlineConfigParser(
93                  getPath("InputMissingJavadocMethodAllowedAnnotations.java"), expected);
94      }
95  
96      @Test
97      public void testTags1() throws Exception {
98          final String[] expected = {
99              "23:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
100         };
101         verifyWithInlineConfigParser(getPath("InputMissingJavadocMethodTags1.java"), expected);
102     }
103 
104     @Test
105     public void testTags2() throws Exception {
106         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
107         verifyWithInlineConfigParser(getPath("InputMissingJavadocMethodTags2.java"), expected);
108     }
109 
110     @Test
111     public void testTags3() throws Exception {
112         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
113         verifyWithInlineConfigParser(getPath("InputMissingJavadocMethodTags3.java"), expected);
114     }
115 
116     @Test
117     public void testTags4() throws Exception {
118         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
119         verifyWithInlineConfigParser(getPath("InputMissingJavadocMethodTags4.java"), expected);
120     }
121 
122     @Test
123     public void testTags5() throws Exception {
124         final String[] expected = {
125             "35:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
126             "44:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
127         };
128         verifyWithInlineConfigParser(getPath("InputMissingJavadocMethodTags5.java"), expected);
129     }
130 
131     @Test
132     public void testStrictJavadoc() throws Exception {
133         final String[] expected = {
134             "24:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
135             "30:13: " + getCheckMessage(MSG_JAVADOC_MISSING),
136             "37:13: " + getCheckMessage(MSG_JAVADOC_MISSING),
137             "50:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
138             "60:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
139             "64:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
140             "68:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
141             "73:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
142             "78:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
143             "82:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
144             "86:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
145             "90:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
146         };
147         verifyWithInlineConfigParser(
148                 getPath("InputMissingJavadocMethodPublicOnly.java"), expected);
149     }
150 
151     @Test
152     public void testNoJavadoc() throws Exception {
153         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
154         verifyWithInlineConfigParser(
155                 getPath("InputMissingJavadocMethodPublicOnly2.java"), expected);
156     }
157 
158     // pre 1.4 relaxed mode is roughly equivalent with check=protected
159     @Test
160     public void testRelaxedJavadoc() throws Exception {
161         final String[] expected = {
162             "65:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
163             "70:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
164             "83:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
165             "87:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
166         };
167         verifyWithInlineConfigParser(
168                 getPath("InputMissingJavadocMethodPublicOnly3.java"), expected);
169     }
170 
171     @Test
172     public void testScopeInnerInterfacesPublic() throws Exception {
173         final String[] expected = {
174             "52:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
175             "53:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
176         };
177         verifyWithInlineConfigParser(
178                 getPath("InputMissingJavadocMethodScopeInnerInterfaces.java"),
179                 expected);
180     }
181 
182     @Test
183     public void testInterfaceMemberScopeIsPublic() throws Exception {
184         final String[] expected = {
185             "22:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
186             "30:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
187         };
188         verifyWithInlineConfigParser(
189                 getPath("InputMissingJavadocMethodInterfaceMemberScopeIsPublic.java"),
190                 expected);
191     }
192 
193     @Test
194     public void testEnumCtorScopeIsPrivate() throws Exception {
195         final String[] expected = {
196             "26:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
197         };
198         verifyWithInlineConfigParser(
199                 getPath("InputMissingJavadocMethodEnumCtorScopeIsPrivate.java"),
200                 expected);
201     }
202 
203     @Test
204     public void testScopeAnonInnerPrivate() throws Exception {
205         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
206         verifyWithInlineConfigParser(
207                 getPath("InputMissingJavadocMethodScopeAnonInner.java"), expected);
208     }
209 
210     @Test
211     public void testScopeAnonInnerAnonInner() throws Exception {
212         final String[] expected = {
213             "34:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
214             "47:13: " + getCheckMessage(MSG_JAVADOC_MISSING),
215             "61:13: " + getCheckMessage(MSG_JAVADOC_MISSING), };
216         verifyWithInlineConfigParser(
217                 getPath("InputMissingJavadocMethodScopeAnonInner2.java"), expected);
218     }
219 
220     @Test
221     public void testScopesA() throws Exception {
222         final String[] expected = {
223             "26:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
224             "27:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
225             "28:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
226             "29:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
227             "37:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
228             "38:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
229             "39:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
230             "40:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
231             "49:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
232             "50:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
233             "51:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
234             "52:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
235             "61:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
236             "62:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
237             "63:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
238             "64:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
239         };
240         verifyWithInlineConfigParser(
241                 getPath("InputMissingJavadocMethodNoJavadocA.java"), expected);
242     }
243 
244     @Test
245     public void testScopesB() throws Exception {
246         final String[] expected = {
247             "25:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
248             "26:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
249             "27:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
250             "28:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
251             "36:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
252             "37:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
253             "38:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
254             "39:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
255             "48:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
256             "49:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
257             "50:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
258             "51:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
259             "60:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
260             "61:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
261             "62:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
262             "63:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
263             "72:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
264             "73:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
265             "74:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
266             "75:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
267             "86:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
268         };
269         verifyWithInlineConfigParser(
270                 getPath("InputMissingJavadocMethodNoJavadocB.java"), expected);
271     }
272 
273     @Test
274     public void testScopes2A() throws Exception {
275         final String[] expected = {
276             "26:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
277             "27:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
278             "37:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
279             "38:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
280         };
281         verifyWithInlineConfigParser(
282                 getPath("InputMissingJavadocMethodNoJavadoc2A.java"), expected);
283     }
284 
285     @Test
286     public void testScopes2B() throws Exception {
287         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
288         verifyWithInlineConfigParser(
289                 getPath("InputMissingJavadocMethodNoJavadoc2B.java"), expected);
290     }
291 
292     @Test
293     public void testExcludeScopeA() throws Exception {
294         final String[] expected = {
295             "27:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
296             "29:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
297             "30:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
298             "50:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
299             "52:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
300             "53:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
301             "62:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
302             "64:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
303             "65:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
304         };
305         verifyWithInlineConfigParser(
306                 getPath("InputMissingJavadocMethodNoJavadoc3A.java"), expected);
307     }
308 
309     @Test
310     public void testExcludeScopeB() throws Exception {
311         final String[] expected = {
312             "26:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
313             "28:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
314             "29:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
315             "37:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
316             "39:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
317             "40:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
318             "49:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
319             "51:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
320             "52:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
321             "61:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
322             "63:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
323             "64:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
324             "73:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
325             "75:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
326             "76:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
327             "87:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
328         };
329         verifyWithInlineConfigParser(
330                 getPath("InputMissingJavadocMethodNoJavadoc3B.java"), expected);
331     }
332 
333     @Test
334     public void testDoAllowMissingJavadocTagsByDefault() throws Exception {
335         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
336         verifyWithInlineConfigParser(
337                 getPath("InputMissingJavadocMethodMissingJavadocTags.java"), expected);
338     }
339 
340     @Test
341     public void testSetterGetterOff() throws Exception {
342         final String[] expected = {
343             "20:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
344             "25:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
345             "30:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
346             "35:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
347             "41:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
348             "45:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
349             "50:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
350             "56:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
351             "61:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
352             "66:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
353             "68:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
354             "72:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
355             "76:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
356             "80:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
357             "82:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
358             "88:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
359             "90:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
360         };
361         verifyWithInlineConfigParser(
362                 getPath("InputMissingJavadocMethodSetterGetter.java"), expected);
363     }
364 
365     @Test
366     public void testSetterGetterOnCheck() throws Exception {
367         final String[] expected = {
368             "30:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
369             "35:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
370             "41:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
371             "45:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
372             "50:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
373             "56:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
374             "66:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
375             "68:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
376             "72:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
377             "76:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
378             "80:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
379             "82:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
380             "88:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
381             "90:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
382         };
383         verifyWithInlineConfigParser(
384                 getPath("InputMissingJavadocMethodSetterGetter2.java"), expected);
385     }
386 
387     @Test
388     public void test11684081() throws Exception {
389         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
390         verifyWithInlineConfigParser(
391                 getPath("InputMissingJavadocMethod_01.java"), expected);
392     }
393 
394     @Test
395     public void test11684082() throws Exception {
396         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
397         verifyWithInlineConfigParser(
398                 getPath("InputMissingJavadocMethod_02.java"), expected);
399     }
400 
401     @Test
402     public void testSkipCertainMethods() throws Exception {
403         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
404         verifyWithInlineConfigParser(
405                 getPath("InputMissingJavadocMethodIgnoreNameRegex.java"), expected);
406     }
407 
408     @Test
409     public void testNotSkipAnythingWhenSkipRegexDoesNotMatch() throws Exception {
410         final String[] expected = {
411             "22:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
412             "26:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
413             "30:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
414         };
415         verifyWithInlineConfigParser(
416                 getPath("InputMissingJavadocMethodIgnoreNameRegex2.java"), expected);
417     }
418 
419     @Test
420     public void testAllowToSkipOverridden() throws Exception {
421         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
422         verifyWithInlineConfigParser(
423                 getPath("InputMissingJavadocMethodsNotSkipWritten.java"), expected);
424     }
425 
426     @Test
427     public void testJava8ReceiverParameter() throws Exception {
428         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
429         verifyWithInlineConfigParser(
430                 getPath("InputMissingJavadocMethodReceiverParameter.java"), expected);
431     }
432 
433     @Test
434     public void testJavadocInMethod() throws Exception {
435         final String[] expected = {
436             "20:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
437             "22:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
438             "25:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
439             "29:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
440         };
441         verifyWithInlineConfigParser(
442                 getPath("InputMissingJavadocMethodJavadocInMethod.java"), expected);
443     }
444 
445     @Test
446     public void testConstructor() throws Exception {
447         final String[] expected = {
448             "21:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
449         };
450         verifyWithInlineConfigParser(
451                 getPath("InputMissingJavadocMethodConstructor.java"), expected);
452     }
453 
454     @Test
455     public void testNotPublicInterfaceMethods() throws Exception {
456         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
457         verifyWithInlineConfigParser(
458                 getPath("InputMissingJavadocMethodInterfacePrivateMethod.java"), expected);
459     }
460 
461     @Test
462     public void testPublicMethods() throws Exception {
463         final String[] expected = {
464             "22:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
465             "25:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
466             "30:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
467             "33:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
468             "38:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
469         };
470         verifyWithInlineConfigParser(
471                 getPath("InputMissingJavadocMethodPublicMethods.java"), expected);
472 
473     }
474 
475     @Test
476     public void testMissingJavadocMethodRecordsAndCompactCtors() throws Exception {
477         final String[] expected = {
478             "22:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
479             "27:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
480             "31:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
481             "38:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
482             "44:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
483             "48:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
484         };
485         verifyWithInlineConfigParser(
486                 getPath("InputMissingJavadocMethodRecordsAndCtors.java"), expected);
487     }
488 
489     @Test
490     public void testMissingJavadocMethodRecordsAndCompactCtorsMinLineCount() throws Exception {
491 
492         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
493 
494         verifyWithInlineConfigParser(
495                 getPath("InputMissingJavadocMethodRecordsAndCtorsMinLineCount.java"),
496             expected);
497     }
498 
499     @Test
500     public void testMinLineCount() throws Exception {
501         final String[] expected = {
502             "14:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
503         };
504         verifyWithInlineConfigParser(
505                 getPath("InputMissingJavadocMethod1.java"),
506                 expected);
507     }
508 
509     @Test
510     public void testAnnotationField() throws Exception {
511         final String[] expected = {
512             "25:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
513             "27:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
514         };
515 
516         verifyWithInlineConfigParser(
517                 getPath("InputMissingJavadocMethodAnnotationField.java"),
518                 expected);
519     }
520 
521     @Test
522     public void testIsGetterMethod() throws Exception {
523         final Path testFile = Path.of(getPath("InputMissingJavadocMethodSetterGetter3.java"));
524         final DetailAST notGetterMethod = CheckUtilTest.getNode(testFile, TokenTypes.METHOD_DEF);
525 
526         final DetailAST getterMethod = notGetterMethod.getNextSibling().getNextSibling();
527 
528         assertWithMessage("Invalid result: AST provided is getter method")
529                 .that(MissingJavadocMethodCheck.isGetterMethod(getterMethod))
530                 .isTrue();
531         assertWithMessage("Invalid result: AST provided is not getter method")
532                 .that(MissingJavadocMethodCheck.isGetterMethod(notGetterMethod))
533                 .isFalse();
534     }
535 
536     @Test
537     public void testIsSetterMethod() throws Exception {
538         final Path testFile = Path.of(getPath("InputMissingJavadocMethodSetterGetter3.java"));
539         final DetailAST firstClassMethod = CheckUtilTest.getNode(testFile, TokenTypes.METHOD_DEF);
540 
541         final DetailAST setterMethod =
542             firstClassMethod.getNextSibling().getNextSibling().getNextSibling();
543         final DetailAST notSetterMethod = setterMethod.getNextSibling();
544 
545         assertWithMessage("Invalid result: AST provided is not setter method")
546                 .that(MissingJavadocMethodCheck.isSetterMethod(setterMethod))
547                 .isTrue();
548         assertWithMessage("Invalid result: AST provided is not setter method")
549                 .that(MissingJavadocMethodCheck.isSetterMethod(notSetterMethod))
550                 .isFalse();
551     }
552 
553     @Test
554     public void testSetterGetterOn() throws Exception {
555         final String[] expected = {
556             "20:5: " + getCheckMessage(MissingJavadocMethodCheck.class,
557                     MSG_JAVADOC_MISSING),
558             "24:5: " + getCheckMessage(MissingJavadocMethodCheck.class,
559                     MSG_JAVADOC_MISSING),
560             "29:5: " + getCheckMessage(MissingJavadocMethodCheck.class,
561                     MSG_JAVADOC_MISSING),
562         };
563         verifyWithInlineConfigParser(
564                 getPath("InputMissingJavadocMethodSetterGetter4.java"), expected);
565     }
566 
567     @Test
568     public void missingJavadoc() throws Exception {
569         final String[] expected = {
570             "13:5: " + getCheckMessage(MissingJavadocMethodCheck.class, MSG_JAVADOC_MISSING),
571         };
572         verifyWithInlineConfigParser(
573                 getPath("InputMissingJavadocMethodBasic.java"), expected);
574     }
575 
576     @Test
577     public void testMissingJavadocMethodAboveComments() throws Exception {
578         final String[] expected = {
579             "18:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
580             "36:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
581         };
582         verifyWithInlineConfigParser(
583                 getPath("InputMissingJavadocMethodAboveComments.java"),
584                 expected);
585     }
586 }