Clover coverage report - DynamicJava Test Coverage (dynamicjava-20110903-r5436)
Coverage timestamp: Sat Sep 3 2011 03:02:20 CDT
Overview   Package   File
    FRAMES   NO FRAMES  
file stats: LOC: 923   Methods: 112
NCLOC: 342   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
AbstractVisitor.java - 0% 0% 0%
coverage
 1    /*
 2    * DynamicJava - Copyright (C) 1999-2001
 3    *
 4    * Permission is hereby granted, free of charge, to any person obtaining a
 5    * copy of this software and associated documentation files
 6    * (the "Software"), to deal in the Software without restriction, including
 7    * without limitation the rights to use, copy, modify, merge, publish,
 8    * distribute, sublicense, and/or sell copies of the Software, and to permit
 9    * persons to whom the Software is furnished to do so, subject to the
 10    * following conditions:
 11    * The above copyright notice and this permission notice shall be included
 12    * in all copies or substantial portions of the Software.
 13    *
 14    * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 15    * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 16    * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 17    * IN NO EVENT SHALL DYADE BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 18    * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 19    * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 20    * DEALINGS IN THE SOFTWARE.
 21    *
 22    * Except as contained in this notice, the name of Dyade shall not be
 23    * used in advertising or otherwise to promote the sale, use or other
 24    * dealings in this Software without prior written authorization from
 25    * Dyade.
 26    *
 27    */
 28   
 29    package koala.dynamicjava.tree.visitor;
 30   
 31    import koala.dynamicjava.tree.*;
 32    import koala.dynamicjava.tree.tiger.GenericReferenceTypeName;
 33    import koala.dynamicjava.tree.tiger.HookTypeName;
 34   
 35    /**
 36    * A visitor that, by default, invokes the method defaultCase(). If defaultCase is not overriden,
 37    * this results in an IllegalArgumentException.
 38    */
 39   
 40    public abstract class AbstractVisitor<T> implements Visitor<T> {
 41   
 42  0 public T defaultCase(Node node) {
 43  0 throw new IllegalArgumentException("Visitor is undefined for " + node.getClass().getName());
 44    }
 45   
 46    /**
 47    * Visits a CompilationUnit
 48    * @param node the node to visit
 49    */
 50  0 public T visit(CompilationUnit node) {
 51  0 return defaultCase(node);
 52    }
 53   
 54    /**
 55    * Visits an PackageDeclaration
 56    * @param node the node to visit
 57    */
 58  0 public T visit(PackageDeclaration node) {
 59  0 return defaultCase(node);
 60    }
 61   
 62    /**
 63    * Visits an ImportDeclaration
 64    * @param node the node to visit
 65    */
 66  0 public T visit(ImportDeclaration node) {
 67  0 return defaultCase(node);
 68    }
 69   
 70    /**
 71    * Visits an EmptyStatement
 72    * @param node the node to visit
 73    */
 74  0 public T visit(EmptyStatement node) {
 75  0 return defaultCase(node);
 76    }
 77   
 78    /**
 79    * Visits an ExpressionStatement
 80    * @param node the node to visit
 81    */
 82  0 public T visit(ExpressionStatement node) {
 83  0 return defaultCase(node);
 84    }
 85   
 86    /**
 87    * Visits a WhileStatement
 88    * @param node the node to visit
 89    */
 90  0 public T visit(WhileStatement node) {
 91  0 return defaultCase(node);
 92    }
 93   
 94    /**
 95    * Visits a ForStatement
 96    * @param node the node to visit
 97    */
 98  0 public T visit(ForStatement node) {
 99  0 return defaultCase(node);
 100    }
 101   
 102    /**
 103    * Visits a ForEachStatement
 104    * @param node the node to visit
 105    */
 106  0 public T visit(ForEachStatement node) {
 107  0 return defaultCase(node);
 108    }
 109   
 110    /**
 111    * Visits a DoStatement
 112    * @param node the node to visit
 113    */
 114  0 public T visit(DoStatement node) {
 115  0 return defaultCase(node);
 116    }
 117   
 118    /**
 119    * Visits a SwitchStatement
 120    * @param node the node to visit
 121    */
 122  0 public T visit(SwitchStatement node) {
 123  0 return defaultCase(node);
 124    }
 125   
 126    /**
 127    * Visits a SwitchBlock
 128    * @param node the node to visit
 129    */
 130  0 public T visit(SwitchBlock node) {
 131  0 return defaultCase(node);
 132    }
 133   
 134    /**
 135    * Visits a LabeledStatement
 136    * @param node the node to visit
 137    */
 138  0 public T visit(LabeledStatement node) {
 139  0 return defaultCase(node);
 140    }
 141   
 142    /**
 143    * Visits a BreakStatement
 144    * @param node the node to visit
 145    */
 146  0 public T visit(BreakStatement node) {
 147  0 return defaultCase(node);
 148    }
 149   
 150    /**
 151    * Visits a TryStatement
 152    * @param node the node to visit
 153    */
 154  0 public T visit(TryStatement node) {
 155  0 return defaultCase(node);
 156    }
 157   
 158    /**
 159    * Visits a CatchStatement
 160    * @param node the node to visit
 161    */
 162  0 public T visit(CatchStatement node) {
 163  0 return defaultCase(node);
 164    }
 165   
 166    /**
 167    * Visits a ThrowStatement
 168    * @param node the node to visit
 169    */
 170  0 public T visit(ThrowStatement node) {
 171  0 return defaultCase(node);
 172    }
 173   
 174    /**
 175    * Visits a ReturnStatement
 176    * @param node the node to visit
 177    */
 178  0 public T visit(ReturnStatement node) {
 179  0 return defaultCase(node);
 180    }
 181   
 182    /**
 183    * Visits a SynchronizedStatement
 184    * @param node the node to visit
 185    */
 186  0 public T visit(SynchronizedStatement node) {
 187  0 return defaultCase(node);
 188    }
 189   
 190    /**
 191    * Visits a ContinueStatement
 192    * @param node the node to visit
 193    */
 194  0 public T visit(ContinueStatement node) {
 195  0 return defaultCase(node);
 196    }
 197   
 198    /**
 199    * Visits a IfThenStatement
 200    * @param node the node to visit
 201    */
 202  0 public T visit(IfThenStatement node) {
 203  0 return defaultCase(node);
 204    }
 205   
 206    /**
 207    * Visits a IfThenElseStatement
 208    * @param node the node to visit
 209    */
 210  0 public T visit(IfThenElseStatement node) {
 211  0 return defaultCase(node);
 212    }
 213   
 214    /**
 215    * Visits an AssertStatement
 216    * @param node the node to visit
 217    */
 218  0 public T visit(AssertStatement node) {
 219  0 return defaultCase(node);
 220    }
 221   
 222    /**
 223    * Visits a Literal
 224    * @param node the node to visit
 225    */
 226  0 public T visit(Literal node) {
 227  0 return defaultCase(node);
 228    }
 229   
 230    /**
 231    * Visits a ThisExpression
 232    * @param node the node to visit
 233    */
 234  0 public T visit(ThisExpression node) {
 235  0 return defaultCase(node);
 236    }
 237   
 238    /**
 239    * Visits a AmbiguousName
 240    * @param node the node to visit
 241    */
 242  0 public T visit(AmbiguousName node) {
 243  0 return defaultCase(node);
 244    }
 245   
 246    /**
 247    * Visits a VariableAccess
 248    * @param node the node to visit
 249    */
 250  0 public T visit(VariableAccess node) {
 251  0 return defaultCase(node);
 252    }
 253   
 254    /**
 255    * Visits a SimpleFieldAccess
 256    * @param node the node to visit
 257    */
 258  0 public T visit(SimpleFieldAccess node) {
 259  0 return defaultCase(node);
 260    }
 261   
 262    /**
 263    * Visits a ObjectFieldAccess
 264    * @param node the node to visit
 265    */
 266  0 public T visit(ObjectFieldAccess node) {
 267  0 return defaultCase(node);
 268    }
 269   
 270    /**
 271    * Visits a StaticFieldAccess
 272    * @param node the node to visit
 273    */
 274  0 public T visit(StaticFieldAccess node) {
 275  0 return defaultCase(node);
 276    }
 277   
 278    /**
 279    * Visits a SuperFieldAccess
 280    * @param node the node to visit
 281    */
 282  0 public T visit(SuperFieldAccess node) {
 283  0 return defaultCase(node);
 284    }
 285   
 286    /**
 287    * Visits a ArrayAccess
 288    * @param node the node to visit
 289    */
 290  0 public T visit(ArrayAccess node) {
 291  0 return defaultCase(node);
 292    }
 293   
 294    /**
 295    * Visits a ObjectMethodCall
 296    * @param node the node to visit
 297    */
 298  0 public T visit(ObjectMethodCall node) {
 299  0 return defaultCase(node);
 300    }
 301   
 302    /**
 303    * Visits a SimpleMethodCall
 304    * @param node the node to visit
 305    */
 306  0 public T visit(SimpleMethodCall node) {
 307  0 return defaultCase(node);
 308    }
 309   
 310    /**
 311    * Visits a StaticMethodCall
 312    * @param node the node to visit
 313    */
 314  0 public T visit(StaticMethodCall node) {
 315  0 return defaultCase(node);
 316    }
 317   
 318    /**
 319    * Visits a ConstructorCall
 320    * @param node the node to visit
 321    */
 322  0 public T visit(ConstructorCall node) {
 323  0 return defaultCase(node);
 324    }
 325   
 326    /**
 327    * Visits a SuperMethodCall
 328    * @param node the node to visit
 329    */
 330  0 public T visit(SuperMethodCall node) {
 331  0 return defaultCase(node);
 332    }
 333   
 334    /**
 335    * Visits a BooleanTypeName
 336    * @param node the node to visit
 337    */
 338  0 public T visit(BooleanTypeName node) {
 339  0 return defaultCase(node);
 340    }
 341   
 342    /**
 343    * Visits a ByteTypeName
 344    * @param node the node to visit
 345    */
 346  0 public T visit(ByteTypeName node) {
 347  0 return defaultCase(node);
 348    }
 349   
 350    /**
 351    * Visits a ShortTypeName
 352    * @param node the node to visit
 353    */
 354  0 public T visit(ShortTypeName node) {
 355  0 return defaultCase(node);
 356    }
 357   
 358    /**
 359    * Visits a CharTypeName
 360    * @param node the node to visit
 361    */
 362  0 public T visit(CharTypeName node) {
 363  0 return defaultCase(node);
 364    }
 365   
 366    /**
 367    * Visits a IntTypeName
 368    * @param node the node to visit
 369    */
 370  0 public T visit(IntTypeName node) {
 371  0 return defaultCase(node);
 372    }
 373   
 374    /**
 375    * Visits a LongTypeName
 376    * @param node the node to visit
 377    */
 378  0 public T visit(LongTypeName node) {
 379  0 return defaultCase(node);
 380    }
 381   
 382    /**
 383    * Visits a FloatTypeName
 384    * @param node the node to visit
 385    */
 386  0 public T visit(FloatTypeName node) {
 387  0 return defaultCase(node);
 388    }
 389   
 390    /**
 391    * Visits a DoubleTypeName
 392    * @param node the node to visit
 393    */
 394  0 public T visit(DoubleTypeName node) {
 395  0 return defaultCase(node);
 396    }
 397   
 398    /**
 399    * Visits a VoidTypeName
 400    * @param node the node to visit
 401    */
 402  0 public T visit(VoidTypeName node) {
 403  0 return defaultCase(node);
 404    }
 405   
 406    /**
 407    * Visits a ReferenceTypeName
 408    * @param node the node to visit
 409    */
 410  0 public T visit(ReferenceTypeName node) {
 411  0 return defaultCase(node);
 412    }
 413   
 414    /**
 415    * Visits a GenericReferenceTypeName
 416    * @param node the node to visit
 417    */
 418  0 public T visit(GenericReferenceTypeName node) {
 419  0 return defaultCase(node);
 420    }
 421   
 422    /**
 423    * Visits a ArrayTypeName
 424    * @param node the node to visit
 425    */
 426  0 public T visit(ArrayTypeName node) {
 427  0 return defaultCase(node);
 428    }
 429   
 430    /**
 431    * Visits a HookTypeName
 432    * @param node the node to visit
 433    */
 434  0 public T visit(HookTypeName node) {
 435  0 return defaultCase(node);
 436    }
 437   
 438    /**
 439    * Visits a TypeExpression
 440    * @param node the node to visit
 441    */
 442  0 public T visit(TypeExpression node) {
 443  0 return defaultCase(node);
 444    }
 445   
 446    /**
 447    * Visits a PostIncrement
 448    * @param node the node to visit
 449    */
 450  0 public T visit(PostIncrement node) {
 451  0 return defaultCase(node);
 452    }
 453   
 454    /**
 455    * Visits a PostDecrement
 456    * @param node the node to visit
 457    */
 458  0 public T visit(PostDecrement node) {
 459  0 return defaultCase(node);
 460    }
 461   
 462    /**
 463    * Visits a PreIncrement
 464    * @param node the node to visit
 465    */
 466  0 public T visit(PreIncrement node) {
 467  0 return defaultCase(node);
 468    }
 469   
 470    /**
 471    * Visits a PreDecrement
 472    * @param node the node to visit
 473    */
 474  0 public T visit(PreDecrement node) {
 475  0 return defaultCase(node);
 476    }
 477   
 478    /**
 479    * Visits an ArrayInitializer
 480    * @param node the node to visit
 481    */
 482  0 public T visit(ArrayInitializer node) {
 483  0 return defaultCase(node);
 484    }
 485   
 486    /**
 487    * Visits an ArrayAllocation
 488    * @param node the node to visit
 489    */
 490  0 public T visit(ArrayAllocation node) {
 491  0 return defaultCase(node);
 492    }
 493   
 494    /**
 495    * Visits a SimpleAllocation
 496    * @param node the node to visit
 497    */
 498  0 public T visit(SimpleAllocation node) {
 499  0 return defaultCase(node);
 500    }
 501   
 502    /**
 503    * Visits an AnonymousAllocation
 504    * @param node the node to visit
 505    */
 506  0 public T visit(AnonymousAllocation node) {
 507  0 return defaultCase(node);
 508    }
 509   
 510    /**
 511    * Visits an InnerAllocation
 512    * @param node the node to visit
 513    */
 514  0 public T visit(InnerAllocation node) {
 515  0 return defaultCase(node);
 516    }
 517   
 518    /**
 519    * Visits an AnonymousInnerAllocation
 520    * @param node the node to visit
 521    */
 522  0 public T visit(AnonymousInnerAllocation node) {
 523  0 return defaultCase(node);
 524    }
 525   
 526    /**
 527    * Visits a CastExpression
 528    * @param node the node to visit
 529    */
 530  0 public T visit(CastExpression node) {
 531  0 return defaultCase(node);
 532    }
 533   
 534    /**
 535    * Visits a NotExpression
 536    * @param node the node to visit
 537    */
 538  0 public T visit(NotExpression node) {
 539  0 return defaultCase(node);
 540    }
 541   
 542    /**
 543    * Visits a ComplementExpression
 544    * @param node the node to visit
 545    */
 546  0 public T visit(ComplementExpression node) {
 547  0 return defaultCase(node);
 548    }
 549   
 550    /**
 551    * Visits a PlusExpression
 552    * @param node the node to visit
 553    */
 554  0 public T visit(PlusExpression node) {
 555  0 return defaultCase(node);
 556    }
 557   
 558    /**
 559    * Visits a MinusExpression
 560    * @param node the node to visit
 561    */
 562  0 public T visit(MinusExpression node) {
 563  0 return defaultCase(node);
 564    }
 565   
 566    /**
 567    * Visits a MultiplyExpression
 568    * @param node the node to visit
 569    */
 570  0 public T visit(MultiplyExpression node) {
 571  0 return defaultCase(node);
 572    }
 573   
 574    /**
 575    * Visits a DivideExpression
 576    * @param node the node to visit
 577    */
 578  0 public T visit(DivideExpression node) {
 579  0 return defaultCase(node);
 580    }
 581   
 582    /**
 583    * Visits a RemainderExpression
 584    * @param node the node to visit
 585    */
 586  0 public T visit(RemainderExpression node) {
 587  0 return defaultCase(node);
 588    }
 589   
 590    /**
 591    * Visits a AddExpression
 592    * @param node the node to visit
 593    */
 594  0 public T visit(AddExpression node) {
 595  0 return defaultCase(node);
 596    }
 597   
 598    /**
 599    * Visits a SubtractExpression
 600    * @param node the node to visit
 601    */
 602  0 public T visit(SubtractExpression node) {
 603  0 return defaultCase(node);
 604    }
 605   
 606    /**
 607    * Visits a ShiftLeftExpression
 608    * @param node the node to visit
 609    */
 610  0 public T visit(ShiftLeftExpression node) {
 611  0 return defaultCase(node);
 612    }
 613   
 614    /**
 615    * Visits a ShiftRightExpression
 616    * @param node the node to visit
 617    */
 618  0 public T visit(ShiftRightExpression node) {
 619  0 return defaultCase(node);
 620    }
 621   
 622    /**
 623    * Visits a UnsignedShiftRightExpression
 624    * @param node the node to visit
 625    */
 626  0 public T visit(UnsignedShiftRightExpression node) {
 627  0 return defaultCase(node);
 628    }
 629   
 630    /**
 631    * Visits a LessExpression
 632    * @param node the node to visit
 633    */
 634  0 public T visit(LessExpression node) {
 635  0 return defaultCase(node);
 636    }
 637   
 638    /**
 639    * Visits a GreaterExpression
 640    * @param node the node to visit
 641    */
 642  0 public T visit(GreaterExpression node) {
 643  0 return defaultCase(node);
 644    }
 645   
 646    /**
 647    * Visits a LessOrEqualExpression
 648    * @param node the node to visit
 649    */
 650  0 public T visit(LessOrEqualExpression node) {
 651  0 return defaultCase(node);
 652    }
 653   
 654    /**
 655    * Visits a GreaterOrEqualExpression
 656    * @param node the node to visit
 657    */
 658  0 public T visit(GreaterOrEqualExpression node) {
 659  0 return defaultCase(node);
 660    }
 661   
 662    /**
 663    * Visits an InstanceOfExpression
 664    * @param node the node to visit
 665    */
 666  0 public T visit(InstanceOfExpression node) {
 667  0 return defaultCase(node);
 668    }
 669   
 670    /**
 671    * Visits a EqualExpression
 672    * @param node the node to visit
 673    */
 674  0 public T visit(EqualExpression node) {
 675  0 return defaultCase(node);
 676    }
 677   
 678    /**
 679    * Visits a NotEqualExpression
 680    * @param node the node to visit
 681    */
 682  0 public T visit(NotEqualExpression node) {
 683  0 return defaultCase(node);
 684    }
 685   
 686    /**
 687    * Visits a BitAndExpression
 688    * @param node the node to visit
 689    */
 690  0 public T visit(BitAndExpression node) {
 691  0 return defaultCase(node);
 692    }
 693   
 694    /**
 695    * Visits a ExclusiveOrExpression
 696    * @param node the node to visit
 697    */
 698  0 public T visit(ExclusiveOrExpression node) {
 699  0 return defaultCase(node);
 700    }
 701   
 702    /**
 703    * Visits a BitOrExpression
 704    * @param node the node to visit
 705    */
 706  0 public T visit(BitOrExpression node) {
 707  0 return defaultCase(node);
 708    }
 709   
 710    /**
 711    * Visits a AndExpression
 712    * @param node the node to visit
 713    */
 714  0 public T visit(AndExpression node) {
 715  0 return defaultCase(node);
 716    }
 717   
 718    /**
 719    * Visits a OrExpression
 720    * @param node the node to visit
 721    */
 722  0 public T visit(OrExpression node) {
 723  0 return defaultCase(node);
 724    }
 725   
 726    /**
 727    * Visits a ConditionalExpression
 728    * @param node the node to visit
 729    */
 730  0 public T visit(ConditionalExpression node) {
 731  0 return defaultCase(node);
 732    }
 733   
 734    /**
 735    * Visits an SimpleAssignExpression
 736    * @param node the node to visit
 737    */
 738  0 public T visit(SimpleAssignExpression node) {
 739  0 return defaultCase(node);
 740    }
 741   
 742    /**
 743    * Visits an MultiplyAssignExpression
 744    * @param node the node to visit
 745    */
 746  0 public T visit(MultiplyAssignExpression node) {
 747  0 return defaultCase(node);
 748    }
 749   
 750    /**
 751    * Visits an DivideAssignExpression
 752    * @param node the node to visit
 753    */
 754  0 public T visit(DivideAssignExpression node) {
 755  0 return defaultCase(node);
 756    }
 757   
 758    /**
 759    * Visits an RemainderAssignExpression
 760    * @param node the node to visit
 761    */
 762  0 public T visit(RemainderAssignExpression node) {
 763  0 return defaultCase(node);
 764    }
 765   
 766    /**
 767    * Visits an AddAssignExpression
 768    * @param node the node to visit
 769    */
 770  0 public T visit(AddAssignExpression node) {
 771  0 return defaultCase(node);
 772    }
 773   
 774    /**
 775    * Visits an SubtractAssignExpression
 776    * @param node the node to visit
 777    */
 778  0 public T visit(SubtractAssignExpression node) {
 779  0 return defaultCase(node);
 780    }
 781   
 782    /**
 783    * Visits an ShiftLeftAssignExpression
 784    * @param node the node to visit
 785    */
 786  0 public T visit(ShiftLeftAssignExpression node) {
 787  0 return defaultCase(node);
 788    }
 789   
 790    /**
 791    * Visits an ShiftRightAssignExpression
 792    * @param node the node to visit
 793    */
 794  0 public T visit(ShiftRightAssignExpression node) {
 795  0 return defaultCase(node);
 796    }
 797   
 798    /**
 799    * Visits an UnsignedShiftRightAssignExpression
 800    * @param node the node to visit
 801    */
 802  0 public T visit(UnsignedShiftRightAssignExpression node) {
 803  0 return defaultCase(node);
 804    }
 805   
 806    /**
 807    * Visits a BitAndAssignExpression
 808    * @param node the node to visit
 809    */
 810  0 public T visit(BitAndAssignExpression node) {
 811  0 return defaultCase(node);
 812    }
 813   
 814    /**
 815    * Visits a ExclusiveOrAssignExpression
 816    * @param node the node to visit
 817    */
 818  0 public T visit(ExclusiveOrAssignExpression node) {
 819  0 return defaultCase(node);
 820    }
 821   
 822    /**
 823    * Visits a BitOrAssignExpression
 824    * @param node the node to visit
 825    */
 826  0 public T visit(BitOrAssignExpression node) {
 827  0 return defaultCase(node);
 828    }
 829   
 830    /**
 831    * Visits a BlockStatement
 832    * @param node the node to visit
 833    */
 834  0 public T visit(BlockStatement node) {
 835  0 return defaultCase(node);
 836    }
 837   
 838    /**
 839    * Visits a ClassDeclaration
 840    * @param node the node to visit
 841    */
 842  0 public T visit(ClassDeclaration node) {
 843  0 return defaultCase(node);
 844    }
 845   
 846    /**
 847    * Visits a InterfaceDeclaration
 848    * @param node the node to visit
 849    */
 850  0 public T visit(InterfaceDeclaration node) {
 851  0 return defaultCase(node);
 852    }
 853   
 854    /**
 855    * Visits a ConstructorDeclaration
 856    * @param node the node to visit
 857    */
 858  0 public T visit(ConstructorDeclaration node) {
 859  0 return defaultCase(node);
 860    }
 861   
 862    /**
 863    * Visits a MethodDeclaration
 864    * @param node the node to visit
 865    */
 866  0 public T visit(MethodDeclaration node) {
 867  0 return defaultCase(node);
 868    }
 869   
 870    /**
 871    * Visits a FormalParameter
 872    * @param node the node to visit
 873    */
 874  0 public T visit(FormalParameter node) {
 875  0 return defaultCase(node);
 876    }
 877   
 878    /**
 879    * Visits a FieldDeclaration
 880    * @param node the node to visit
 881    */
 882  0 public T visit(FieldDeclaration node) {
 883  0 return defaultCase(node);
 884    }
 885   
 886    /**
 887    * Visits a VariableDeclaration
 888    * @param node the node to visit
 889    */
 890  0 public T visit(VariableDeclaration node) {
 891  0 return defaultCase(node);
 892    }
 893   
 894  0 public T visit(EnumDeclaration.EnumConstant node) {
 895  0 return defaultCase(node);
 896    }
 897   
 898    /**
 899    * Visits a ClassInitializer
 900    * @param node the node to visit
 901    */
 902  0 public T visit(ClassInitializer node) {
 903  0 return defaultCase(node);
 904    }
 905   
 906    /**
 907    * Visits a InstanceInitializer
 908    * @param node the node to visit
 909    */
 910  0 public T visit(InstanceInitializer node) {
 911  0 return defaultCase(node);
 912    }
 913   
 914   
 915  0 public T visit(ModifierSet node) {
 916  0 return defaultCase(node);
 917    }
 918   
 919  0 public T visit(Annotation node) {
 920  0 return defaultCase(node);
 921    }
 922   
 923    }
 
CloverReport generated by Clover Code Coverage v1.3.14
Sat Sep 3 2011 03:02:20 CDT.		   Open Source License registered to the DrJava Project. This license of Clover is provided to support the development of DrJava only.