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;
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  import java.util.Collections;
28  import java.util.List;
29  import java.util.Objects;
30  import java.util.Set;
31  import java.util.stream.Collectors;
32  
33  import org.antlr.v4.runtime.VocabularyImpl;
34  import org.junit.jupiter.api.Test;
35  
36  import com.puppycrawl.tools.checkstyle.grammar.java.JavaLanguageLexer;
37  
38  /**
39   * GeneratedJavaTokenTypesTest.
40   *
41   * @noinspection ClassIndependentOfModule
42   * @noinspectionreason ClassIndependentOfModule - architecture of test modules
43   *      requires this structure
44   */
45  public class GeneratedJavaTokenTypesTest {
46  
47      /**
48       * The following tokens are not declared in the lexer's 'tokens' block,
49       * they will always appear last in the list of symbolic names provided
50       * by the vocabulary. They are not part of the public API and are only
51       * used as components of parser rules.
52       */
53      private static final List<String> INTERNAL_TOKENS = List.of(
54              "DECIMAL_LITERAL_LONG",
55              "DECIMAL_LITERAL",
56              "HEX_LITERAL_LONG",
57              "HEX_LITERAL",
58              "OCT_LITERAL_LONG",
59              "OCT_LITERAL",
60              "BINARY_LITERAL_LONG",
61              "BINARY_LITERAL"
62      );
63  
64      /**
65       * <p>
66       * New tokens must be added onto the end of the list with new numbers, and
67       * old tokens must remain and keep their current numbering. Old token
68       * numberings are not allowed to change.
69       * </p>
70       *
71       * <p>
72       * The reason behind this is Java inlines static final field values directly
73       * into the compiled Java code. This loses all connections with the original
74       * class, JavaLanguageLexer, and so numbering updates are not picked
75       * up in user-created checks and causes conflicts.
76       * </p>
77       *
78       * <p>
79       * Issue: <a href="https://github.com/checkstyle/checkstyle/issues/505">#505</a>
80       * </p>
81       */
82      @Test
83      public void testTokenNumbering() {
84          final String message = "A token's number has changed. Please open"
85                  + " 'GeneratedJavaTokenTypesTest' and confirm which token is at fault.\n"
86                  + "Token numbers must not change or else they will create a conflict"
87                  + " with users.\n\n"
88                  + "See Issue: https://github.com/checkstyle/checkstyle/issues/505";
89  
90          // Read JavaDoc before changing
91          assertWithMessage(message)
92              .that(JavaLanguageLexer.COMPILATION_UNIT)
93              .isEqualTo(1);
94          assertWithMessage(message)
95              .that(JavaLanguageLexer.PLACEHOLDER1)
96              .isEqualTo(2);
97          assertWithMessage(message)
98              .that(JavaLanguageLexer.NULL_TREE_LOOKAHEAD)
99              .isEqualTo(3);
100         assertWithMessage(message)
101             .that(JavaLanguageLexer.BLOCK)
102             .isEqualTo(4);
103         assertWithMessage(message)
104             .that(JavaLanguageLexer.MODIFIERS)
105             .isEqualTo(5);
106         assertWithMessage(message)
107             .that(JavaLanguageLexer.OBJBLOCK)
108             .isEqualTo(6);
109         assertWithMessage(message)
110             .that(JavaLanguageLexer.SLIST)
111             .isEqualTo(7);
112         assertWithMessage(message)
113             .that(JavaLanguageLexer.CTOR_DEF)
114             .isEqualTo(8);
115         assertWithMessage(message)
116             .that(JavaLanguageLexer.METHOD_DEF)
117             .isEqualTo(9);
118         assertWithMessage(message)
119             .that(JavaLanguageLexer.VARIABLE_DEF)
120             .isEqualTo(10);
121         assertWithMessage(message)
122             .that(JavaLanguageLexer.INSTANCE_INIT)
123             .isEqualTo(11);
124         assertWithMessage(message)
125             .that(JavaLanguageLexer.STATIC_INIT)
126             .isEqualTo(12);
127         assertWithMessage(message)
128             .that(JavaLanguageLexer.TYPE)
129             .isEqualTo(13);
130         assertWithMessage(message)
131             .that(JavaLanguageLexer.CLASS_DEF)
132             .isEqualTo(14);
133         assertWithMessage(message)
134             .that(JavaLanguageLexer.INTERFACE_DEF)
135             .isEqualTo(15);
136         assertWithMessage(message)
137             .that(JavaLanguageLexer.PACKAGE_DEF)
138             .isEqualTo(16);
139         assertWithMessage(message)
140             .that(JavaLanguageLexer.ARRAY_DECLARATOR)
141             .isEqualTo(17);
142         assertWithMessage(message)
143             .that(JavaLanguageLexer.EXTENDS_CLAUSE)
144             .isEqualTo(18);
145         assertWithMessage(message)
146             .that(JavaLanguageLexer.IMPLEMENTS_CLAUSE)
147             .isEqualTo(19);
148         assertWithMessage(message)
149             .that(JavaLanguageLexer.PARAMETERS)
150             .isEqualTo(20);
151         assertWithMessage(message)
152             .that(JavaLanguageLexer.PARAMETER_DEF)
153             .isEqualTo(21);
154         assertWithMessage(message)
155             .that(JavaLanguageLexer.LABELED_STAT)
156             .isEqualTo(22);
157         assertWithMessage(message)
158             .that(JavaLanguageLexer.TYPECAST)
159             .isEqualTo(23);
160         assertWithMessage(message)
161             .that(JavaLanguageLexer.INDEX_OP)
162             .isEqualTo(24);
163         assertWithMessage(message)
164             .that(JavaLanguageLexer.POST_INC)
165             .isEqualTo(25);
166         assertWithMessage(message)
167             .that(JavaLanguageLexer.POST_DEC)
168             .isEqualTo(26);
169         assertWithMessage(message)
170             .that(JavaLanguageLexer.METHOD_CALL)
171             .isEqualTo(27);
172         assertWithMessage(message)
173             .that(JavaLanguageLexer.EXPR)
174             .isEqualTo(28);
175         assertWithMessage(message)
176             .that(JavaLanguageLexer.ARRAY_INIT)
177             .isEqualTo(29);
178         assertWithMessage(message)
179             .that(JavaLanguageLexer.IMPORT)
180             .isEqualTo(30);
181         assertWithMessage(message)
182             .that(JavaLanguageLexer.UNARY_MINUS)
183             .isEqualTo(31);
184         assertWithMessage(message)
185             .that(JavaLanguageLexer.UNARY_PLUS)
186             .isEqualTo(32);
187         assertWithMessage(message)
188             .that(JavaLanguageLexer.CASE_GROUP)
189             .isEqualTo(33);
190         assertWithMessage(message)
191             .that(JavaLanguageLexer.ELIST)
192             .isEqualTo(34);
193         assertWithMessage(message)
194             .that(JavaLanguageLexer.FOR_INIT)
195             .isEqualTo(35);
196         assertWithMessage(message)
197             .that(JavaLanguageLexer.FOR_CONDITION)
198             .isEqualTo(36);
199         assertWithMessage(message)
200             .that(JavaLanguageLexer.FOR_ITERATOR)
201             .isEqualTo(37);
202         assertWithMessage(message)
203             .that(JavaLanguageLexer.EMPTY_STAT)
204             .isEqualTo(38);
205         assertWithMessage(message)
206             .that(JavaLanguageLexer.FINAL)
207             .isEqualTo(39);
208         assertWithMessage(message)
209             .that(JavaLanguageLexer.ABSTRACT)
210             .isEqualTo(40);
211         assertWithMessage(message)
212             .that(JavaLanguageLexer.STRICTFP)
213             .isEqualTo(41);
214         assertWithMessage(message)
215             .that(JavaLanguageLexer.SUPER_CTOR_CALL)
216             .isEqualTo(42);
217         assertWithMessage(message)
218             .that(JavaLanguageLexer.CTOR_CALL)
219             .isEqualTo(43);
220         assertWithMessage(message)
221             .that(JavaLanguageLexer.LITERAL_PACKAGE)
222             .isEqualTo(44);
223         assertWithMessage(message)
224             .that(JavaLanguageLexer.SEMI)
225             .isEqualTo(45);
226         assertWithMessage(message)
227             .that(JavaLanguageLexer.LITERAL_IMPORT)
228             .isEqualTo(46);
229         assertWithMessage(message)
230             .that(JavaLanguageLexer.LBRACK)
231             .isEqualTo(47);
232         assertWithMessage(message)
233             .that(JavaLanguageLexer.RBRACK)
234             .isEqualTo(48);
235         assertWithMessage(message)
236             .that(JavaLanguageLexer.LITERAL_VOID)
237             .isEqualTo(49);
238         assertWithMessage(message)
239             .that(JavaLanguageLexer.LITERAL_BOOLEAN)
240             .isEqualTo(50);
241         assertWithMessage(message)
242             .that(JavaLanguageLexer.LITERAL_BYTE)
243             .isEqualTo(51);
244         assertWithMessage(message)
245             .that(JavaLanguageLexer.LITERAL_CHAR)
246             .isEqualTo(52);
247         assertWithMessage(message)
248             .that(JavaLanguageLexer.LITERAL_SHORT)
249             .isEqualTo(53);
250         assertWithMessage(message)
251             .that(JavaLanguageLexer.LITERAL_INT)
252             .isEqualTo(54);
253         assertWithMessage(message)
254             .that(JavaLanguageLexer.LITERAL_FLOAT)
255             .isEqualTo(55);
256         assertWithMessage(message)
257             .that(JavaLanguageLexer.LITERAL_LONG)
258             .isEqualTo(56);
259         assertWithMessage(message)
260             .that(JavaLanguageLexer.LITERAL_DOUBLE)
261             .isEqualTo(57);
262         assertWithMessage(message)
263             .that(JavaLanguageLexer.IDENT)
264             .isEqualTo(58);
265         assertWithMessage(message)
266             .that(JavaLanguageLexer.DOT)
267             .isEqualTo(59);
268         assertWithMessage(message)
269             .that(JavaLanguageLexer.STAR)
270             .isEqualTo(60);
271         assertWithMessage(message)
272             .that(JavaLanguageLexer.LITERAL_PRIVATE)
273             .isEqualTo(61);
274         assertWithMessage(message)
275             .that(JavaLanguageLexer.LITERAL_PUBLIC)
276             .isEqualTo(62);
277         assertWithMessage(message)
278             .that(JavaLanguageLexer.LITERAL_PROTECTED)
279             .isEqualTo(63);
280         assertWithMessage(message)
281             .that(JavaLanguageLexer.LITERAL_STATIC)
282             .isEqualTo(64);
283         assertWithMessage(message)
284             .that(JavaLanguageLexer.LITERAL_TRANSIENT)
285             .isEqualTo(65);
286         assertWithMessage(message)
287             .that(JavaLanguageLexer.LITERAL_NATIVE)
288             .isEqualTo(66);
289         assertWithMessage(message)
290             .that(JavaLanguageLexer.LITERAL_SYNCHRONIZED)
291             .isEqualTo(67);
292         assertWithMessage(message)
293             .that(JavaLanguageLexer.LITERAL_VOLATILE)
294             .isEqualTo(68);
295         assertWithMessage(message)
296             .that(JavaLanguageLexer.LITERAL_CLASS)
297             .isEqualTo(69);
298         assertWithMessage(message)
299             .that(JavaLanguageLexer.LITERAL_EXTENDS)
300             .isEqualTo(70);
301         assertWithMessage(message)
302             .that(JavaLanguageLexer.LITERAL_INTERFACE)
303             .isEqualTo(71);
304         assertWithMessage(message)
305             .that(JavaLanguageLexer.LCURLY)
306             .isEqualTo(72);
307         assertWithMessage(message)
308             .that(JavaLanguageLexer.RCURLY)
309             .isEqualTo(73);
310         assertWithMessage(message)
311             .that(JavaLanguageLexer.COMMA)
312             .isEqualTo(74);
313         assertWithMessage(message)
314             .that(JavaLanguageLexer.LITERAL_IMPLEMENTS)
315             .isEqualTo(75);
316         assertWithMessage(message)
317             .that(JavaLanguageLexer.LPAREN)
318             .isEqualTo(76);
319         assertWithMessage(message)
320             .that(JavaLanguageLexer.RPAREN)
321             .isEqualTo(77);
322         assertWithMessage(message)
323             .that(JavaLanguageLexer.LITERAL_THIS)
324             .isEqualTo(78);
325         assertWithMessage(message)
326             .that(JavaLanguageLexer.LITERAL_SUPER)
327             .isEqualTo(79);
328         assertWithMessage(message)
329             .that(JavaLanguageLexer.ASSIGN)
330             .isEqualTo(80);
331         assertWithMessage(message)
332             .that(JavaLanguageLexer.LITERAL_THROWS)
333             .isEqualTo(81);
334         assertWithMessage(message)
335             .that(JavaLanguageLexer.COLON)
336             .isEqualTo(82);
337         assertWithMessage(message)
338             .that(JavaLanguageLexer.LITERAL_IF)
339             .isEqualTo(83);
340         assertWithMessage(message)
341             .that(JavaLanguageLexer.LITERAL_WHILE)
342             .isEqualTo(84);
343         assertWithMessage(message)
344             .that(JavaLanguageLexer.LITERAL_DO)
345             .isEqualTo(85);
346         assertWithMessage(message)
347             .that(JavaLanguageLexer.LITERAL_BREAK)
348             .isEqualTo(86);
349         assertWithMessage(message)
350             .that(JavaLanguageLexer.LITERAL_CONTINUE)
351             .isEqualTo(87);
352         assertWithMessage(message)
353             .that(JavaLanguageLexer.LITERAL_RETURN)
354             .isEqualTo(88);
355         assertWithMessage(message)
356             .that(JavaLanguageLexer.LITERAL_SWITCH)
357             .isEqualTo(89);
358         assertWithMessage(message)
359             .that(JavaLanguageLexer.LITERAL_THROW)
360             .isEqualTo(90);
361         assertWithMessage(message)
362             .that(JavaLanguageLexer.LITERAL_FOR)
363             .isEqualTo(91);
364         assertWithMessage(message)
365             .that(JavaLanguageLexer.LITERAL_ELSE)
366             .isEqualTo(92);
367         assertWithMessage(message)
368             .that(JavaLanguageLexer.LITERAL_CASE)
369             .isEqualTo(93);
370         assertWithMessage(message)
371             .that(JavaLanguageLexer.LITERAL_DEFAULT)
372             .isEqualTo(94);
373         assertWithMessage(message)
374             .that(JavaLanguageLexer.LITERAL_TRY)
375             .isEqualTo(95);
376         assertWithMessage(message)
377             .that(JavaLanguageLexer.LITERAL_CATCH)
378             .isEqualTo(96);
379         assertWithMessage(message)
380             .that(JavaLanguageLexer.LITERAL_FINALLY)
381             .isEqualTo(97);
382         assertWithMessage(message)
383             .that(JavaLanguageLexer.PLUS_ASSIGN)
384             .isEqualTo(98);
385         assertWithMessage(message)
386             .that(JavaLanguageLexer.MINUS_ASSIGN)
387             .isEqualTo(99);
388         assertWithMessage(message)
389             .that(JavaLanguageLexer.STAR_ASSIGN)
390             .isEqualTo(100);
391         assertWithMessage(message)
392             .that(JavaLanguageLexer.DIV_ASSIGN)
393             .isEqualTo(101);
394         assertWithMessage(message)
395             .that(JavaLanguageLexer.MOD_ASSIGN)
396             .isEqualTo(102);
397         assertWithMessage(message)
398             .that(JavaLanguageLexer.SR_ASSIGN)
399             .isEqualTo(103);
400         assertWithMessage(message)
401             .that(JavaLanguageLexer.BSR_ASSIGN)
402             .isEqualTo(104);
403         assertWithMessage(message)
404             .that(JavaLanguageLexer.SL_ASSIGN)
405             .isEqualTo(105);
406         assertWithMessage(message)
407             .that(JavaLanguageLexer.BAND_ASSIGN)
408             .isEqualTo(106);
409         assertWithMessage(message)
410             .that(JavaLanguageLexer.BXOR_ASSIGN)
411             .isEqualTo(107);
412         assertWithMessage(message)
413             .that(JavaLanguageLexer.BOR_ASSIGN)
414             .isEqualTo(108);
415         assertWithMessage(message)
416             .that(JavaLanguageLexer.QUESTION)
417             .isEqualTo(109);
418         assertWithMessage(message)
419             .that(JavaLanguageLexer.LOR)
420             .isEqualTo(110);
421         assertWithMessage(message)
422             .that(JavaLanguageLexer.LAND)
423             .isEqualTo(111);
424         assertWithMessage(message)
425             .that(JavaLanguageLexer.BOR)
426             .isEqualTo(112);
427         assertWithMessage(message)
428             .that(JavaLanguageLexer.BXOR)
429             .isEqualTo(113);
430         assertWithMessage(message)
431             .that(JavaLanguageLexer.BAND)
432             .isEqualTo(114);
433         assertWithMessage(message)
434             .that(JavaLanguageLexer.NOT_EQUAL)
435             .isEqualTo(115);
436         assertWithMessage(message)
437             .that(JavaLanguageLexer.EQUAL)
438             .isEqualTo(116);
439         assertWithMessage(message)
440             .that(JavaLanguageLexer.LT)
441             .isEqualTo(117);
442         assertWithMessage(message)
443             .that(JavaLanguageLexer.GT)
444             .isEqualTo(118);
445         assertWithMessage(message)
446             .that(JavaLanguageLexer.LE)
447             .isEqualTo(119);
448         assertWithMessage(message)
449             .that(JavaLanguageLexer.GE)
450             .isEqualTo(120);
451         assertWithMessage(message)
452             .that(JavaLanguageLexer.LITERAL_INSTANCEOF)
453             .isEqualTo(121);
454         assertWithMessage(message)
455             .that(JavaLanguageLexer.SL)
456             .isEqualTo(122);
457         assertWithMessage(message)
458             .that(JavaLanguageLexer.SR)
459             .isEqualTo(123);
460         assertWithMessage(message)
461             .that(JavaLanguageLexer.BSR)
462             .isEqualTo(124);
463         assertWithMessage(message)
464             .that(JavaLanguageLexer.PLUS)
465             .isEqualTo(125);
466         assertWithMessage(message)
467             .that(JavaLanguageLexer.MINUS)
468             .isEqualTo(126);
469         assertWithMessage(message)
470             .that(JavaLanguageLexer.DIV)
471             .isEqualTo(127);
472         assertWithMessage(message)
473             .that(JavaLanguageLexer.MOD)
474             .isEqualTo(128);
475         assertWithMessage(message)
476             .that(JavaLanguageLexer.INC)
477             .isEqualTo(129);
478         assertWithMessage(message)
479             .that(JavaLanguageLexer.DEC)
480             .isEqualTo(130);
481         assertWithMessage(message)
482             .that(JavaLanguageLexer.BNOT)
483             .isEqualTo(131);
484         assertWithMessage(message)
485             .that(JavaLanguageLexer.LNOT)
486             .isEqualTo(132);
487         assertWithMessage(message)
488             .that(JavaLanguageLexer.LITERAL_TRUE)
489             .isEqualTo(133);
490         assertWithMessage(message)
491             .that(JavaLanguageLexer.LITERAL_FALSE)
492             .isEqualTo(134);
493         assertWithMessage(message)
494             .that(JavaLanguageLexer.LITERAL_NULL)
495             .isEqualTo(135);
496         assertWithMessage(message)
497             .that(JavaLanguageLexer.LITERAL_NEW)
498             .isEqualTo(136);
499         assertWithMessage(message)
500             .that(JavaLanguageLexer.NUM_INT)
501             .isEqualTo(137);
502         assertWithMessage(message)
503             .that(JavaLanguageLexer.CHAR_LITERAL)
504             .isEqualTo(138);
505         assertWithMessage(message)
506             .that(JavaLanguageLexer.STRING_LITERAL)
507             .isEqualTo(139);
508         assertWithMessage(message)
509             .that(JavaLanguageLexer.NUM_FLOAT)
510             .isEqualTo(140);
511         assertWithMessage(message)
512             .that(JavaLanguageLexer.NUM_LONG)
513             .isEqualTo(141);
514         assertWithMessage(message)
515             .that(JavaLanguageLexer.NUM_DOUBLE)
516             .isEqualTo(142);
517         assertWithMessage(message)
518             .that(JavaLanguageLexer.WS)
519             .isEqualTo(143);
520         assertWithMessage(message)
521             .that(JavaLanguageLexer.SINGLE_LINE_COMMENT)
522             .isEqualTo(144);
523         assertWithMessage(message)
524             .that(JavaLanguageLexer.BLOCK_COMMENT_BEGIN)
525             .isEqualTo(145);
526         assertWithMessage(message)
527             .that(JavaLanguageLexer.ESC)
528             .isEqualTo(146);
529         assertWithMessage(message)
530             .that(JavaLanguageLexer.HEX_DIGIT)
531             .isEqualTo(147);
532         assertWithMessage(message)
533             .that(JavaLanguageLexer.VOCAB)
534             .isEqualTo(148);
535         assertWithMessage(message)
536             .that(JavaLanguageLexer.EXPONENT)
537             .isEqualTo(149);
538         assertWithMessage(message)
539             .that(JavaLanguageLexer.FLOAT_SUFFIX)
540             .isEqualTo(150);
541         assertWithMessage(message)
542             .that(JavaLanguageLexer.ASSERT)
543             .isEqualTo(151);
544         assertWithMessage(message)
545             .that(JavaLanguageLexer.STATIC_IMPORT)
546             .isEqualTo(152);
547         assertWithMessage(message)
548             .that(JavaLanguageLexer.ENUM)
549             .isEqualTo(153);
550         assertWithMessage(message)
551             .that(JavaLanguageLexer.ENUM_DEF)
552             .isEqualTo(154);
553         assertWithMessage(message)
554             .that(JavaLanguageLexer.ENUM_CONSTANT_DEF)
555             .isEqualTo(155);
556         assertWithMessage(message)
557             .that(JavaLanguageLexer.FOR_EACH_CLAUSE)
558             .isEqualTo(156);
559         assertWithMessage(message)
560             .that(JavaLanguageLexer.ANNOTATION_DEF)
561             .isEqualTo(157);
562         assertWithMessage(message)
563             .that(JavaLanguageLexer.ANNOTATIONS)
564             .isEqualTo(158);
565         assertWithMessage(message)
566             .that(JavaLanguageLexer.ANNOTATION)
567             .isEqualTo(159);
568         assertWithMessage(message)
569             .that(JavaLanguageLexer.ANNOTATION_MEMBER_VALUE_PAIR)
570             .isEqualTo(160);
571         assertWithMessage(message)
572             .that(JavaLanguageLexer.ANNOTATION_FIELD_DEF)
573             .isEqualTo(161);
574         assertWithMessage(message)
575             .that(JavaLanguageLexer.ANNOTATION_ARRAY_INIT)
576             .isEqualTo(162);
577         assertWithMessage(message)
578             .that(JavaLanguageLexer.TYPE_ARGUMENTS)
579             .isEqualTo(163);
580         assertWithMessage(message)
581             .that(JavaLanguageLexer.TYPE_ARGUMENT)
582             .isEqualTo(164);
583         assertWithMessage(message)
584             .that(JavaLanguageLexer.TYPE_PARAMETERS)
585             .isEqualTo(165);
586         assertWithMessage(message)
587             .that(JavaLanguageLexer.TYPE_PARAMETER)
588             .isEqualTo(166);
589         assertWithMessage(message)
590             .that(JavaLanguageLexer.WILDCARD_TYPE)
591             .isEqualTo(167);
592         assertWithMessage(message)
593             .that(JavaLanguageLexer.TYPE_UPPER_BOUNDS)
594             .isEqualTo(168);
595         assertWithMessage(message)
596             .that(JavaLanguageLexer.TYPE_LOWER_BOUNDS)
597             .isEqualTo(169);
598         assertWithMessage(message)
599             .that(JavaLanguageLexer.AT)
600             .isEqualTo(170);
601         assertWithMessage(message)
602             .that(JavaLanguageLexer.ELLIPSIS)
603             .isEqualTo(171);
604         assertWithMessage(message)
605             .that(JavaLanguageLexer.GENERIC_START)
606             .isEqualTo(172);
607         assertWithMessage(message)
608             .that(JavaLanguageLexer.GENERIC_END)
609             .isEqualTo(173);
610         assertWithMessage(message)
611             .that(JavaLanguageLexer.TYPE_EXTENSION_AND)
612             .isEqualTo(174);
613         assertWithMessage(message)
614             .that(JavaLanguageLexer.DO_WHILE)
615             .isEqualTo(175);
616         assertWithMessage(message)
617             .that(JavaLanguageLexer.RESOURCE_SPECIFICATION)
618             .isEqualTo(176);
619         assertWithMessage(message)
620             .that(JavaLanguageLexer.RESOURCES)
621             .isEqualTo(177);
622         assertWithMessage(message)
623             .that(JavaLanguageLexer.RESOURCE)
624             .isEqualTo(178);
625         assertWithMessage(message)
626             .that(JavaLanguageLexer.DOUBLE_COLON)
627             .isEqualTo(179);
628         assertWithMessage(message)
629             .that(JavaLanguageLexer.METHOD_REF)
630             .isEqualTo(180);
631         assertWithMessage(message)
632             .that(JavaLanguageLexer.LAMBDA)
633             .isEqualTo(181);
634         assertWithMessage(message)
635             .that(JavaLanguageLexer.BLOCK_COMMENT_END)
636             .isEqualTo(182);
637         assertWithMessage(message)
638             .that(JavaLanguageLexer.COMMENT_CONTENT)
639             .isEqualTo(183);
640         assertWithMessage(message)
641             .that(JavaLanguageLexer.SINGLE_LINE_COMMENT_CONTENT)
642             .isEqualTo(184);
643         assertWithMessage(message)
644             .that(JavaLanguageLexer.BLOCK_COMMENT_CONTENT)
645             .isEqualTo(185);
646         assertWithMessage(message)
647             .that(JavaLanguageLexer.STD_ESC)
648             .isEqualTo(186);
649         assertWithMessage(message)
650             .that(JavaLanguageLexer.BINARY_DIGIT)
651             .isEqualTo(187);
652         assertWithMessage(message)
653             .that(JavaLanguageLexer.ID_START)
654             .isEqualTo(188);
655         assertWithMessage(message)
656             .that(JavaLanguageLexer.ID_PART)
657             .isEqualTo(189);
658         assertWithMessage(message)
659             .that(JavaLanguageLexer.INT_LITERAL)
660             .isEqualTo(190);
661         assertWithMessage(message)
662             .that(JavaLanguageLexer.LONG_LITERAL)
663             .isEqualTo(191);
664         assertWithMessage(message)
665             .that(JavaLanguageLexer.FLOAT_LITERAL)
666             .isEqualTo(192);
667         assertWithMessage(message)
668             .that(JavaLanguageLexer.DOUBLE_LITERAL)
669             .isEqualTo(193);
670         assertWithMessage(message)
671             .that(JavaLanguageLexer.HEX_FLOAT_LITERAL)
672             .isEqualTo(194);
673         assertWithMessage(message)
674             .that(JavaLanguageLexer.HEX_DOUBLE_LITERAL)
675             .isEqualTo(195);
676         assertWithMessage(message)
677             .that(JavaLanguageLexer.SIGNED_INTEGER)
678             .isEqualTo(196);
679         assertWithMessage(message)
680             .that(JavaLanguageLexer.BINARY_EXPONENT)
681             .isEqualTo(197);
682         assertWithMessage(message)
683             .that(JavaLanguageLexer.PATTERN_VARIABLE_DEF)
684             .isEqualTo(198);
685         assertWithMessage(message)
686             .that(JavaLanguageLexer.RECORD_DEF)
687             .isEqualTo(199);
688         assertWithMessage(message)
689             .that(JavaLanguageLexer.LITERAL_RECORD)
690             .isEqualTo(200);
691         assertWithMessage(message)
692             .that(JavaLanguageLexer.RECORD_COMPONENTS)
693             .isEqualTo(201);
694         assertWithMessage(message)
695             .that(JavaLanguageLexer.RECORD_COMPONENT_DEF)
696             .isEqualTo(202);
697         assertWithMessage(message)
698             .that(JavaLanguageLexer.COMPACT_CTOR_DEF)
699             .isEqualTo(203);
700         assertWithMessage(message)
701             .that(JavaLanguageLexer.TEXT_BLOCK_LITERAL_BEGIN)
702             .isEqualTo(204);
703         assertWithMessage(message)
704             .that(JavaLanguageLexer.TEXT_BLOCK_CONTENT)
705             .isEqualTo(205);
706         assertWithMessage(message)
707             .that(JavaLanguageLexer.TEXT_BLOCK_LITERAL_END)
708             .isEqualTo(206);
709         assertWithMessage(message)
710             .that(JavaLanguageLexer.LITERAL_YIELD)
711             .isEqualTo(207);
712         assertWithMessage(message)
713             .that(JavaLanguageLexer.SWITCH_RULE)
714             .isEqualTo(208);
715         assertWithMessage(message)
716             .that(JavaLanguageLexer.LITERAL_NON_SEALED)
717             .isEqualTo(209);
718         assertWithMessage(message)
719             .that(JavaLanguageLexer.LITERAL_SEALED)
720             .isEqualTo(210);
721         assertWithMessage(message)
722             .that(JavaLanguageLexer.LITERAL_PERMITS)
723             .isEqualTo(211);
724         assertWithMessage(message)
725             .that(JavaLanguageLexer.PERMITS_CLAUSE)
726             .isEqualTo(212);
727         assertWithMessage(message)
728              .that(JavaLanguageLexer.PATTERN_DEF)
729              .isEqualTo(213);
730         assertWithMessage(message)
731              .that(JavaLanguageLexer.LITERAL_WHEN)
732              .isEqualTo(214);
733         assertWithMessage(message)
734              .that(JavaLanguageLexer.RECORD_PATTERN_DEF)
735              .isEqualTo(215);
736         assertWithMessage(message)
737              .that(JavaLanguageLexer.RECORD_PATTERN_COMPONENTS)
738              .isEqualTo(216);
739         assertWithMessage(message)
740             .that(JavaLanguageLexer.LITERAL_UNDERSCORE)
741             .isEqualTo(224);
742         assertWithMessage(message)
743             .that(JavaLanguageLexer.UNNAMED_PATTERN_DEF)
744             .isEqualTo(225);
745 
746         final Set<String> modeNames = Set.of(JavaLanguageLexer.modeNames);
747         final Set<String> channelNames = Set.of(JavaLanguageLexer.channelNames);
748 
749         final int tokenCount = (int) Arrays.stream(JavaLanguageLexer.class.getDeclaredFields())
750                 .filter(GeneratedJavaTokenTypesTest::isPublicStaticFinalInt)
751                 .filter(field -> !modeNames.contains(field.getName()))
752                 .filter(field -> !channelNames.contains(field.getName()))
753                 .filter(field -> !INTERNAL_TOKENS.contains(field.getName()))
754                 .count();
755 
756         // Read JavaDoc before changing count below, the count should be equal to
757         // the number of the last token asserted above.
758         assertWithMessage("all tokens must be added to list in"
759                         + " 'GeneratedJavaTokenTypesTest' and verified"
760                         + " that their old numbering didn't change")
761             .that(tokenCount)
762             .isEqualTo(225);
763     }
764 
765     /**
766      * This test was created to make sure that new tokens are added to the 'tokens'
767      * block in the lexer grammar. If a new token is not added at the end of the list,
768      * it will become "mixed in" with the unused tokens and cause
769      * Collections#lastIndexOfSubList to return a -1 and fail the test.
770      */
771     @Test
772     public void testTokenHasBeenAddedToTokensBlockInLexerGrammar() {
773         final VocabularyImpl vocabulary = (VocabularyImpl) JavaLanguageLexer.VOCABULARY;
774         final String[] nullableSymbolicNames = vocabulary.getSymbolicNames();
775         final List<String> allTokenNames = Arrays.stream(nullableSymbolicNames)
776                 .filter(Objects::nonNull)
777                 .collect(Collectors.toUnmodifiableList());
778 
779         // Get the starting index of the sublist of tokens, or -1 if sublist
780         // is not present.
781         final int lastIndexOfSublist =
782                 Collections.lastIndexOfSubList(allTokenNames, INTERNAL_TOKENS);
783         final int expectedNumberOfUsedTokens = allTokenNames.size() - INTERNAL_TOKENS.size();
784         final String message = "New tokens must be added to the 'tokens' block in the"
785                 + " lexer grammar.";
786 
787         assertWithMessage(message)
788                 .that(expectedNumberOfUsedTokens)
789                 .isEqualTo(lastIndexOfSublist);
790     }
791 
792     /**
793      * Checks that a given field is 'public static final int'.
794      *
795      * @param field field to verify type and visibility of
796      * @return true if field is declared as 'public static final int'
797      */
798     private static boolean isPublicStaticFinalInt(Field field) {
799         final Class<?> fieldType = field.getType();
800         final int mods = field.getModifiers();
801         return fieldType.equals(Integer.TYPE)
802                 && Modifier.isPublic(mods)
803                 && Modifier.isStatic(mods)
804                 && Modifier.isFinal(mods);
805     }
806 }