tests/java.at

   1 # Java tests for simple calculator.           -*- Autotest -*-
   2
   3 # Copyright (C) 2007-2015, 2018-2021 Free Software Foundation, Inc.
   4
   5 # This program is free software: you can redistribute it and/or modify
   6 # it under the terms of the GNU General Public License as published by
   7 # the Free Software Foundation, either version 3 of the License, or
   8 # (at your option) any later version.
   9 #
  10 # This program 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
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
  17
  18 AT_BANNER([[Java Calculator.]])
  19
  20
  21 ## ------------------------- ##
  22 ## Java invalid directives.  ##
  23 ## ------------------------- ##
  24
  25 AT_SETUP([Java invalid directives])
  26
  27 AT_DATA([[YYParser.y]], [
  28 %language "Java"
  29 %header
  30 %destructor { /* Nothing. */ } exp
  31 %%
  32 exp:
  33 ])
  34
  35 AT_BISON_CHECK([[-fcaret YYParser.y]], [1], [],
  36 [[YYParser.y: error: %header/%defines does not make sense in Java
  37 YYParser.y:4.13-30: error: %destructor does not make sense in Java
  38     4 | %destructor { /* Nothing. */ } exp
  39       |             ^~~~~~~~~~~~~~~~~~
  40 ]])
  41
  42 AT_DATA([[YYParser.y]], [
  43 %language "Java"
  44 %defines
  45 %destructor { /* Nothing. */ } exp
  46 %%
  47 exp:
  48 ])
  49
  50 AT_BISON_CHECK([[-fcaret YYParser.y]], [1], [],
  51 [[YYParser.y: error: %header/%defines does not make sense in Java
  52 YYParser.y:4.13-30: error: %destructor does not make sense in Java
  53     4 | %destructor { /* Nothing. */ } exp
  54       |             ^~~~~~~~~~~~~~~~~~
  55 ]])
  56
  57 AT_CLEANUP
  58
  59
  60 ## ------------------------- ##
  61 ## Helping Autotest macros.  ##
  62 ## ------------------------- ##
  63
  64
  65 # AT_JAVA_POSITION_DEFINE_OLD
  66 # -----------------------
  67 m4_define([AT_JAVA_POSITION_DEFINE_OLD],
  68 [[class Position {
  69   public int line;
  70   public int token;
  71
  72   public Position ()
  73   {
  74     line = 0;
  75     token = 0;
  76   }
  77
  78   public Position (int l, int t)
  79   {
  80     line = l;
  81     token = t;
  82   }
  83
  84   public boolean equals (Position l)
  85   {
  86     return l.line == line && l.token == token;
  87   }
  88
  89   public String toString ()
  90   {
  91     return Integer.toString (line) + "." + Integer.toString (token);
  92   }
  93
  94   public int lineno ()
  95   {
  96     return line;
  97   }
  98
  99   public int token ()
 100   {
 101     return token;
 102   }
 103 }]])
 104
 105
 106
 107
 108
 109 ## ----------------- ##
 110 ## Java Parameters.  ##
 111 ## ----------------- ##
 112
 113 AT_BANNER([Java Parameters.])
 114
 115
 116 # AT_CHECK_JAVA_MINIMAL([DIRECTIVES], [PARSER_ACTION], [POSITION_CLASS])
 117 # ----------------------------------------------------------------------
 118 # Check that a minimal parser with DIRECTIVES compiles in Java.
 119 # Put the Java code in YYParser.java.
 120 m4_define([AT_CHECK_JAVA_MINIMAL],
 121 [
 122 AT_DATA([[YYParser.y]], [
 123 %language "Java"
 124 %locations
 125 %debug
 126 %define parse.error verbose
 127 %token-table
 128 %token END "end"
 129 $1
 130 %%
 131 start: END {$2};
 132 %%
 133 class m4_default([$3], [Position]) {}
 134 ])
 135 AT_BISON_CHECK([[-Wno-deprecated YYParser.y]])
 136 AT_CHECK([[grep '[mb]4_' YYParser.y]], [1], [ignore])
 137 AT_JAVA_COMPILE([[YYParser.java]])
 138 ])
 139
 140
 141 # AT_CHECK_JAVA_MINIMAL_W_LEXER([1:DIRECTIVES], [2:LEX_THROWS],
 142 #       [3:YYLEX_ACTION], [4:LEXER_BODY], [5:PARSER_ACTION], [6:VALUE_TYPE],
 143 #       [7:POSITION_TYPE], [8:LOCATION_TYPE])
 144 # ---------------------------------------------------------------------
 145 # Check that a minimal parser with DIRECTIVES and a "%code lexer".
 146 # YYLEX is the body of yylex () which throws LEX_THROW.
 147 # compiles in Java.
 148 m4_define([AT_CHECK_JAVA_MINIMAL_W_LEXER],
 149 [AT_CHECK_JAVA_MINIMAL([$1
 150
 151 %code lexer
 152 {
 153   m4_default([$6], [Object]) yylval;
 154   public m4_default([$6], [Object]) getLVal() { return yylval; }
 155
 156   public m4_default([$7], [Position]) getStartPos() { return null; }
 157   public m4_default([$7], [Position]) getEndPos()   { return null; }
 158
 159   public void yyerror (m4_default([$8], [Location]) loc, String s)
 160   {
 161     System.err.println (loc + ": " + s);
 162   }
 163
 164   public int yylex()$2
 165   {
 166     $3
 167   }
 168
 169   $4
 170 }], [$5], [$7])])
 171
 172
 173 # AT_CHECK_JAVA_GREP([LINE], [COUNT=1])
 174 # -------------------------------------
 175 # Check that YYParser.java contains exactly COUNT lines matching ^LINE$
 176 # with grep.
 177 m4_define([AT_CHECK_JAVA_GREP],
 178 [AT_CHECK([grep -c '^$1$' YYParser.java], [ignore], [m4_default([$2], [1])
 179 ])])
 180
 181
 182 ## ------------------------------------- ##
 183 ## Java parser class and package names.  ##
 184 ## ------------------------------------- ##
 185
 186 AT_SETUP([Java parser class and package names])
 187
 188 AT_CHECK_JAVA_MINIMAL([])
 189 AT_CHECK_JAVA_GREP([[class YYParser]])
 190
 191 AT_CHECK_JAVA_MINIMAL([[%name-prefix "Prefix"]])
 192 AT_CHECK_JAVA_GREP([[class PrefixParser]])
 193
 194 AT_CHECK_JAVA_MINIMAL([[%define api.prefix {Prefix}]])
 195 AT_CHECK_JAVA_GREP([[class PrefixParser]])
 196
 197 AT_CHECK_JAVA_MINIMAL([[%define api.token.prefix {TOK_}]])
 198 AT_CHECK_JAVA_GREP([[.*TOK_END.*]])
 199
 200 AT_CHECK_JAVA_MINIMAL([[%define api.parser.class {ParserClassName}]])
 201 AT_CHECK_JAVA_GREP([[class ParserClassName]])
 202
 203 AT_CHECK_JAVA_MINIMAL([[%define api.package {user_java_package}]])
 204 AT_CHECK_JAVA_GREP([[package user_java_package;]])
 205
 206 # Backward compatibility.
 207 AT_CHECK_JAVA_MINIMAL([[%define package {user_java_package}]])
 208 AT_CHECK_JAVA_GREP([[package user_java_package;]])
 209
 210 AT_CLEANUP
 211
 212
 213 ## ----------------------------- ##
 214 ## Java parser class modifiers.  ##
 215 ## ----------------------------- ##
 216
 217 AT_SETUP([Java parser class modifiers])
 218
 219 AT_CHECK_JAVA_MINIMAL([[%define abstract]])
 220 AT_CHECK_JAVA_GREP([[abstract class YYParser]])
 221
 222 AT_CHECK_JAVA_MINIMAL([[%define final]])
 223 AT_CHECK_JAVA_GREP([[final class YYParser]])
 224
 225 AT_CHECK_JAVA_MINIMAL([[%define strictfp]])
 226 AT_CHECK_JAVA_GREP([[strictfp class YYParser]])
 227
 228 AT_CHECK_JAVA_MINIMAL([[
 229 %define abstract
 230 %define strictfp]])
 231 AT_CHECK_JAVA_GREP([[abstract strictfp class YYParser]])
 232
 233 AT_CHECK_JAVA_MINIMAL([[
 234 %define final
 235 %define strictfp]])
 236 AT_CHECK_JAVA_GREP([[final strictfp class YYParser]])
 237
 238 AT_CHECK_JAVA_MINIMAL([[%define public]])
 239 AT_CHECK_JAVA_GREP([[public class YYParser]])
 240
 241 AT_CHECK_JAVA_MINIMAL([[
 242 %define public
 243 %define abstract]])
 244 AT_CHECK_JAVA_GREP([[public abstract class YYParser]])
 245
 246 AT_CHECK_JAVA_MINIMAL([[
 247 %define public
 248 %define final]])
 249 AT_CHECK_JAVA_GREP([[public final class YYParser]])
 250
 251 AT_CHECK_JAVA_MINIMAL([[
 252 %define public
 253 %define strictfp]])
 254 AT_CHECK_JAVA_GREP([[public strictfp class YYParser]])
 255
 256 AT_CHECK_JAVA_MINIMAL([[
 257 %define public
 258 %define abstract
 259 %define strictfp]])
 260 AT_CHECK_JAVA_GREP([[public abstract strictfp class YYParser]])
 261
 262 AT_CHECK_JAVA_MINIMAL([[
 263 %define public
 264 %define final
 265 %define strictfp]])
 266 AT_CHECK_JAVA_GREP([[public final strictfp class YYParser]])
 267
 268 AT_CHECK_JAVA_MINIMAL([[
 269 %define api.parser.public
 270 %define api.parser.final
 271 %define api.parser.strictfp]])
 272 AT_CHECK_JAVA_GREP([[public final strictfp class YYParser]])
 273
 274 # FIXME: Can't do a Java compile because javacomp.sh is configured for 1.3
 275 AT_CHECK_JAVA_MINIMAL([[
 276 %define annotations {/*@Deprecated @SuppressWarnings("unchecked") @SuppressWarnings({"unchecked", "deprecation"}) @SuppressWarnings(value={"unchecked", "deprecation"})*/}
 277 %define public]])
 278 AT_CHECK_JAVA_GREP([[/\*@Deprecated @SuppressWarnings("unchecked") @SuppressWarnings({"unchecked", "deprecation"}) @SuppressWarnings(value={"unchecked", "deprecation"})\*/ public class YYParser]])
 279
 280 AT_CLEANUP
 281
 282
 283 ## ---------------------------------------- ##
 284 ## Java parser class extends and implements ##
 285 ## ---------------------------------------- ##
 286
 287 AT_SETUP([Java parser class extends and implements])
 288
 289 AT_CHECK_JAVA_MINIMAL([[%define extends {Thread}]])
 290 AT_CHECK_JAVA_GREP([[class YYParser extends Thread]])
 291
 292 AT_CHECK_JAVA_MINIMAL([[%define implements {Cloneable}]])
 293 AT_CHECK_JAVA_GREP([[class YYParser implements Cloneable]])
 294
 295 AT_CHECK_JAVA_MINIMAL([[
 296 %define extends {Thread}
 297 %define implements {Cloneable}]])
 298 AT_CHECK_JAVA_GREP([[class YYParser extends Thread implements Cloneable]])
 299
 300 AT_CLEANUP
 301
 302
 303 ## -------------------------------- ##
 304 ## Java %parse-param and %lex-param ##
 305 ## -------------------------------- ##
 306
 307 AT_SETUP([Java %parse-param and %lex-param])
 308
 309 AT_CHECK_JAVA_MINIMAL([])
 310 AT_CHECK_JAVA_GREP([[ *public YYParser(Lexer yylexer) *]])
 311
 312 AT_CHECK_JAVA_MINIMAL([[%parse-param {int parse_param1}]])
 313 AT_CHECK_JAVA_GREP([[ *protected final int parse_param1;]])
 314 AT_CHECK_JAVA_GREP([[ *public YYParser(Lexer yylexer, *int parse_param1) *]])
 315 AT_CHECK_JAVA_GREP([[ *this.parse_param1 = parse_param1;]])
 316
 317 AT_CHECK_JAVA_MINIMAL([[
 318 %parse-param {int parse_param1}
 319 %parse-param {long parse_param2}]])
 320 AT_CHECK_JAVA_GREP([[ *protected final int parse_param1;]])
 321 AT_CHECK_JAVA_GREP([[ *protected final long parse_param2;]])
 322 AT_CHECK_JAVA_GREP([[ *public YYParser(Lexer yylexer, *int parse_param1, *long parse_param2) *]])
 323 AT_CHECK_JAVA_GREP([[ *this.parse_param1 = parse_param1;]])
 324 AT_CHECK_JAVA_GREP([[ *this.parse_param2 = parse_param2;]])
 325
 326 AT_CHECK_JAVA_MINIMAL_W_LEXER([], [], [[return EOF;]])
 327 AT_CHECK_JAVA_GREP([[ *public YYParser() *]])
 328 AT_CHECK_JAVA_GREP([[ *protected YYParser(Lexer yylexer) *]])
 329
 330 AT_CHECK_JAVA_MINIMAL_W_LEXER([[%parse-param {int parse_param1}]],
 331     [], [[return EOF;]])
 332 AT_CHECK_JAVA_GREP([[ *protected final int parse_param1;]])
 333 AT_CHECK_JAVA_GREP([[ *public YYParser(int parse_param1) *]])
 334 AT_CHECK_JAVA_GREP([[ *protected YYParser(Lexer yylexer, *int parse_param1) *]])
 335 AT_CHECK_JAVA_GREP([[ *this.parse_param1 = parse_param1;]], [2])
 336
 337 AT_CHECK_JAVA_MINIMAL_W_LEXER([[
 338 %parse-param {int parse_param1}
 339 %parse-param {long parse_param2}]],
 340     [], [[return EOF;]])
 341 AT_CHECK_JAVA_GREP([[ *protected final int parse_param1;]])
 342 AT_CHECK_JAVA_GREP([[ *protected final long parse_param2;]])
 343 AT_CHECK_JAVA_GREP([[ *public YYParser(int parse_param1, *long parse_param2) *]])
 344 AT_CHECK_JAVA_GREP([[ *protected YYParser(Lexer yylexer, *int parse_param1, *long parse_param2) *]])
 345 AT_CHECK_JAVA_GREP([[ *this.parse_param1 = parse_param1;]], [2])
 346 AT_CHECK_JAVA_GREP([[ *this.parse_param2 = parse_param2;]], [2])
 347
 348 AT_CHECK_JAVA_MINIMAL_W_LEXER([[%lex-param {char lex_param1}]],
 349     [], [[return EOF;]], [[YYLexer (char lex_param1) {}]])
 350 AT_CHECK_JAVA_GREP([[ *public YYParser(char lex_param1) *]])
 351 AT_CHECK_JAVA_GREP([[.* = new YYLexer *(lex_param1);]])
 352
 353 AT_CHECK_JAVA_MINIMAL_W_LEXER([[
 354 %lex-param {char lex_param1}
 355 %lex-param {short lex_param2}]],
 356     [], [[return EOF;]], [[YYLexer (char lex_param1, short lex_param2) {}]])
 357 AT_CHECK_JAVA_GREP([[ *public YYParser(char lex_param1, *short lex_param2) *]])
 358 AT_CHECK_JAVA_GREP([[.* = new YYLexer *(lex_param1, *lex_param2);]])
 359
 360 AT_CHECK_JAVA_MINIMAL_W_LEXER([[
 361 %parse-param {int parse_param1}
 362 %parse-param {long parse_param2}
 363 %lex-param {char lex_param1}
 364 %lex-param {short lex_param2}]],
 365     [], [[return EOF;]], [[YYLexer (char lex_param1, short lex_param2) {}]])
 366 AT_CHECK_JAVA_GREP([[ *protected final int parse_param1;]])
 367 AT_CHECK_JAVA_GREP([[ *protected final long parse_param2;]])
 368 AT_CHECK_JAVA_GREP([[ *public YYParser(char lex_param1, *short lex_param2, *int parse_param1, *long parse_param2) *]])
 369 AT_CHECK_JAVA_GREP([[.* = new YYLexer *(lex_param1, *lex_param2);]])
 370 AT_CHECK_JAVA_GREP([[ *protected YYParser(Lexer yylexer, *int parse_param1, *long parse_param2) *]])
 371 AT_CHECK_JAVA_GREP([[ *this.parse_param1 = parse_param1;]], [2])
 372 AT_CHECK_JAVA_GREP([[ *this.parse_param2 = parse_param2;]], [2])
 373
 374 AT_CLEANUP
 375
 376
 377 ## --------------------------- ##
 378 ## Java throw specifications.  ##
 379 ## --------------------------- ##
 380
 381 AT_SETUP([Java throws specifications])
 382
 383 # %define throws        - 0 1 2
 384 # %define lex-throws    - 0 1 2
 385 # %code lexer             0 1
 386
 387 m4_define([AT_JT_lex_throws_define], [m4_case(AT_JT_lex_throws,
 388         -1, [],
 389          0, [[%define lex_throws {}]],
 390          1, [[%define lex_throws {InterruptedException}]],
 391          2, [[%define lex_throws {InterruptedException, IllegalAccessException}]])])
 392
 393 m4_define([AT_JT_yylex_throws], [m4_case(AT_JT_lex_throws,
 394         -1, [[ throws java.io.IOException]],
 395          0, [],
 396          1, [[ throws InterruptedException]],
 397          2, [[ throws InterruptedException, IllegalAccessException]])])
 398
 399 m4_define([AT_JT_yylex_action], [m4_case(AT_JT_lex_throws,
 400         -1, [[throw new java.io.IOException();]],
 401          0, [[return EOF;]],
 402          1, [[throw new InterruptedException();]],
 403          2, [[throw new IllegalAccessException();]])])
 404
 405
 406 m4_define([AT_JT_throws_define], [m4_case(AT_JT_throws,
 407         -1, [],
 408          0, [[%define throws {}]],
 409          1, [[%define throws {ClassNotFoundException}]],
 410          2, [[%define throws {ClassNotFoundException, InstantiationException}]])])
 411
 412 m4_define([AT_JT_yyaction_throws], [m4_case(AT_JT_throws,
 413         -1, [],
 414          0, [],
 415          1, [[ throws ClassNotFoundException]],
 416          2, [[ throws ClassNotFoundException, InstantiationException]])])
 417
 418 m4_define([AT_JT_parse_throws_2], [m4_case(AT_JT_throws,
 419         -1, [],
 420          0, [],
 421          1, [[, ClassNotFoundException]],
 422          2, [[, ClassNotFoundException, InstantiationException]])])
 423
 424 m4_define([AT_JT_parse_throws],
 425         [m4_if(m4_quote(AT_JT_yylex_throws), [],
 426                 [AT_JT_yyaction_throws],
 427                 [AT_JT_yylex_throws[]AT_JT_parse_throws_2])])
 428
 429 m4_define([AT_JT_initial_action], [m4_case(AT_JT_throws,
 430         -1, [],
 431          0, [],
 432          1, [[%initial-action {if (true) throw new ClassNotFoundException();}]],
 433          2, [[%initial-action {if (true) throw new InstantiationException();}]])])
 434
 435 m4_define([AT_JT_parse_action], [m4_case(AT_JT_throws,
 436         -1, [],
 437          0, [],
 438          1, [[throw new ClassNotFoundException();]],
 439          2, [[throw new ClassNotFoundException();]])])
 440
 441 m4_for([AT_JT_lexer], 0, 1, 1,
 442   [m4_for([AT_JT_lex_throws], -1, 2, 1,
 443     [m4_for([AT_JT_throws], -1, 2, 1,
 444       [m4_if(AT_JT_lexer, 0,
 445         [AT_CHECK_JAVA_MINIMAL([
 446 AT_JT_throws_define
 447 AT_JT_lex_throws_define
 448 AT_JT_initial_action],
 449 [AT_JT_parse_action])],
 450         [AT_CHECK_JAVA_MINIMAL_W_LEXER([
 451 AT_JT_throws_define
 452 AT_JT_lex_throws_define
 453 AT_JT_initial_action],
 454 [AT_JT_yylex_throws],
 455 [AT_JT_yylex_action],
 456 [],
 457 [AT_JT_parse_action])])
 458 AT_CHECK_JAVA_GREP([[ *int yylex()]AT_JT_yylex_throws *[;]])
 459 AT_CHECK_JAVA_GREP([[ *private int yyaction([^)]*)]AT_JT_yyaction_throws[ *]])
 460 AT_CHECK_JAVA_GREP([[ *public boolean parse()]AT_JT_parse_throws[ *]])
 461 ])])])
 462
 463 AT_CLEANUP
 464
 465
 466 ## --------------------------------------- ##
 467 ## Java constructor init and init_throws.  ##
 468 ## --------------------------------------- ##
 469
 470 AT_SETUP([Java constructor init and init_throws])
 471
 472 m4_pushdef([AT_Witness],
 473 [super("Test Thread"); if (true) throw new InterruptedException();])
 474
 475 AT_CHECK_JAVA_MINIMAL([[
 476 %define extends {Thread}
 477 %code init { ]AT_Witness[ }
 478 %define init_throws {InterruptedException}
 479 %lex-param {int lex_param}]])
 480 AT_CHECK([[grep ']AT_Witness[' YYParser.java]], 0, [ignore])
 481
 482 AT_CHECK_JAVA_MINIMAL_W_LEXER([[
 483 %define extends {Thread}
 484 %code init { ]AT_Witness[ }
 485 %define init_throws {InterruptedException}]], [], [[return EOF;]])
 486 AT_CHECK([[grep ']AT_Witness[' YYParser.java]], 0, [ignore])
 487
 488 m4_popdef([AT_Witness])
 489
 490 AT_CLEANUP
 491
 492
 493 ## ------------------------------------------ ##
 494 ## Java value, position, and location types.  ##
 495 ## ------------------------------------------ ##
 496
 497 AT_SETUP([Java value, position, and location types])
 498
 499 AT_CHECK_JAVA_MINIMAL([[
 500 %define api.value.type {java.awt.Color}
 501 %type<java.awt.Color> start;
 502 %define api.location.type {MyLoc}
 503 %define api.position.type {MyPos}
 504 %code { class MyPos {} }]], [[$$ = $<java.awt.Color>1;]], [[MyPos]])
 505 AT_CHECK([[grep 'java.awt.Color' YYParser.java]], [0], [ignore])
 506 AT_CHECK([[$EGREP -v ' */?\*' YYParser.java | grep -w 'Position']], [1], [ignore])
 507 AT_CHECK([[$EGREP -v ' */?\*' YYParser.java | grep -w 'Location']], [1], [ignore])
 508
 509 AT_CHECK_JAVA_MINIMAL_W_LEXER([[
 510 %define api.value.type {java.awt.Color}
 511 %type<java.awt.Color> start;
 512 %define api.location.type {MyLoc}
 513 %define api.position.type {MyPos}
 514 %code { class MyPos {} }]], [], [[return EOF;]], [],
 515 [[$$ = $<java.awt.Color>1;]],
 516 [[java.awt.Color]], [[MyPos]], [[MyLoc]])
 517 AT_CHECK([[grep 'java.awt.Color' YYParser.java]], [0], [ignore])
 518 AT_CHECK([[$EGREP -v ' */?\*' YYParser.java | grep -w 'Position']], [1], [ignore])
 519 AT_CHECK([[$EGREP -v ' */?\*' YYParser.java | grep -w 'Location']], [1], [ignore])
 520
 521 AT_CLEANUP
 522
 523
 524 ## ------------------------------------------------ ##
 525 ## Java syntax error handling without error token.  ##
 526 ## ------------------------------------------------ ##
 527
 528 AT_SETUP([Java syntax error handling without error token])
 529
 530 AT_DATA([[YYParser.y]], [[%language "Java"
 531
 532 %lex-param { String s }
 533
 534 %code imports {
 535   import java.io.IOException;
 536 }
 537
 538 %code lexer {
 539   String Input;
 540   int Position;
 541
 542   public YYLexer(String s)
 543   {
 544     Input    = s;
 545     Position = 0;
 546   }
 547
 548   public void yyerror(String s)
 549   {
 550     System.err.println (s);
 551   }
 552
 553   public Object getLVal()
 554   {
 555     return null;
 556   }
 557
 558   public int yylex() throws IOException
 559   {
 560     if (Position >= Input.length ())
 561       return EOF;
 562     else
 563       return Input.charAt (Position++);
 564   }
 565 }
 566
 567 %code {
 568   public static void main(String args []) throws IOException
 569   {
 570     YYParser p = new YYParser(args[0]);
 571     p.parse();
 572   }
 573 }
 574 %%
 575 input:
 576   'a' 'a'
 577 ;
 578 ]])
 579 AT_BISON_CHECK([[YYParser.y]])
 580 AT_JAVA_COMPILE([[YYParser.java]])
 581 AT_JAVA_PARSER_CHECK([[YYParser aa]], [[0]], [[]], [[]])
 582 AT_JAVA_PARSER_CHECK([[YYParser ab]], [[0]], [[]], [[syntax error
 583 ]])
 584 AT_JAVA_PARSER_CHECK([[YYParser ba]], [[0]], [[]], [[syntax error
 585 ]])
 586
 587 AT_CLEANUP