1 package org.codehaus.groovy.syntax.parser; 2 3 import groovy.util.GroovyTestCase; 4 5 /* 6 import org.codehaus.groovy.syntax.lexer.CharStream; 7 import org.codehaus.groovy.syntax.lexer.StringCharStream; 8 import org.codehaus.groovy.syntax.lexer.Lexer; 9 import org.codehaus.groovy.syntax.lexer.LexerTokenStream; 10 import org.codehaus.groovy.syntax.Token; 11 import org.codehaus.groovy.syntax.TokenStream; 12 import org.codehaus.groovy.tools.ExceptionCollector; 13 */ 14 15 public class ParserTest extends GroovyTestCase { 16 17 public void testNothing() 18 { 19 } 20 21 /* 22 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 23 // package 24 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 25 26 public void testEmptyScript() throws Exception { 27 Parser parser = newParser(""); 28 29 CSTNode root = parser.compilationUnit(); 30 31 assertEquals(null, root.getToken()); 32 33 System.out.println("Root: " + root); 34 { 35 CSTNode child = root.getChild(0); 36 37 System.out.println("Child: "+ child); 38 39 //assertEquals(null, child); 40 } 41 } 42 43 public void testPackageDeclaration_NoDots() throws Exception { 44 Parser parser = newParser("package cheese"); 45 46 CSTNode root = parser.packageDeclaration(); 47 48 assertNode(root, "package", Token.KEYWORD_PACKAGE, 1); 49 50 { 51 assertNode(root.getChild(0), "cheese", Token.IDENTIFIER, 0); 52 } 53 } 54 55 public void testPackageDeclaration_OneDot() throws Exception { 56 Parser parser = newParser("package cheese.toast"); 57 58 CSTNode root = parser.packageDeclaration(); 59 60 assertNode(root, "package", Token.KEYWORD_PACKAGE, 1); 61 62 { 63 assertNode(root.getChild(0), ".", Token.DOT, 2); 64 65 { 66 assertNode(root.getChild(0).getChild(0), "cheese", Token.IDENTIFIER, 0); 67 68 assertNode(root.getChild(0).getChild(1), "toast", Token.IDENTIFIER, 0); 69 } 70 } 71 } 72 73 public void testPackageDeclaration_MultipleDots() throws Exception { 74 Parser parser = newParser("package cheddar.cheese.toast"); 75 76 CSTNode root = parser.packageDeclaration(); 77 78 assertNode(root, "package", Token.KEYWORD_PACKAGE, 1); 79 80 { 81 assertNode(root.getChild(0), ".", Token.DOT, 2); 82 83 { 84 assertNode(root.getChild(0).getChild(0), ".", Token.DOT, 2); 85 { 86 assertNode(root.getChild(0).getChild(0).getChild(0), "cheddar", Token.IDENTIFIER, 0); 87 88 assertNode(root.getChild(0).getChild(0).getChild(1), "cheese", Token.IDENTIFIER, 0); 89 } 90 91 assertNode(root.getChild(0).getChild(1), "toast", Token.IDENTIFIER, 0); 92 } 93 } 94 } 95 96 public void testPackageDeclaration_UnexpectedToken_NoInitialIdentifier() throws Exception { 97 Parser parser = newParser("package ."); 98 99 try { 100 try { 101 parser.packageDeclaration(); 102 fail("should have thrown UnexpectedTokenException"); 103 } 104 catch( ExceptionCollector e ) { 105 e.throwFirstChild(); 106 } 107 } 108 catch (UnexpectedTokenException e) { 109 // expected and correct 110 assertToken(e.getUnexpectedToken(), ".", Token.DOT); 111 112 assertLength(1, e.getExpectedTypes()); 113 114 assertContains(Token.IDENTIFIER, e.getExpectedTypes()); 115 } 116 } 117 118 public void testPackageDeclaration_UnexpectedToken_NoIdentifierFollowingDot() throws Exception { 119 Parser parser = newParser("package cheese."); 120 121 try { 122 try { 123 parser.packageDeclaration(); 124 fail("should have thrown UnexpectedTokenException"); 125 } 126 catch( ExceptionCollector e ) { 127 e.throwFirstChild(); 128 } 129 } 130 catch (UnexpectedTokenException e) { 131 // expected and correct 132 assertNull(e.getUnexpectedToken()); 133 134 assertLength(1, e.getExpectedTypes()); 135 136 assertContains(Token.IDENTIFIER, e.getExpectedTypes()); 137 } 138 } 139 140 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 141 // import 142 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 143 144 public void testImportStatement_NoDots() throws Exception { 145 Parser parser = newParser("import Cheese"); 146 147 CSTNode root = parser.importStatement(); 148 149 assertNode(root, "import", Token.KEYWORD_IMPORT, 2); 150 151 { 152 assertNullNode(root.getChild(0), 0); 153 154 assertNode(root.getChild(1), "Cheese", Token.IDENTIFIER, 0); 155 } 156 } 157 158 public void testImportStatement_As_NoDots() throws Exception { 159 Parser parser = newParser("import Cheese as Toast"); 160 161 CSTNode root = parser.importStatement(); 162 163 assertNode(root, "import", Token.KEYWORD_IMPORT, 2); 164 165 { 166 assertNullNode(root.getChild(0), 0); 167 168 assertNode(root.getChild(1), "Cheese", Token.IDENTIFIER, 1); 169 170 assertNode(root.getChild(1).getChild(0), "Toast", Token.IDENTIFIER, 0); 171 } 172 } 173 174 public void testImportStatement_OneDot() throws Exception { 175 Parser parser = newParser("import cheese.Toast"); 176 177 CSTNode root = parser.importStatement(); 178 179 assertNode(root, "import", Token.KEYWORD_IMPORT, 2); 180 181 { 182 assertNode(root.getChild(0), "cheese", Token.IDENTIFIER, 0); 183 assertNode(root.getChild(1), "Toast", Token.IDENTIFIER, 0); 184 } 185 } 186 187 public void testImportStatement_As_OneDot() throws Exception { 188 Parser parser = newParser("import cheese.Toast as Bread"); 189 190 CSTNode root = parser.importStatement(); 191 192 assertNode(root, "import", Token.KEYWORD_IMPORT, 2); 193 194 { 195 assertNode(root.getChild(0), "cheese", Token.IDENTIFIER, 0); 196 197 assertNode(root.getChild(1), "Toast", Token.IDENTIFIER, 1); 198 199 assertNode(root.getChild(1).getChild(0), "Bread", Token.IDENTIFIER, 0); 200 } 201 } 202 203 public void testImportStatement_MultipleDots() throws Exception { 204 Parser parser = newParser("import cheddar.cheese.Toast"); 205 206 CSTNode root = parser.importStatement(); 207 208 assertNode(root, "import", Token.KEYWORD_IMPORT, 2); 209 210 { 211 assertNode(root.getChild(0), ".", Token.DOT, 2); 212 { 213 assertNode(root.getChild(0).getChild(0), "cheddar", Token.IDENTIFIER, 0); 214 assertNode(root.getChild(0).getChild(1), "cheese", Token.IDENTIFIER, 0); 215 } 216 217 assertNode(root.getChild(1), "Toast", Token.IDENTIFIER, 0); 218 } 219 } 220 221 public void testImportStatement_As_MultipleDots() throws Exception { 222 Parser parser = newParser("import cheddar.cheese.Toast as Bread"); 223 224 CSTNode root = parser.importStatement(); 225 226 assertNode(root, "import", Token.KEYWORD_IMPORT, 2); 227 228 { 229 assertNode(root.getChild(0), ".", Token.DOT, 2); 230 { 231 assertNode(root.getChild(0).getChild(0), "cheddar", Token.IDENTIFIER, 0); 232 assertNode(root.getChild(0).getChild(1), "cheese", Token.IDENTIFIER, 0); 233 } 234 235 assertNode(root.getChild(1), "Toast", Token.IDENTIFIER, 1); 236 assertNode(root.getChild(1).getChild(0), "Bread", Token.IDENTIFIER, 0); 237 } 238 } 239 240 public void testImportStatement_UnexpectedToken_NoInitialIdentifier() throws Exception { 241 Parser parser = newParser("import ."); 242 243 try { 244 try { 245 parser.importStatement(); 246 fail("should have thrown UnexpectedTokenException"); 247 } 248 catch( ExceptionCollector e ) { 249 e.throwFirstChild(); 250 } 251 } 252 catch (UnexpectedTokenException e) { 253 // expected and correct 254 assertToken(e.getUnexpectedToken(), ".", Token.DOT); 255 256 assertLength(1, e.getExpectedTypes()); 257 258 assertContains(Token.IDENTIFIER, e.getExpectedTypes()); 259 } 260 } 261 262 public void testImportStatement_UnexpectedToken_NoIdentifierFollowingDot() throws Exception { 263 Parser parser = newParser("import cheese."); 264 265 try { 266 try { 267 parser.importStatement(); 268 fail("should have thrown UnexpectedTokenException"); 269 } 270 catch( ExceptionCollector e ) { 271 e.throwFirstChild(); 272 } 273 } 274 catch (UnexpectedTokenException e) { 275 // expected and correct 276 assertNull(e.getUnexpectedToken()); 277 278 assertLength(1, e.getExpectedTypes()); 279 280 assertContains(Token.IDENTIFIER, e.getExpectedTypes()); 281 } 282 } 283 284 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 285 // class 286 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 287 288 public void testClassDeclaration_NoModifiers_NoBody_NoExtendsOrImplements() throws Exception { 289 Parser parser = newParser("class Cheese { }"); 290 291 CSTNode modifiers = new CSTNode(); 292 293 CSTNode root = parser.classDeclaration(modifiers); 294 295 assertNode(root, "class", Token.KEYWORD_CLASS, 5); 296 297 { 298 assertSame(modifiers, root.getChild(0)); 299 300 assertNode(root.getChild(1), "Cheese", Token.IDENTIFIER, 0); 301 302 assertNullNode(root.getChild(2), 0); 303 304 assertNullNode(root.getChild(3), 0); 305 306 assertNullNode(root.getChild(4), 0); 307 } 308 } 309 310 public void testClassDeclaration_NoIdentifier() throws Exception { 311 Parser parser = newParser("class {"); 312 313 CSTNode modifiers = new CSTNode(); 314 315 try { 316 try { 317 parser.classDeclaration(modifiers); 318 } 319 catch( ExceptionCollector e ) { 320 e.throwFirstChild(); 321 } 322 } 323 catch (UnexpectedTokenException e) { 324 // expected and correct 325 assertToken(e.getUnexpectedToken(), "{", Token.LEFT_CURLY_BRACE); 326 327 assertLength(1, e.getExpectedTypes()); 328 329 assertContains(Token.IDENTIFIER, e.getExpectedTypes()); 330 } 331 } 332 333 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 334 // interface 335 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 336 337 public void testInterfaceDeclaration_NoModifiers_NoBody_NoExtendsOrImplements() throws Exception { 338 Parser parser = newParser("interface Cheese { }"); 339 340 CSTNode modifiers = new CSTNode(); 341 342 CSTNode root = parser.interfaceDeclaration(modifiers); 343 344 assertNode(root, "interface", Token.KEYWORD_INTERFACE, 5); 345 346 { 347 assertSame(modifiers, root.getChild(0)); 348 349 assertNode(root.getChild(1), "Cheese", Token.IDENTIFIER, 0); 350 351 assertNullNode(root.getChild(2), 0); 352 } 353 } 354 355 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 356 // <type declaration> 357 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 358 359 public void testTypeDeclaration_Class_NoModifiers_NoBody_NoExtendsOrImplements() throws Exception { 360 Parser parser = newParser("class Cheese { }"); 361 362 CSTNode root = parser.typeDeclaration(); 363 364 assertNode(root, "class", Token.KEYWORD_CLASS, 5); 365 366 { 367 assertNullNode(root.getChild(0), 0); 368 369 assertNode(root.getChild(1), "Cheese", Token.IDENTIFIER, 0); 370 371 assertNullNode(root.getChild(2), 0); 372 373 assertNullNode(root.getChild(3), 0); 374 375 assertNullNode(root.getChild(4), 0); 376 } 377 } 378 379 public void testTypeDeclaration_Class_WithModifiers_NoBody_NoExtendsOrImplements() throws Exception { 380 Parser parser = newParser("public class Cheese { }"); 381 382 CSTNode root = parser.typeDeclaration(); 383 384 assertNode(root, "class", Token.KEYWORD_CLASS, 5); 385 386 { 387 assertNullNode(root.getChild(0), 1); 388 { 389 assertNode(root.getChild(0).getChild(0), "public", Token.KEYWORD_PUBLIC, 0); 390 } 391 392 assertNode(root.getChild(1), "Cheese", Token.IDENTIFIER, 0); 393 394 assertNullNode(root.getChild(2), 0); 395 396 assertNullNode(root.getChild(3), 0); 397 398 assertNullNode(root.getChild(4), 0); 399 } 400 } 401 402 public void testTypeDeclaration_Interface_NoModifiers_NoBody_NoExtendsOrImplements() throws Exception { 403 Parser parser = newParser("interface Cheese { }"); 404 405 CSTNode root = parser.typeDeclaration(); 406 407 assertNode(root, "interface", Token.KEYWORD_INTERFACE, 5); 408 409 { 410 assertNullNode(root.getChild(0), 0); 411 412 assertNode(root.getChild(1), "Cheese", Token.IDENTIFIER, 0); 413 414 assertNullNode(root.getChild(2), 0); 415 } 416 } 417 418 public void testTypeDeclaration_Interface_WithModifiers_NoBody_NoExtendsOrImplements() throws Exception { 419 Parser parser = newParser("public interface Cheese { }"); 420 421 CSTNode root = parser.typeDeclaration(); 422 423 assertNode(root, "interface", Token.KEYWORD_INTERFACE, 5); 424 425 { 426 assertNullNode(root.getChild(0), 1); 427 { 428 assertNode(root.getChild(0).getChild(0), "public", Token.KEYWORD_PUBLIC, 0); 429 } 430 431 assertNode(root.getChild(1), "Cheese", Token.IDENTIFIER, 0); 432 433 assertNullNode(root.getChild(2), 0); 434 } 435 } 436 437 /* /* 438 439 The following is actually now valid... 440 441 public void testTypeDeclaration_UnexpectedToken() 442 throws Exception 443 { 444 Parser parser = newParser( "cheese" ); 445 446 try 447 { 448 try { 449 parser.typeDeclaration(); 450 fail( "should have thrown UnexpectedTokenException" ); 451 } 452 catch( ExceptionCollector e ) { 453 e.throwFirstChild(); 454 } 455 } 456 catch (UnexpectedTokenException e) 457 { 458 assertToken( e.getToken(), 459 "cheese", 460 Token.IDENTIFIER ); 461 462 assertLength( 2, 463 e.getExpectedTypes() ); 464 465 assertContains( Token.KEYWORD_CLASS, 466 e.getExpectedTypes() ); 467 468 assertContains( Token.KEYWORD_INTERFACE, 469 e.getExpectedTypes() ); 470 } 471 } 472 */ 473 /* 474 475 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 476 // <compilation unit> 477 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 478 479 public void testCompilationUnit_NoImports_OneClass() throws Exception { 480 Parser parser = newParser("package cheese; public class Cheese{}"); 481 482 CSTNode root = parser.compilationUnit(); 483 484 assertNullNode(root, 3); 485 486 { 487 assertNode(root.getChild(0), "package", Token.KEYWORD_PACKAGE, 1); 488 489 { 490 assertNode(root.getChild(0).getChild(0), "cheese", Token.IDENTIFIER, 0); 491 } 492 493 assertNullNode(root.getChild(1), 0); 494 495 assertNode(root.getChild(2), "class", Token.KEYWORD_CLASS, 5); 496 } 497 } 498 499 public void testCompilationUnit_NoImports_OneInterface() throws Exception { 500 Parser parser = newParser("package cheese; public interface Cheese{}"); 501 502 CSTNode root = parser.compilationUnit(); 503 504 assertNullNode(root, 3); 505 506 { 507 assertNode(root.getChild(0), "package", Token.KEYWORD_PACKAGE, 1); 508 509 { 510 assertNode(root.getChild(0).getChild(0), "cheese", Token.IDENTIFIER, 0); 511 } 512 513 assertNullNode(root.getChild(1), 0); 514 515 assertNode(root.getChild(2), "interface", Token.KEYWORD_INTERFACE, 5); 516 } 517 } 518 519 public void testCompilationUnit_WithImports_OneClass() throws Exception { 520 Parser parser = newParser("package cheese; import com.Toast; import com.Jelly; public class Cheese{}"); 521 522 CSTNode root = parser.compilationUnit(); 523 524 assertNullNode(root, 3); 525 526 { 527 assertNode(root.getChild(0), "package", Token.KEYWORD_PACKAGE, 1); 528 529 { 530 assertNode(root.getChild(0).getChild(0), "cheese", Token.IDENTIFIER, 0); 531 } 532 533 assertNullNode(root.getChild(1), 2); 534 535 { 536 assertNode(root.getChild(1).getChild(0), "import", Token.KEYWORD_IMPORT, 2); 537 538 assertNode(root.getChild(1).getChild(1), "import", Token.KEYWORD_IMPORT, 2); 539 } 540 541 assertNode(root.getChild(2), "class", Token.KEYWORD_CLASS, 5); 542 } 543 } 544 545 public void testCompilationUnit_WithImports_TwoClasses() throws Exception { 546 Parser parser = 547 newParser("package cheese; import com.Toast; import com.Jelly; public class Cheese{} public class Goober {}"); 548 549 CSTNode root = parser.compilationUnit(); 550 551 assertNullNode(root, 4); 552 553 { 554 assertNode(root.getChild(0), "package", Token.KEYWORD_PACKAGE, 1); 555 556 { 557 assertNode(root.getChild(0).getChild(0), "cheese", Token.IDENTIFIER, 0); 558 } 559 560 assertNullNode(root.getChild(1), 2); 561 562 { 563 assertNode(root.getChild(1).getChild(0), "import", Token.KEYWORD_IMPORT, 2); 564 565 assertNode(root.getChild(1).getChild(1), "import", Token.KEYWORD_IMPORT, 2); 566 } 567 568 assertNode(root.getChild(2), "class", Token.KEYWORD_CLASS, 5); 569 { 570 assertNode(root.getChild(2).getChild(1), "Cheese", Token.IDENTIFIER, 0); 571 } 572 573 assertNode(root.getChild(3), "class", Token.KEYWORD_CLASS, 5); 574 { 575 assertNode(root.getChild(3).getChild(1), "Goober", Token.IDENTIFIER, 0); 576 } 577 } 578 } 579 580 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 581 // <body statement> 582 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 583 584 public void testBodyStatement_PropertyDeclaration_NoModifiers_NoType() throws Exception { 585 Parser parser = newParser("property cheese;"); 586 587 CSTNode root = parser.bodyStatement(); 588 589 System.out.println("Got: " + root); 590 591 assertNode(root, "property", Token.KEYWORD_PROPERTY, 3); 592 593 { 594 assertNullNode(root.getChild(0), 0); 595 596 assertNode(root.getChild(1), "cheese", Token.IDENTIFIER, 0); 597 598 assertNullNode(root.getChild(2), 0); 599 } 600 } 601 602 public void testBodyStatement_PropertyDeclaration_OneModifier_NoType() throws Exception { 603 Parser parser = newParser("static property cheese;"); 604 605 CSTNode root = parser.bodyStatement(); 606 607 assertNode(root, "property", Token.KEYWORD_PROPERTY, 3); 608 609 { 610 assertNullNode(root.getChild(0), 1); 611 612 { 613 assertNode(root.getChild(0).getChild(0), "static", Token.KEYWORD_STATIC, 0); 614 } 615 616 assertNode(root.getChild(1), "cheese", Token.IDENTIFIER, 0); 617 618 assertNullNode(root.getChild(2), 0); 619 } 620 } 621 622 public void testBodyStatement_PropertyDeclaration_TwoModifiers_NoType() throws Exception { 623 Parser parser = newParser("static synchronized property cheese;"); 624 625 CSTNode root = parser.bodyStatement(); 626 627 assertNode(root, "property", Token.KEYWORD_PROPERTY, 3); 628 629 { 630 assertNullNode(root.getChild(0), 2); 631 632 { 633 assertNode(root.getChild(0).getChild(0), "static", Token.KEYWORD_STATIC, 0); 634 635 assertNode(root.getChild(0).getChild(1), "synchronized", Token.KEYWORD_SYNCHRONIZED, 0); 636 } 637 638 assertNode(root.getChild(1), "cheese", Token.IDENTIFIER, 0); 639 640 assertNullNode(root.getChild(2), 0); 641 } 642 } 643 644 public void testBodyStatement_PropertyDeclaration_NoProperty_NoModifiers_NoType() throws Exception { 645 Parser parser = newParser("cheese;"); 646 647 CSTNode root = parser.bodyStatement(); 648 649 System.out.println("Got: " + root); 650 651 assertNode(root, "property", Token.KEYWORD_PROPERTY, 3); 652 653 { 654 assertNullNode(root.getChild(0), 0); 655 656 assertNode(root.getChild(1), "cheese", Token.IDENTIFIER, 0); 657 658 assertNullNode(root.getChild(2), 0); 659 } 660 } 661 662 public void testBodyStatement_PropertyDeclaration_NoProperty_OneModifier_NoType() throws Exception { 663 Parser parser = newParser("static cheese;"); 664 665 CSTNode root = parser.bodyStatement(); 666 667 assertNode(root, "property", Token.KEYWORD_PROPERTY, 3); 668 669 { 670 assertNullNode(root.getChild(0), 1); 671 672 { 673 assertNode(root.getChild(0).getChild(0), "static", Token.KEYWORD_STATIC, 0); 674 } 675 676 assertNode(root.getChild(1), "cheese", Token.IDENTIFIER, 0); 677 678 assertNullNode(root.getChild(2), 0); 679 } 680 } 681 682 public void testBodyStatement_PropertyDeclaration_NoProperty_TwoModifiers_NoType() throws Exception { 683 Parser parser = newParser("static synchronized cheese;"); 684 685 CSTNode root = parser.bodyStatement(); 686 687 assertNode(root, "property", Token.KEYWORD_PROPERTY, 3); 688 689 { 690 assertNullNode(root.getChild(0), 2); 691 692 { 693 assertNode(root.getChild(0).getChild(0), "static", Token.KEYWORD_STATIC, 0); 694 695 assertNode(root.getChild(0).getChild(1), "synchronized", Token.KEYWORD_SYNCHRONIZED, 0); 696 } 697 698 assertNode(root.getChild(1), "cheese", Token.IDENTIFIER, 0); 699 700 assertNullNode(root.getChild(2), 0); 701 } 702 } 703 704 public void testBodyStatement_PropertyDeclaration_NoType_WithExpression() throws Exception { 705 Parser parser = newParser("cheese = 1234"); 706 707 CSTNode root = parser.bodyStatement(); 708 709 assertNode(root, "property", Token.KEYWORD_PROPERTY, 4); 710 711 { 712 assertNullNode(root.getChild(0), 0); 713 714 assertNode(root.getChild(1), "cheese", Token.IDENTIFIER, 0); 715 716 assertNullNode(root.getChild(2), 0); 717 718 assertNode(root.getChild(3), "1234", Token.INTEGER_NUMBER, 0); 719 } 720 } 721 722 public void testBodyStatement_PropertyDeclaration_Type_WithExpression() throws Exception { 723 Parser parser = newParser("Food cheese = defaultValue()"); 724 725 CSTNode root = parser.bodyStatement(); 726 727 assertNode(root, "property", Token.KEYWORD_PROPERTY, 4); 728 729 { 730 assertNullNode(root.getChild(0), 0); 731 732 assertNode(root.getChild(1), "cheese", Token.IDENTIFIER, 0); 733 734 assertNode(root.getChild(2), "Food", Token.IDENTIFIER, 0); 735 736 assertNode(root.getChild(3), "(", Token.LEFT_PARENTHESIS, 3); 737 } 738 } 739 740 public void testBodyStatement_MethodDeclaration_NoReturnType_NoParameters() throws Exception { 741 Parser parser = newParser("cheeseIt() { } "); 742 743 CSTNode root = parser.bodyStatement(); 744 745 assertNode(root, "<synthetic>", Token.SYNTH_METHOD, 6); 746 747 { 748 assertNullNode(root.getChild(0), 0); 749 750 assertNode(root.getChild(1), "cheeseIt", Token.IDENTIFIER, 0); 751 752 assertNullNode(root.getChild(2), 0); 753 754 assertNode(root.getChild(3), "(", Token.LEFT_PARENTHESIS, 0); 755 } 756 } 757 758 public void testBodyStatement_MethodDeclaration_WithReturnType_NoParameters() throws Exception { 759 Parser parser = newParser("String cheeseIt() { }"); 760 761 CSTNode root = parser.bodyStatement(); 762 763 assertNode(root, "<synthetic>", Token.SYNTH_METHOD, 6); 764 765 { 766 assertNullNode(root.getChild(0), 0); 767 768 assertNode(root.getChild(1), "cheeseIt", Token.IDENTIFIER, 0); 769 770 assertNode(root.getChild(2), "String", Token.IDENTIFIER, 0); 771 772 assertNode(root.getChild(3), "(", Token.LEFT_PARENTHESIS, 0); 773 } 774 } 775 776 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 777 // <parameter> 778 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 779 780 public void testParameterList() throws Exception { 781 } 782 783 public void testParameterDeclarationWithoutDatatype() throws Exception { 784 Parser parser = newParser("cheese"); 785 786 CSTNode root = parser.parameterDeclaration(); 787 788 assertNode(root, "<synthetic>", Token.SYNTH_PARAMETER_DECLARATION, 2); 789 790 { 791 assertNullNode(root.getChild(0), 0); 792 793 assertNode(root.getChild(1), "cheese", Token.IDENTIFIER, 0); 794 } 795 } 796 797 public void testParameterDeclarationWithDatatype_Simple() throws Exception { 798 Parser parser = newParser("String cheese"); 799 800 CSTNode root = parser.parameterDeclaration(); 801 802 assertNode(root, "<synthetic>", Token.SYNTH_PARAMETER_DECLARATION, 2); 803 804 { 805 assertNode(root.getChild(0), "String", Token.IDENTIFIER, 0); 806 807 assertNode(root.getChild(1), "cheese", Token.IDENTIFIER, 0); 808 } 809 } 810 811 public void testParameterDeclarationWithDatatype_Qualified() throws Exception { 812 Parser parser = newParser("java.lang.String cheese"); 813 814 CSTNode root = parser.parameterDeclaration(); 815 816 assertNode(root, "<synthetic>", Token.SYNTH_PARAMETER_DECLARATION, 2); 817 818 { 819 assertNode(root.getChild(0), ".", Token.DOT, 2); 820 { 821 assertNode(root.getChild(0).getChild(0), ".", Token.DOT, 2); 822 823 { 824 assertNode(root.getChild(0).getChild(0).getChild(0), "java", Token.IDENTIFIER, 0); 825 826 assertNode(root.getChild(0).getChild(0).getChild(1), "lang", Token.IDENTIFIER, 0); 827 } 828 829 assertNode(root.getChild(0).getChild(1), "String", Token.IDENTIFIER, 0); 830 } 831 832 assertNode(root.getChild(1), "cheese", Token.IDENTIFIER, 0); 833 } 834 } 835 836 public void testParameterDeclaration_General_WithoutDatatype() throws Exception { 837 Parser parser = newParser("cheese"); 838 839 CSTNode root = parser.parameterDeclaration(); 840 841 assertNode(root, "<synthetic>", Token.SYNTH_PARAMETER_DECLARATION, 2); 842 843 { 844 assertNullNode(root.getChild(0), 0); 845 846 assertNode(root.getChild(1), "cheese", Token.IDENTIFIER, 0); 847 } 848 } 849 850 public void testParameterDeclaration_General_WithDatatype() throws Exception { 851 Parser parser = newParser("String cheese"); 852 853 CSTNode root = parser.parameterDeclaration(); 854 855 assertNode(root, "<synthetic>", Token.SYNTH_PARAMETER_DECLARATION, 2); 856 857 { 858 assertNode(root.getChild(0), "String", Token.IDENTIFIER, 0); 859 860 assertNode(root.getChild(1), "cheese", Token.IDENTIFIER, 0); 861 } 862 } 863 864 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 865 // <parameter list> 866 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 867 868 public void testParameterList_Empty() throws Exception { 869 Parser parser = newParser(""); 870 871 CSTNode root = parser.parameterDeclarationList(); 872 873 assertNullNode(root, 0); 874 } 875 876 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 877 // method 878 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 879 880 public void testMethod_NoModifiers_NoReturnType_NoParameters() throws Exception { 881 Parser parser = newParser("cheeseIt() { }"); 882 883 CSTNode root = parser.bodyStatement(); 884 885 assertNode(root, "<synthetic>", Token.SYNTH_METHOD, 6); 886 887 { 888 assertNullNode(root.getChild(0), 0); 889 890 assertNode(root.getChild(1), "cheeseIt", Token.IDENTIFIER, 0); 891 892 assertNullNode(root.getChild(2), 0); 893 894 assertNode(root.getChild(3), "(", Token.LEFT_PARENTHESIS, 0); 895 } 896 } 897 898 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 899 // property 900 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 901 902 public void testProperty_NoModifiers_NoType() throws Exception { 903 Parser parser = newParser("property cheese"); 904 905 CSTNode root = parser.bodyStatement(); 906 907 assertNode(root, "property", Token.KEYWORD_PROPERTY, 3); 908 909 { 910 assertNullNode(root.getChild(0), 0); 911 912 assertNode(root.getChild(1), "cheese", Token.IDENTIFIER, 0); 913 914 assertNullNode(root.getChild(2), 0); 915 } 916 } 917 918 public void testProperty_NoModifiers_NoProperty_NoType() throws Exception { 919 Parser parser = newParser("cheese"); 920 921 CSTNode root = parser.bodyStatement(); 922 923 assertNode(root, "property", Token.KEYWORD_PROPERTY, 3); 924 925 { 926 assertNullNode(root.getChild(0), 0); 927 928 assertNode(root.getChild(1), "cheese", Token.IDENTIFIER, 0); 929 930 assertNullNode(root.getChild(2), 0); 931 } 932 } 933 934 // ((misc)) 935 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 936 937 public void testIsModifier() throws Exception { 938 assertTrue(Token.isModifier(Token.KEYWORD_PUBLIC)); 939 assertTrue(Token.isModifier(Token.KEYWORD_PROTECTED)); 940 assertTrue(Token.isModifier(Token.KEYWORD_PRIVATE)); 941 assertTrue(Token.isModifier(Token.KEYWORD_STATIC)); 942 assertTrue(Token.isModifier(Token.KEYWORD_FINAL)); 943 assertTrue(Token.isModifier(Token.KEYWORD_SYNCHRONIZED)); 944 assertFalse(Token.isModifier(Token.IDENTIFIER)); 945 } 946 947 public void testConsumeUntil_Found() throws Exception { 948 Parser parser = newParser("cheese toast is; bread"); 949 950 assertToken(parser.la(), "cheese", Token.IDENTIFIER); 951 952 parser.consumeUntil(Token.SEMICOLON); 953 954 assertToken(parser.la(), "bread", Token.IDENTIFIER); 955 } 956 957 public void testConsumeUntil_NotFound() throws Exception { 958 Parser parser = newParser("cheese toast"); 959 960 assertToken(parser.la(), "cheese", Token.IDENTIFIER); 961 962 parser.consumeUntil(Token.SEMICOLON); 963 964 assertNull(parser.la()); 965 } 966 967 public void testAssignmentExpression() throws Exception { 968 Parser parser = newParser("answer = list.collect( { item | return item * 2 } )"); 969 970 CSTNode root = parser.expression(); 971 } 972 973 public void testSafeMethodCallExpression() throws Exception { 974 Parser parser = newParser("answer = foo->someMethod()"); 975 976 CSTNode root = parser.expression(); 977 978 System.out.println("Got: " + root); 979 } 980 981 public void testLogicalAndExpression() throws Exception { 982 Parser parser = newParser("x > 1 && \n y < 2"); 983 984 CSTNode root = parser.expression(); 985 986 System.out.println("Got: " + root); 987 } 988 989 public void testStatement_CharacterizeMePlease() throws Exception { 990 Parser parser = newParser("callBlock(5, { owner | owner.incrementCallCount() })"); 991 992 CSTNode root = parser.statement(); 993 } 994 995 public void testStatementBlock_CharacterizeMePlease() throws Exception { 996 Parser parser = 997 newParser("keys = answer.collect( { entry | return entry.key } ); values = answer.collect( { entry | return entry.value })"); 998 999 CSTNode root = parser.statement(); 1000 1001 root = parser.statement(); 1002 } 1003 1004 public void testStatementBlock_MissingSemicolon() throws Exception { 1005 Parser parser = 1006 newParser("keys = answer.collect( { entry | return entry.key } ) values = answer.collect( { entry | return entry.value })"); 1007 1008 try { 1009 try { 1010 parser.statement(); 1011 fail("should have thrown UnexpectedTokenException"); 1012 } 1013 catch( ExceptionCollector e ) { 1014 e.throwFirstChild(); 1015 } 1016 } 1017 catch (UnexpectedTokenException e) { 1018 } 1019 } 1020 1021 public void testNewExpression() throws Exception { 1022 Parser parser = newParser("new Cheese()"); 1023 1024 CSTNode root = parser.newExpression(); 1025 1026 assertNode(root, "new", Token.KEYWORD_NEW, 2); 1027 1028 { 1029 assertNode(root.getChild(0), "Cheese", Token.IDENTIFIER, 0); 1030 1031 assertNode(root.getChild(1), "<synthetic>", Token.SYNTH_LIST, 0); 1032 } 1033 } 1034 1035 public void testDatatype_NoDots() throws Exception { 1036 Parser parser = newParser("Cheese"); 1037 1038 CSTNode root = parser.datatype(); 1039 1040 assertNode(root, "Cheese", Token.IDENTIFIER, 0); 1041 } 1042 1043 public void testDatatype_OneDot() throws Exception { 1044 Parser parser = newParser("cheese.Toast"); 1045 1046 CSTNode root = parser.datatype(); 1047 1048 assertNode(root, ".", Token.DOT, 2); 1049 { 1050 assertNode(root.getChild(0), "cheese", Token.IDENTIFIER, 0); 1051 1052 assertNode(root.getChild(1), "Toast", Token.IDENTIFIER, 0); 1053 } 1054 } 1055 1056 public void testDatatype_TwoDots() throws Exception { 1057 Parser parser = newParser("toast.is.Bread"); 1058 1059 CSTNode root = parser.datatype(); 1060 1061 assertNode(root, ".", Token.DOT, 2); 1062 { 1063 assertNode(root.getChild(0), ".", Token.DOT, 2); 1064 { 1065 assertNode(root.getChild(0).getChild(0), "toast", Token.IDENTIFIER, 0); 1066 1067 assertNode(root.getChild(0).getChild(1), "is", Token.IDENTIFIER, 0); 1068 } 1069 1070 assertNode(root.getChild(1), "Bread", Token.IDENTIFIER, 0); 1071 } 1072 } 1073 1074 // ---------------------------------------------------------------------- 1075 // ---------------------------------------------------------------------- 1076 1077 protected void assertNullNode(CSTNode node, int numChildren) { 1078 assertNotNull(node); 1079 assertNull(node.getToken()); 1080 assertLength(numChildren, node.getChildren()); 1081 } 1082 1083 protected void assertNode(CSTNode node, String text, int type) { 1084 assertNotNull(node); 1085 assertNotNull(node.getToken()); 1086 assertEquals(text, node.getToken().getText()); 1087 assertEquals(type, node.getToken().getType()); 1088 } 1089 1090 protected void assertNode(CSTNode node, String text, int type, int numChildren) { 1091 assertNotNull("Node should not be null!", node); 1092 assertNotNull(node.getToken()); 1093 assertEquals(text, node.getToken().getText()); 1094 assertEquals(type, node.getToken().getType()); 1095 assertLength(numChildren, node.getChildren()); 1096 } 1097 1098 protected void assertToken(Token token, String text, int type) { 1099 assertNotNull(token); 1100 assertEquals(text, token.getText()); 1101 assertEquals(type, token.getType()); 1102 } 1103 1104 protected Parser newParser(String text) { 1105 CharStream chars = new StringCharStream(text); 1106 Lexer lexer = new Lexer(chars); 1107 TokenStream tokens = new LexerTokenStream(lexer); 1108 1109 return new Parser(tokens); 1110 } 1111 */ 1112 }