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
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
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
757
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
767
768
769
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
780
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
794
795
796
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 }