View Javadoc
1   ///////////////////////////////////////////////////////////////////////////////////////////////
2   // checkstyle: Checks Java source code and other text files for adherence to a set of rules.
3   // Copyright (C) 2001-2025 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.io.File;
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      protected 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 testTags() throws Exception {
98          final String[] expected = {
99              "23:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
100             "337:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
101             "346:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
102         };
103 
104         verifyWithInlineConfigParser(
105                 getPath("InputMissingJavadocMethodTags.java"), expected);
106     }
107 
108     @Test
109     public void testStrictJavadoc() throws Exception {
110         final String[] expected = {
111             "24:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
112             "30:13: " + getCheckMessage(MSG_JAVADOC_MISSING),
113             "37:13: " + getCheckMessage(MSG_JAVADOC_MISSING),
114             "50:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
115             "60:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
116             "64:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
117             "68:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
118             "72:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
119             "76:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
120             "80:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
121             "84:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
122             "88:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
123         };
124         verifyWithInlineConfigParser(
125                 getPath("InputMissingJavadocMethodPublicOnly.java"), expected);
126     }
127 
128     @Test
129     public void testNoJavadoc() throws Exception {
130         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
131         verifyWithInlineConfigParser(
132                 getPath("InputMissingJavadocMethodPublicOnly2.java"), expected);
133     }
134 
135     // pre 1.4 relaxed mode is roughly equivalent with check=protected
136     @Test
137     public void testRelaxedJavadoc() throws Exception {
138         final String[] expected = {
139             "65:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
140             "69:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
141             "81:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
142             "85:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
143         };
144         verifyWithInlineConfigParser(
145                 getPath("InputMissingJavadocMethodPublicOnly3.java"), expected);
146     }
147 
148     @Test
149     public void testScopeInnerInterfacesPublic() throws Exception {
150         final String[] expected = {
151             "52:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
152             "53:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
153         };
154         verifyWithInlineConfigParser(
155                 getPath("InputMissingJavadocMethodScopeInnerInterfaces.java"),
156                 expected);
157     }
158 
159     @Test
160     public void testInterfaceMemberScopeIsPublic() throws Exception {
161         final String[] expected = {
162             "22:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
163             "30:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
164         };
165         verifyWithInlineConfigParser(
166                 getPath("InputMissingJavadocMethodInterfaceMemberScopeIsPublic.java"),
167                 expected);
168     }
169 
170     @Test
171     public void testEnumCtorScopeIsPrivate() throws Exception {
172         final String[] expected = {
173             "26:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
174         };
175         verifyWithInlineConfigParser(
176                 getPath("InputMissingJavadocMethodEnumCtorScopeIsPrivate.java"),
177                 expected);
178     }
179 
180     @Test
181     public void testScopeAnonInnerPrivate() throws Exception {
182         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
183         verifyWithInlineConfigParser(
184                 getPath("InputMissingJavadocMethodScopeAnonInner.java"), expected);
185     }
186 
187     @Test
188     public void testScopeAnonInnerAnonInner() throws Exception {
189         final String[] expected = {
190             "34:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
191             "47:13: " + getCheckMessage(MSG_JAVADOC_MISSING),
192             "61:13: " + getCheckMessage(MSG_JAVADOC_MISSING), };
193         verifyWithInlineConfigParser(
194                 getPath("InputMissingJavadocMethodScopeAnonInner2.java"), expected);
195     }
196 
197     @Test
198     public void testScopes() throws Exception {
199         final String[] expected = {
200             "26:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
201             "27:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
202             "28:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
203             "29:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
204             "37:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
205             "38:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
206             "39:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
207             "40:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
208             "49:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
209             "50:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
210             "51:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
211             "52:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
212             "61:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
213             "62:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
214             "63:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
215             "64:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
216             "74:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
217             "75:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
218             "76:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
219             "77:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
220             "85:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
221             "86:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
222             "87:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
223             "88:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
224             "97:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
225             "98:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
226             "99:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
227             "100:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
228             "109:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
229             "110:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
230             "111:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
231             "112:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
232             "121:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
233             "122:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
234             "123:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
235             "124:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
236             "135:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
237         };
238         verifyWithInlineConfigParser(
239                 getPath("InputMissingJavadocMethodNoJavadoc.java"), expected);
240     }
241 
242     @Test
243     public void testScopes2() throws Exception {
244         final String[] expected = {
245             "26:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
246             "27:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
247             "37:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
248             "38:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
249         };
250         verifyWithInlineConfigParser(
251                 getPath("InputMissingJavadocMethodNoJavadoc2.java"), expected);
252     }
253 
254     @Test
255     public void testExcludeScope() throws Exception {
256         final String[] expected = {
257             "27:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
258             "29:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
259             "30:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
260             "50:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
261             "52:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
262             "53:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
263             "62:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
264             "64:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
265             "65:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
266             "75:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
267             "77:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
268             "78:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
269             "86:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
270             "88:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
271             "89:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
272             "98:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
273             "100:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
274             "101:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
275             "110:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
276             "112:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
277             "113:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
278             "122:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
279             "124:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
280             "125:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
281             "136:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
282         };
283         verifyWithInlineConfigParser(
284                 getPath("InputMissingJavadocMethodNoJavadoc3.java"), expected);
285     }
286 
287     @Test
288     public void testDoAllowMissingJavadocTagsByDefault() throws Exception {
289         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
290         verifyWithInlineConfigParser(
291                 getPath("InputMissingJavadocMethodMissingJavadocTags.java"), expected);
292     }
293 
294     @Test
295     public void testSetterGetterOff() throws Exception {
296         final String[] expected = {
297             "20:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
298             "25:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
299             "30:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
300             "35:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
301             "41:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
302             "45:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
303             "50:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
304             "56:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
305             "61:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
306             "66:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
307             "68:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
308             "72:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
309             "76:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
310             "80:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
311             "82:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
312             "87:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
313             "89:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
314         };
315         verifyWithInlineConfigParser(
316                 getPath("InputMissingJavadocMethodSetterGetter.java"), expected);
317     }
318 
319     @Test
320     public void testSetterGetterOnCheck() throws Exception {
321         final String[] expected = {
322             "30:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
323             "35:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
324             "41:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
325             "45:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
326             "50:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
327             "56:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
328             "66:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
329             "68:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
330             "72:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
331             "76:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
332             "80:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
333             "82:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
334             "87:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
335             "89:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
336         };
337         verifyWithInlineConfigParser(
338                 getPath("InputMissingJavadocMethodSetterGetter2.java"), expected);
339     }
340 
341     @Test
342     public void test11684081() throws Exception {
343         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
344         verifyWithInlineConfigParser(
345                 getPath("InputMissingJavadocMethod_01.java"), expected);
346     }
347 
348     @Test
349     public void test11684082() throws Exception {
350         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
351         verifyWithInlineConfigParser(
352                 getPath("InputMissingJavadocMethod_02.java"), expected);
353     }
354 
355     @Test
356     public void testSkipCertainMethods() throws Exception {
357         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
358         verifyWithInlineConfigParser(
359                 getPath("InputMissingJavadocMethodIgnoreNameRegex.java"), expected);
360     }
361 
362     @Test
363     public void testNotSkipAnythingWhenSkipRegexDoesNotMatch() throws Exception {
364         final String[] expected = {
365             "22:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
366             "26:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
367             "30:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
368         };
369         verifyWithInlineConfigParser(
370                 getPath("InputMissingJavadocMethodIgnoreNameRegex2.java"), expected);
371     }
372 
373     @Test
374     public void testAllowToSkipOverridden() throws Exception {
375         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
376         verifyWithInlineConfigParser(
377                 getPath("InputMissingJavadocMethodsNotSkipWritten.java"), expected);
378     }
379 
380     @Test
381     public void testJava8ReceiverParameter() throws Exception {
382         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
383         verifyWithInlineConfigParser(
384                 getPath("InputMissingJavadocMethodReceiverParameter.java"), expected);
385     }
386 
387     @Test
388     public void testJavadocInMethod() throws Exception {
389         final String[] expected = {
390             "20:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
391             "22:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
392             "25:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
393             "29:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
394         };
395         verifyWithInlineConfigParser(
396                 getPath("InputMissingJavadocMethodJavadocInMethod.java"), expected);
397     }
398 
399     @Test
400     public void testConstructor() throws Exception {
401         final String[] expected = {
402             "21:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
403         };
404         verifyWithInlineConfigParser(
405                 getPath("InputMissingJavadocMethodConstructor.java"), expected);
406     }
407 
408     @Test
409     public void testNotPublicInterfaceMethods() throws Exception {
410         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
411         verifyWithInlineConfigParser(
412                 getPath("InputMissingJavadocMethodInterfacePrivateMethod.java"), expected);
413     }
414 
415     @Test
416     public void testPublicMethods() throws Exception {
417         final String[] expected = {
418             "22:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
419             "24:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
420             "28:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
421             "31:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
422             "35:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
423         };
424         verifyWithInlineConfigParser(
425                 getPath("InputMissingJavadocMethodPublicMethods.java"), expected);
426 
427     }
428 
429     @Test
430     public void testMissingJavadocMethodRecordsAndCompactCtors() throws Exception {
431         final String[] expected = {
432             "22:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
433             "27:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
434             "31:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
435             "38:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
436             "44:9: " + getCheckMessage(MSG_JAVADOC_MISSING),
437             "48:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
438         };
439         verifyWithInlineConfigParser(
440                 getNonCompilablePath("InputMissingJavadocMethodRecordsAndCtors.java"), expected);
441     }
442 
443     @Test
444     public void testMissingJavadocMethodRecordsAndCompactCtorsMinLineCount() throws Exception {
445 
446         final String[] expected = CommonUtil.EMPTY_STRING_ARRAY;
447 
448         verifyWithInlineConfigParser(
449                 getNonCompilablePath("InputMissingJavadocMethodRecordsAndCtorsMinLineCount.java"),
450             expected);
451     }
452 
453     @Test
454     public void testMinLineCount() throws Exception {
455         final String[] expected = {
456             "14:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
457         };
458         verifyWithInlineConfigParser(
459                 getNonCompilablePath("InputMissingJavadocMethod1.java"),
460                 expected);
461     }
462 
463     @Test
464     public void testAnnotationField() throws Exception {
465         final String[] expected = {
466             "25:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
467             "27:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
468         };
469 
470         verifyWithInlineConfigParser(
471                 getPath("InputMissingJavadocMethodAnnotationField.java"),
472                 expected);
473     }
474 
475     @Test
476     public void testIsGetterMethod() throws Exception {
477         final File testFile =
478                 new File(getPath("InputMissingJavadocMethodSetterGetter3.java"));
479         final DetailAST notGetterMethod =
480                 CheckUtilTest.getNode(testFile, TokenTypes.METHOD_DEF);
481         final DetailAST getterMethod = notGetterMethod.getNextSibling().getNextSibling();
482 
483         assertWithMessage("Invalid result: AST provided is getter method")
484                 .that(MissingJavadocMethodCheck.isGetterMethod(getterMethod))
485                 .isTrue();
486         assertWithMessage("Invalid result: AST provided is not getter method")
487                 .that(MissingJavadocMethodCheck.isGetterMethod(notGetterMethod))
488                 .isFalse();
489     }
490 
491     @Test
492     public void testIsSetterMethod() throws Exception {
493         final File testFile =
494             new File(getPath("InputMissingJavadocMethodSetterGetter3.java"));
495         final DetailAST firstClassMethod =
496             CheckUtilTest.getNode(testFile, TokenTypes.METHOD_DEF);
497         final DetailAST setterMethod =
498             firstClassMethod.getNextSibling().getNextSibling().getNextSibling();
499         final DetailAST notSetterMethod = setterMethod.getNextSibling();
500 
501         assertWithMessage("Invalid result: AST provided is not setter method")
502                 .that(MissingJavadocMethodCheck.isSetterMethod(setterMethod))
503                 .isTrue();
504         assertWithMessage("Invalid result: AST provided is not setter method")
505                 .that(MissingJavadocMethodCheck.isSetterMethod(notSetterMethod))
506                 .isFalse();
507     }
508 
509     @Test
510     public void testSetterGetterOn() throws Exception {
511         final String[] expected = {
512             "20:5: " + getCheckMessage(MissingJavadocMethodCheck.class,
513                     MSG_JAVADOC_MISSING),
514             "24:5: " + getCheckMessage(MissingJavadocMethodCheck.class,
515                     MSG_JAVADOC_MISSING),
516             "29:5: " + getCheckMessage(MissingJavadocMethodCheck.class,
517                     MSG_JAVADOC_MISSING),
518         };
519         verifyWithInlineConfigParser(
520                 getPath("InputMissingJavadocMethodSetterGetter4.java"), expected);
521     }
522 
523     @Test
524     public void missingJavadoc() throws Exception {
525         final String[] expected = {
526             "13:5: " + getCheckMessage(MissingJavadocMethodCheck.class, MSG_JAVADOC_MISSING),
527         };
528         verifyWithInlineConfigParser(
529                 getNonCompilablePath("InputMissingJavadocMethodBasic.java"), expected);
530     }
531 
532     @Test
533     public void testMissingJavadocMethodAboveComments() throws Exception {
534         final String[] expected = {
535             "18:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
536             "36:5: " + getCheckMessage(MSG_JAVADOC_MISSING),
537         };
538         verifyWithInlineConfigParser(
539                 getPath("InputMissingJavadocMethodAboveComments.java"),
540                 expected);
541     }
542 }