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