View Javadoc
1   ///////////////////////////////////////////////////////////////////////////////////////////////
2   // checkstyle: Checks Java source code and other text files for adherence to a set of rules.
3   // Copyright (C) 2001-2024 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.grammar.javadoc;
21  
22  import static com.google.common.truth.Truth.assertWithMessage;
23  
24  import java.lang.reflect.Field;
25  import java.lang.reflect.Modifier;
26  import java.util.Arrays;
27  
28  import org.junit.jupiter.api.Test;
29  
30  /**
31   * GeneratedJavadocTokenTypesTest.
32   *
33   * @noinspection ClassIndependentOfModule
34   * @noinspectionreason ClassIndependentOfModule - architecture of test modules
35   *      requires this structure
36   */
37  public class GeneratedJavadocTokenTypesTest {
38  
39      private static final String MSG = "Ensure that token numbers generated for the elements"
40              + "present in JavadocParser are consistent with what the tests assert.";
41  
42      /**
43       * This method checks that the numbers generated for tokens in <tt>JavadocLexer.g4</tt> don't
44       * change with the lexer grammar itself.
45       * <br>ANTLR maps all the lexer elements to compile-time constants used internally by ANTLR.
46       * Compatibility damage is incurred <i>(with respect to the previous checkstyle versions)
47       * </i> if these compile-time constants keep changing with the grammar.
48       *
49       * @see "https://github.com/checkstyle/checkstyle/issues/5139"
50       * @see "https://github.com/checkstyle/checkstyle/issues/5186"
51       */
52      @Test
53      public void testTokenNumbers() {
54          assertWithMessage(MSG)
55              .that(JavadocParser.LEADING_ASTERISK)
56              .isEqualTo(1);
57          assertWithMessage(MSG)
58              .that(JavadocParser.HTML_COMMENT_START)
59              .isEqualTo(2);
60          assertWithMessage(MSG)
61              .that(JavadocParser.DEPRECATED_CDATA_DO_NOT_USE)
62              .isEqualTo(3);
63          assertWithMessage(MSG)
64              .that(JavadocParser.WS)
65              .isEqualTo(4);
66          assertWithMessage(MSG)
67              .that(JavadocParser.START)
68              .isEqualTo(5);
69          assertWithMessage(MSG)
70              .that(JavadocParser.NEWLINE)
71              .isEqualTo(6);
72          assertWithMessage(MSG)
73              .that(JavadocParser.AUTHOR_LITERAL)
74              .isEqualTo(7);
75          assertWithMessage(MSG)
76              .that(JavadocParser.DEPRECATED_LITERAL)
77              .isEqualTo(8);
78          assertWithMessage(MSG)
79              .that(JavadocParser.EXCEPTION_LITERAL)
80              .isEqualTo(9);
81          assertWithMessage(MSG)
82              .that(JavadocParser.PARAM_LITERAL)
83              .isEqualTo(10);
84          assertWithMessage(MSG)
85              .that(JavadocParser.RETURN_LITERAL)
86              .isEqualTo(11);
87          assertWithMessage(MSG)
88              .that(JavadocParser.SEE_LITERAL)
89              .isEqualTo(12);
90          assertWithMessage(MSG)
91              .that(JavadocParser.SERIAL_LITERAL)
92              .isEqualTo(13);
93          assertWithMessage(MSG)
94              .that(JavadocParser.SERIAL_FIELD_LITERAL)
95              .isEqualTo(14);
96          assertWithMessage(MSG)
97              .that(JavadocParser.SERIAL_DATA_LITERAL)
98              .isEqualTo(15);
99          assertWithMessage(MSG)
100             .that(JavadocParser.SINCE_LITERAL)
101             .isEqualTo(16);
102         assertWithMessage(MSG)
103             .that(JavadocParser.THROWS_LITERAL)
104             .isEqualTo(17);
105         assertWithMessage(MSG)
106             .that(JavadocParser.VERSION_LITERAL)
107             .isEqualTo(18);
108         assertWithMessage(MSG)
109             .that(JavadocParser.JAVADOC_INLINE_TAG_START)
110             .isEqualTo(19);
111         assertWithMessage(MSG)
112             .that(JavadocParser.JAVADOC_INLINE_TAG_END)
113             .isEqualTo(20);
114         assertWithMessage(MSG)
115             .that(JavadocParser.CUSTOM_NAME)
116             .isEqualTo(21);
117         assertWithMessage(MSG)
118             .that(JavadocParser.LITERAL_INCLUDE)
119             .isEqualTo(22);
120         assertWithMessage(MSG)
121             .that(JavadocParser.LITERAL_EXCLUDE)
122             .isEqualTo(23);
123         assertWithMessage(MSG)
124             .that(JavadocParser.CHAR)
125             .isEqualTo(24);
126         assertWithMessage(MSG)
127             .that(JavadocParser.PARAMETER_NAME)
128             .isEqualTo(25);
129         assertWithMessage(MSG)
130             .that(JavadocParser.Char1)
131             .isEqualTo(26);
132         assertWithMessage(MSG)
133             .that(JavadocParser.STRING)
134             .isEqualTo(27);
135         assertWithMessage(MSG)
136             .that(JavadocParser.PACKAGE_CLASS)
137             .isEqualTo(28);
138         assertWithMessage(MSG)
139             .that(JavadocParser.DOT)
140             .isEqualTo(29);
141         assertWithMessage(MSG)
142             .that(JavadocParser.HASH)
143             .isEqualTo(30);
144         assertWithMessage(MSG)
145             .that(JavadocParser.CLASS)
146             .isEqualTo(31);
147         assertWithMessage(MSG)
148             .that(JavadocParser.Char2)
149             .isEqualTo(32);
150         assertWithMessage(MSG)
151             .that(JavadocParser.MEMBER)
152             .isEqualTo(33);
153         assertWithMessage(MSG)
154             .that(JavadocParser.LEFT_BRACE)
155             .isEqualTo(34);
156         assertWithMessage(MSG)
157             .that(JavadocParser.RIGHT_BRACE)
158             .isEqualTo(35);
159         assertWithMessage(MSG)
160             .that(JavadocParser.ARGUMENT)
161             .isEqualTo(36);
162         assertWithMessage(MSG)
163             .that(JavadocParser.COMMA)
164             .isEqualTo(37);
165         assertWithMessage(MSG)
166             .that(JavadocParser.Char20)
167             .isEqualTo(38);
168         assertWithMessage(MSG)
169             .that(JavadocParser.FIELD_NAME)
170             .isEqualTo(39);
171         assertWithMessage(MSG)
172             .that(JavadocParser.Char3)
173             .isEqualTo(40);
174         assertWithMessage(MSG)
175             .that(JavadocParser.FIELD_TYPE)
176             .isEqualTo(41);
177         assertWithMessage(MSG)
178             .that(JavadocParser.Char4)
179             .isEqualTo(42);
180         assertWithMessage(MSG)
181             .that(JavadocParser.CLASS_NAME)
182             .isEqualTo(43);
183         assertWithMessage(MSG)
184             .that(JavadocParser.Char5)
185             .isEqualTo(44);
186         assertWithMessage(MSG)
187             .that(JavadocParser.CODE_LITERAL)
188             .isEqualTo(45);
189         assertWithMessage(MSG)
190             .that(JavadocParser.DOC_ROOT_LITERAL)
191             .isEqualTo(46);
192         assertWithMessage(MSG)
193             .that(JavadocParser.INHERIT_DOC_LITERAL)
194             .isEqualTo(47);
195         assertWithMessage(MSG)
196             .that(JavadocParser.LINK_LITERAL)
197             .isEqualTo(48);
198         assertWithMessage(MSG)
199             .that(JavadocParser.LINKPLAIN_LITERAL)
200             .isEqualTo(49);
201         assertWithMessage(MSG)
202             .that(JavadocParser.LITERAL_LITERAL)
203             .isEqualTo(50);
204         assertWithMessage(MSG)
205             .that(JavadocParser.VALUE_LITERAL)
206             .isEqualTo(51);
207         assertWithMessage(MSG)
208             .that(JavadocParser.Char7)
209             .isEqualTo(52);
210         assertWithMessage(MSG)
211             .that(JavadocParser.Char8)
212             .isEqualTo(53);
213         assertWithMessage(MSG)
214             .that(JavadocParser.Char10)
215             .isEqualTo(54);
216         assertWithMessage(MSG)
217             .that(JavadocParser.END)
218             .isEqualTo(55);
219         assertWithMessage(MSG)
220             .that(JavadocParser.SLASH_END)
221             .isEqualTo(56);
222         assertWithMessage(MSG)
223             .that(JavadocParser.SLASH)
224             .isEqualTo(57);
225         assertWithMessage(MSG)
226             .that(JavadocParser.EQUALS)
227             .isEqualTo(58);
228         assertWithMessage(MSG)
229             .that(JavadocParser.P_HTML_TAG_NAME)
230             .isEqualTo(59);
231         assertWithMessage(MSG)
232             .that(JavadocParser.LI_HTML_TAG_NAME)
233             .isEqualTo(60);
234         assertWithMessage(MSG)
235             .that(JavadocParser.TR_HTML_TAG_NAME)
236             .isEqualTo(61);
237         assertWithMessage(MSG)
238             .that(JavadocParser.TD_HTML_TAG_NAME)
239             .isEqualTo(62);
240         assertWithMessage(MSG)
241             .that(JavadocParser.TH_HTML_TAG_NAME)
242             .isEqualTo(63);
243         assertWithMessage(MSG)
244             .that(JavadocParser.BODY_HTML_TAG_NAME)
245             .isEqualTo(64);
246         assertWithMessage(MSG)
247             .that(JavadocParser.COLGROUP_HTML_TAG_NAME)
248             .isEqualTo(65);
249         assertWithMessage(MSG)
250             .that(JavadocParser.DD_HTML_TAG_NAME)
251             .isEqualTo(66);
252         assertWithMessage(MSG)
253             .that(JavadocParser.DT_HTML_TAG_NAME)
254             .isEqualTo(67);
255         assertWithMessage(MSG)
256             .that(JavadocParser.HEAD_HTML_TAG_NAME)
257             .isEqualTo(68);
258         assertWithMessage(MSG)
259             .that(JavadocParser.HTML_HTML_TAG_NAME)
260             .isEqualTo(69);
261         assertWithMessage(MSG)
262             .that(JavadocParser.OPTION_HTML_TAG_NAME)
263             .isEqualTo(70);
264         assertWithMessage(MSG)
265             .that(JavadocParser.TBODY_HTML_TAG_NAME)
266             .isEqualTo(71);
267         assertWithMessage(MSG)
268             .that(JavadocParser.TFOOT_HTML_TAG_NAME)
269             .isEqualTo(72);
270         assertWithMessage(MSG)
271             .that(JavadocParser.THEAD_HTML_TAG_NAME)
272             .isEqualTo(73);
273         assertWithMessage(MSG)
274             .that(JavadocParser.AREA_HTML_TAG_NAME)
275             .isEqualTo(74);
276         assertWithMessage(MSG)
277             .that(JavadocParser.BASE_HTML_TAG_NAME)
278             .isEqualTo(75);
279         assertWithMessage(MSG)
280             .that(JavadocParser.BASEFONT_HTML_TAG_NAME)
281             .isEqualTo(76);
282         assertWithMessage(MSG)
283             .that(JavadocParser.BR_HTML_TAG_NAME)
284             .isEqualTo(77);
285         assertWithMessage(MSG)
286             .that(JavadocParser.COL_HTML_TAG_NAME)
287             .isEqualTo(78);
288         assertWithMessage(MSG)
289             .that(JavadocParser.FRAME_HTML_TAG_NAME)
290             .isEqualTo(79);
291         assertWithMessage(MSG)
292             .that(JavadocParser.HR_HTML_TAG_NAME)
293             .isEqualTo(80);
294         assertWithMessage(MSG)
295             .that(JavadocParser.IMG_HTML_TAG_NAME)
296             .isEqualTo(81);
297         assertWithMessage(MSG)
298             .that(JavadocParser.INPUT_HTML_TAG_NAME)
299             .isEqualTo(82);
300         assertWithMessage(MSG)
301             .that(JavadocParser.ISINDEX_HTML_TAG_NAME)
302             .isEqualTo(83);
303         assertWithMessage(MSG)
304             .that(JavadocParser.LINK_HTML_TAG_NAME)
305             .isEqualTo(84);
306         assertWithMessage(MSG)
307             .that(JavadocParser.META_HTML_TAG_NAME)
308             .isEqualTo(85);
309         assertWithMessage(MSG)
310             .that(JavadocParser.PARAM_HTML_TAG_NAME)
311             .isEqualTo(86);
312         assertWithMessage(MSG)
313             .that(JavadocParser.EMBED_HTML_TAG_NAME)
314             .isEqualTo(87);
315         assertWithMessage(MSG)
316             .that(JavadocParser.KEYGEN_HTML_TAG_NAME)
317             .isEqualTo(88);
318         assertWithMessage(MSG)
319             .that(JavadocParser.ATTR_VALUE)
320             .isEqualTo(89);
321         assertWithMessage(MSG)
322             .that(JavadocParser.Char12)
323             .isEqualTo(90);
324         assertWithMessage(MSG)
325             .that(JavadocParser.HTML_COMMENT_END)
326             .isEqualTo(91);
327         assertWithMessage(MSG)
328             .that(JavadocParser.SOURCE_HTML_TAG_NAME)
329             .isEqualTo(92);
330         assertWithMessage(MSG)
331             .that(JavadocParser.TRACK_HTML_TAG_NAME)
332             .isEqualTo(93);
333         assertWithMessage(MSG)
334             .that(JavadocParser.WBR_HTML_TAG_NAME)
335             .isEqualTo(94);
336         assertWithMessage(MSG)
337             .that(JavadocParser.OPTGROUP_HTML_TAG_NAME)
338             .isEqualTo(95);
339         assertWithMessage(MSG)
340             .that(JavadocParser.RB_HTML_TAG_NAME)
341             .isEqualTo(96);
342         assertWithMessage(MSG)
343             .that(JavadocParser.RT_HTML_TAG_NAME)
344             .isEqualTo(97);
345         assertWithMessage(MSG)
346             .that(JavadocParser.RTC_HTML_TAG_NAME)
347             .isEqualTo(98);
348         assertWithMessage(MSG)
349             .that(JavadocParser.RP_HTML_TAG_NAME)
350             .isEqualTo(99);
351         assertWithMessage(MSG)
352             .that(JavadocParser.HTML_TAG_NAME)
353             .isEqualTo(100);
354         assertWithMessage(MSG)
355             .that(JavadocParser.Char11)
356             .isEqualTo(101);
357 
358         final int tokenCount = (int) Arrays.stream(JavadocParser.class.getDeclaredFields())
359                 .filter(GeneratedJavadocTokenTypesTest::isPublicStaticFinalInt)
360                 .filter(field -> !isRule(field))
361                 .count();
362 
363         // Read JavaDoc before changing count below
364         assertWithMessage("all tokens must be added to list in"
365                         + " 'GeneratedJavadocTokenTypesTest' and verified"
366                         + " that their old numbering didn't change")
367             .that(tokenCount)
368             .isEqualTo(101);
369     }
370 
371     /**
372      * This method checks that the numbers generated for rules in <tt>JavadocParser.g4</tt> don't
373      * change with the Parser grammar itself.
374      * <br>ANTLR maps all the parser rules to compile-time constants used internally by ANTLR.
375      * Compatibility damage is incurred <i>(with respect to the previous checkstyle versions)
376      * </i> if these compile-time constants keep changing with the grammar.
377      *
378      * @see "https://github.com/checkstyle/checkstyle/issues/5139"
379      * @see "https://github.com/checkstyle/checkstyle/issues/5186"
380      */
381     @Test
382     public void testRuleNumbers() {
383         assertWithMessage(MSG)
384             .that(JavadocParser.RULE_javadoc)
385             .isEqualTo(0);
386         assertWithMessage(MSG)
387             .that(JavadocParser.RULE_htmlElement)
388             .isEqualTo(1);
389         assertWithMessage(MSG)
390             .that(JavadocParser.RULE_htmlElementStart)
391             .isEqualTo(2);
392         assertWithMessage(MSG)
393             .that(JavadocParser.RULE_htmlElementEnd)
394             .isEqualTo(3);
395         assertWithMessage(MSG)
396             .that(JavadocParser.RULE_attribute)
397             .isEqualTo(4);
398         assertWithMessage(MSG)
399             .that(JavadocParser.RULE_htmlTag)
400             .isEqualTo(5);
401         assertWithMessage(MSG)
402             .that(JavadocParser.RULE_pTagStart)
403             .isEqualTo(6);
404         assertWithMessage(MSG)
405             .that(JavadocParser.RULE_pTagEnd)
406             .isEqualTo(7);
407         assertWithMessage(MSG)
408             .that(JavadocParser.RULE_paragraph)
409             .isEqualTo(8);
410         assertWithMessage(MSG)
411             .that(JavadocParser.RULE_liTagStart)
412             .isEqualTo(9);
413         assertWithMessage(MSG)
414             .that(JavadocParser.RULE_liTagEnd)
415             .isEqualTo(10);
416         assertWithMessage(MSG)
417             .that(JavadocParser.RULE_li)
418             .isEqualTo(11);
419         assertWithMessage(MSG)
420             .that(JavadocParser.RULE_trTagStart)
421             .isEqualTo(12);
422         assertWithMessage(MSG)
423             .that(JavadocParser.RULE_trTagEnd)
424             .isEqualTo(13);
425         assertWithMessage(MSG)
426             .that(JavadocParser.RULE_tr)
427             .isEqualTo(14);
428         assertWithMessage(MSG)
429             .that(JavadocParser.RULE_tdTagStart)
430             .isEqualTo(15);
431         assertWithMessage(MSG)
432             .that(JavadocParser.RULE_tdTagEnd)
433             .isEqualTo(16);
434         assertWithMessage(MSG)
435             .that(JavadocParser.RULE_td)
436             .isEqualTo(17);
437         assertWithMessage(MSG)
438             .that(JavadocParser.RULE_thTagStart)
439             .isEqualTo(18);
440         assertWithMessage(MSG)
441             .that(JavadocParser.RULE_thTagEnd)
442             .isEqualTo(19);
443         assertWithMessage(MSG)
444             .that(JavadocParser.RULE_th)
445             .isEqualTo(20);
446         assertWithMessage(MSG)
447             .that(JavadocParser.RULE_bodyTagStart)
448             .isEqualTo(21);
449         assertWithMessage(MSG)
450             .that(JavadocParser.RULE_bodyTagEnd)
451             .isEqualTo(22);
452         assertWithMessage(MSG)
453             .that(JavadocParser.RULE_body)
454             .isEqualTo(23);
455         assertWithMessage(MSG)
456             .that(JavadocParser.RULE_colgroupTagStart)
457             .isEqualTo(24);
458         assertWithMessage(MSG)
459             .that(JavadocParser.RULE_colgroupTagEnd)
460             .isEqualTo(25);
461         assertWithMessage(MSG)
462             .that(JavadocParser.RULE_colgroup)
463             .isEqualTo(26);
464         assertWithMessage(MSG)
465             .that(JavadocParser.RULE_ddTagStart)
466             .isEqualTo(27);
467         assertWithMessage(MSG)
468             .that(JavadocParser.RULE_ddTagEnd)
469             .isEqualTo(28);
470         assertWithMessage(MSG)
471             .that(JavadocParser.RULE_dd)
472             .isEqualTo(29);
473         assertWithMessage(MSG)
474             .that(JavadocParser.RULE_dtTagStart)
475             .isEqualTo(30);
476         assertWithMessage(MSG)
477             .that(JavadocParser.RULE_dtTagEnd)
478             .isEqualTo(31);
479         assertWithMessage(MSG)
480             .that(JavadocParser.RULE_dt)
481             .isEqualTo(32);
482         assertWithMessage(MSG)
483             .that(JavadocParser.RULE_headTagStart)
484             .isEqualTo(33);
485         assertWithMessage(MSG)
486             .that(JavadocParser.RULE_headTagEnd)
487             .isEqualTo(34);
488         assertWithMessage(MSG)
489             .that(JavadocParser.RULE_head)
490             .isEqualTo(35);
491         assertWithMessage(MSG)
492             .that(JavadocParser.RULE_htmlTagStart)
493             .isEqualTo(36);
494         assertWithMessage(MSG)
495             .that(JavadocParser.RULE_htmlTagEnd)
496             .isEqualTo(37);
497         assertWithMessage(MSG)
498             .that(JavadocParser.RULE_html)
499             .isEqualTo(38);
500         assertWithMessage(MSG)
501             .that(JavadocParser.RULE_optionTagStart)
502             .isEqualTo(39);
503         assertWithMessage(MSG)
504             .that(JavadocParser.RULE_optionTagEnd)
505             .isEqualTo(40);
506         assertWithMessage(MSG)
507             .that(JavadocParser.RULE_option)
508             .isEqualTo(41);
509         assertWithMessage(MSG)
510             .that(JavadocParser.RULE_tbodyTagStart)
511             .isEqualTo(42);
512         assertWithMessage(MSG)
513             .that(JavadocParser.RULE_tbodyTagEnd)
514             .isEqualTo(43);
515         assertWithMessage(MSG)
516             .that(JavadocParser.RULE_tbody)
517             .isEqualTo(44);
518         assertWithMessage(MSG)
519             .that(JavadocParser.RULE_tfootTagStart)
520             .isEqualTo(45);
521         assertWithMessage(MSG)
522             .that(JavadocParser.RULE_tfootTagEnd)
523             .isEqualTo(46);
524         assertWithMessage(MSG)
525             .that(JavadocParser.RULE_tfoot)
526             .isEqualTo(47);
527         assertWithMessage(MSG)
528             .that(JavadocParser.RULE_theadTagStart)
529             .isEqualTo(48);
530         assertWithMessage(MSG)
531             .that(JavadocParser.RULE_theadTagEnd)
532             .isEqualTo(49);
533         assertWithMessage(MSG)
534             .that(JavadocParser.RULE_thead)
535             .isEqualTo(50);
536         assertWithMessage(MSG)
537             .that(JavadocParser.RULE_singletonElement)
538             .isEqualTo(51);
539         assertWithMessage(MSG)
540             .that(JavadocParser.RULE_emptyTag)
541             .isEqualTo(52);
542         assertWithMessage(MSG)
543             .that(JavadocParser.RULE_areaTag)
544             .isEqualTo(53);
545         assertWithMessage(MSG)
546             .that(JavadocParser.RULE_baseTag)
547             .isEqualTo(54);
548         assertWithMessage(MSG)
549             .that(JavadocParser.RULE_basefontTag)
550             .isEqualTo(55);
551         assertWithMessage(MSG)
552             .that(JavadocParser.RULE_brTag)
553             .isEqualTo(56);
554         assertWithMessage(MSG)
555             .that(JavadocParser.RULE_colTag)
556             .isEqualTo(57);
557         assertWithMessage(MSG)
558             .that(JavadocParser.RULE_frameTag)
559             .isEqualTo(58);
560         assertWithMessage(MSG)
561             .that(JavadocParser.RULE_hrTag)
562             .isEqualTo(59);
563         assertWithMessage(MSG)
564             .that(JavadocParser.RULE_imgTag)
565             .isEqualTo(60);
566         assertWithMessage(MSG)
567             .that(JavadocParser.RULE_inputTag)
568             .isEqualTo(61);
569         assertWithMessage(MSG)
570             .that(JavadocParser.RULE_isindexTag)
571             .isEqualTo(62);
572         assertWithMessage(MSG)
573             .that(JavadocParser.RULE_linkTag)
574             .isEqualTo(63);
575         assertWithMessage(MSG)
576             .that(JavadocParser.RULE_metaTag)
577             .isEqualTo(64);
578         assertWithMessage(MSG)
579             .that(JavadocParser.RULE_paramTag)
580             .isEqualTo(65);
581         assertWithMessage(MSG)
582             .that(JavadocParser.RULE_wrongSingletonTag)
583             .isEqualTo(66);
584         assertWithMessage(MSG)
585             .that(JavadocParser.RULE_singletonTagName)
586             .isEqualTo(67);
587         assertWithMessage(MSG)
588             .that(JavadocParser.RULE_description)
589             .isEqualTo(68);
590         assertWithMessage(MSG)
591             .that(JavadocParser.RULE_reference)
592             .isEqualTo(69);
593         assertWithMessage(MSG)
594             .that(JavadocParser.RULE_parameters)
595             .isEqualTo(70);
596         assertWithMessage(MSG)
597             .that(JavadocParser.RULE_javadocTag)
598             .isEqualTo(71);
599         assertWithMessage(MSG)
600             .that(JavadocParser.RULE_javadocInlineTag)
601             .isEqualTo(72);
602         assertWithMessage(MSG)
603             .that(JavadocParser.RULE_htmlComment)
604             .isEqualTo(73);
605         assertWithMessage(MSG)
606             .that(JavadocParser.RULE_text)
607             .isEqualTo(74);
608         assertWithMessage(MSG)
609             .that(JavadocParser.RULE_embedTag)
610             .isEqualTo(75);
611         assertWithMessage(MSG)
612             .that(JavadocParser.RULE_keygenTag)
613             .isEqualTo(76);
614         assertWithMessage(MSG)
615             .that(JavadocParser.RULE_sourceTag)
616             .isEqualTo(77);
617         assertWithMessage(MSG)
618             .that(JavadocParser.RULE_trackTag)
619             .isEqualTo(78);
620         assertWithMessage(MSG)
621             .that(JavadocParser.RULE_wbrTag)
622             .isEqualTo(79);
623         assertWithMessage(MSG)
624             .that(JavadocParser.RULE_optgroupTagStart)
625             .isEqualTo(80);
626         assertWithMessage(MSG)
627             .that(JavadocParser.RULE_optgroupTagEnd)
628             .isEqualTo(81);
629         assertWithMessage(MSG)
630             .that(JavadocParser.RULE_optgroup)
631             .isEqualTo(82);
632         assertWithMessage(MSG)
633             .that(JavadocParser.RULE_rbTagStart)
634             .isEqualTo(83);
635         assertWithMessage(MSG)
636             .that(JavadocParser.RULE_rbTagEnd)
637             .isEqualTo(84);
638         assertWithMessage(MSG)
639             .that(JavadocParser.RULE_rb)
640             .isEqualTo(85);
641         assertWithMessage(MSG)
642             .that(JavadocParser.RULE_rtTagStart)
643             .isEqualTo(86);
644         assertWithMessage(MSG)
645             .that(JavadocParser.RULE_rtTagEnd)
646             .isEqualTo(87);
647         assertWithMessage(MSG)
648             .that(JavadocParser.RULE_rt)
649             .isEqualTo(88);
650         assertWithMessage(MSG)
651             .that(JavadocParser.RULE_rtcTagStart)
652             .isEqualTo(89);
653         assertWithMessage(MSG)
654             .that(JavadocParser.RULE_rtcTagEnd)
655             .isEqualTo(90);
656         assertWithMessage(MSG)
657             .that(JavadocParser.RULE_rtc)
658             .isEqualTo(91);
659         assertWithMessage(MSG)
660             .that(JavadocParser.RULE_rpTagStart)
661             .isEqualTo(92);
662         assertWithMessage(MSG)
663             .that(JavadocParser.RULE_rpTagEnd)
664             .isEqualTo(93);
665         assertWithMessage(MSG)
666             .that(JavadocParser.RULE_rp)
667             .isEqualTo(94);
668 
669         final int tokenCount = (int) Arrays.stream(JavadocParser.class.getDeclaredFields())
670                 .filter(GeneratedJavadocTokenTypesTest::isPublicStaticFinalInt)
671                 .filter(GeneratedJavadocTokenTypesTest::isRule)
672                 .count();
673 
674         // Read JavaDoc before changing count below
675         assertWithMessage("all rules must be added to list in"
676                         + " 'GeneratedJavadocTokenTypesTest' and verified"
677                         + " that their old numbering didn't change")
678             .that(tokenCount)
679             .isEqualTo(95);
680     }
681 
682     /**
683      * Checks that a given field is named 'RULE_'.
684      *
685      * @param field field to verify the name of
686      * @return true if field is named 'RULE_'
687      */
688     private static boolean isRule(Field field) {
689         return field.getName().startsWith("RULE_");
690     }
691 
692     /**
693      * Checks that a given field is 'public static final int'.
694      *
695      * @param field field to verify type and visibility of
696      * @return true if field is declared as 'public static final int'
697      */
698     private static boolean isPublicStaticFinalInt(Field field) {
699         final Class<?> fieldType = field.getType();
700         final int mods = field.getModifiers();
701         return fieldType.equals(Integer.TYPE)
702                 && Modifier.isPublic(mods)
703                 && Modifier.isStatic(mods)
704                 && Modifier.isFinal(mods);
705     }
706 
707 }