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