Home | History | Annotate | Download | only in steps
      1 /*
      2  * Copyright (C) 2007-2010 Jlio Vilmar Gesser.
      3  * Copyright (C) 2011, 2013-2016 The JavaParser Team.
      4  *
      5  * This file is part of JavaParser.
      6  *
      7  * JavaParser can be used either under the terms of
      8  * a) the GNU Lesser General Public License as published by
      9  *     the Free Software Foundation, either version 3 of the License, or
     10  *     (at your option) any later version.
     11  * b) the terms of the Apache License
     12  *
     13  * You should have received a copy of both licenses in LICENCE.LGPL and
     14  * LICENCE.APACHE. Please refer to those files for details.
     15  *
     16  * JavaParser is distributed in the hope that it will be useful,
     17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
     18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     19  * GNU Lesser General Public License for more details.
     20  */
     21 
     22 package com.github.javaparser.bdd.steps;
     23 
     24 import com.github.javaparser.HasParentNode;
     25 import com.github.javaparser.ast.*;
     26 import com.github.javaparser.ast.body.*;
     27 import com.github.javaparser.ast.comments.BlockComment;
     28 import com.github.javaparser.ast.comments.JavadocComment;
     29 import com.github.javaparser.ast.comments.LineComment;
     30 import com.github.javaparser.ast.expr.*;
     31 import com.github.javaparser.ast.stmt.*;
     32 import com.github.javaparser.ast.type.*;
     33 import com.github.javaparser.ast.visitor.VoidVisitorAdapter;
     34 
     35 import static org.hamcrest.Matchers.notNullValue;
     36 import static org.hamcrest.core.Is.is;
     37 import static org.junit.Assert.assertThat;
     38 
     39 /**
     40  * The <code>ExistenceOfParentNodeVerifier</code> verifies that each node of the compilation unit has a parent set.
     41  */
     42 class ExistenceOfParentNodeVerifier {
     43 
     44     public void verify(CompilationUnit compilationUnit) throws AssertionError {
     45         new Verifier().visit(compilationUnit, null);
     46     }
     47 
     48     private static class Verifier extends VoidVisitorAdapter<Void> {
     49         private static void assertParentIsSet(HasParentNode<?> n) {
     50             assertThat(n + " has no parent set!", n.getParentNode().orElse(null), is(notNullValue()));
     51         }
     52 
     53         @Override
     54         public void visit(AnnotationDeclaration n, Void arg) {
     55             assertParentIsSet(n);
     56             super.visit(n, arg);
     57         }
     58 
     59         @Override
     60         public void visit(AnnotationMemberDeclaration n, Void arg) {
     61             assertParentIsSet(n);
     62             super.visit(n, arg);
     63         }
     64 
     65         @Override
     66         public void visit(ArrayAccessExpr n, Void arg) {
     67             assertParentIsSet(n);
     68             super.visit(n, arg);
     69         }
     70 
     71         @Override
     72         public void visit(ArrayCreationExpr n, Void arg) {
     73             assertParentIsSet(n);
     74             super.visit(n, arg);
     75         }
     76 
     77         @Override
     78         public void visit(ArrayInitializerExpr n, Void arg) {
     79             assertParentIsSet(n);
     80             super.visit(n, arg);
     81         }
     82 
     83         @Override
     84         public void visit(AssertStmt n, Void arg) {
     85             assertParentIsSet(n);
     86             super.visit(n, arg);
     87         }
     88 
     89         @Override
     90         public void visit(AssignExpr n, Void arg) {
     91             assertParentIsSet(n);
     92             super.visit(n, arg);
     93         }
     94 
     95         @Override
     96         public void visit(BinaryExpr n, Void arg) {
     97             assertParentIsSet(n);
     98             super.visit(n, arg);
     99         }
    100 
    101         @Override
    102         public void visit(BlockComment n, Void arg) {
    103             super.visit(n, arg);
    104         }
    105 
    106         @Override
    107         public void visit(BlockStmt n, Void arg) {
    108             assertParentIsSet(n);
    109             super.visit(n, arg);
    110         }
    111 
    112         @Override
    113         public void visit(BooleanLiteralExpr n, Void arg) {
    114             assertParentIsSet(n);
    115             super.visit(n, arg);
    116         }
    117 
    118         @Override
    119         public void visit(BreakStmt n, Void arg) {
    120             assertParentIsSet(n);
    121             super.visit(n, arg);
    122         }
    123 
    124         @Override
    125         public void visit(CastExpr n, Void arg) {
    126             assertParentIsSet(n);
    127             super.visit(n, arg);
    128         }
    129 
    130         @Override
    131         public void visit(CatchClause n, Void arg) {
    132             assertParentIsSet(n);
    133             super.visit(n, arg);
    134         }
    135 
    136         @Override
    137         public void visit(CharLiteralExpr n, Void arg) {
    138             assertParentIsSet(n);
    139             super.visit(n, arg);
    140         }
    141 
    142         @Override
    143         public void visit(ClassExpr n, Void arg) {
    144             assertParentIsSet(n);
    145             super.visit(n, arg);
    146         }
    147 
    148         @Override
    149         public void visit(ClassOrInterfaceDeclaration n, Void arg) {
    150             assertParentIsSet(n);
    151             super.visit(n, arg);
    152         }
    153 
    154         @Override
    155         public void visit(ClassOrInterfaceType n, Void arg) {
    156             assertParentIsSet(n);
    157             super.visit(n, arg);
    158         }
    159 
    160         @Override
    161         public void visit(CompilationUnit n, Void arg) {
    162             super.visit(n, arg);
    163         }
    164 
    165         @Override
    166         public void visit(ConditionalExpr n, Void arg) {
    167             assertParentIsSet(n);
    168             super.visit(n, arg);
    169         }
    170 
    171         @Override
    172         public void visit(ConstructorDeclaration n, Void arg) {
    173             assertParentIsSet(n);
    174             super.visit(n, arg);
    175         }
    176 
    177         @Override
    178         public void visit(ContinueStmt n, Void arg) {
    179             assertParentIsSet(n);
    180             super.visit(n, arg);
    181         }
    182 
    183         @Override
    184         public void visit(DoStmt n, Void arg) {
    185             assertParentIsSet(n);
    186             super.visit(n, arg);
    187         }
    188 
    189         @Override
    190         public void visit(DoubleLiteralExpr n, Void arg) {
    191             assertParentIsSet(n);
    192             super.visit(n, arg);
    193         }
    194 
    195         @Override
    196         public void visit(EmptyStmt n, Void arg) {
    197             assertParentIsSet(n);
    198             super.visit(n, arg);
    199         }
    200 
    201         @Override
    202         public void visit(EnclosedExpr n, Void arg) {
    203             assertParentIsSet(n);
    204             super.visit(n, arg);
    205         }
    206 
    207         @Override
    208         public void visit(EnumConstantDeclaration n, Void arg) {
    209             assertParentIsSet(n);
    210             super.visit(n, arg);
    211         }
    212 
    213         @Override
    214         public void visit(EnumDeclaration n, Void arg) {
    215             assertParentIsSet(n);
    216             super.visit(n, arg);
    217         }
    218 
    219         @Override
    220         public void visit(ExplicitConstructorInvocationStmt n, Void arg) {
    221             assertParentIsSet(n);
    222             super.visit(n, arg);
    223         }
    224 
    225         @Override
    226         public void visit(ExpressionStmt n, Void arg) {
    227             assertParentIsSet(n);
    228             super.visit(n, arg);
    229         }
    230 
    231         @Override
    232         public void visit(FieldAccessExpr n, Void arg) {
    233             assertParentIsSet(n);
    234             super.visit(n, arg);
    235         }
    236 
    237         @Override
    238         public void visit(FieldDeclaration n, Void arg) {
    239             assertParentIsSet(n);
    240             super.visit(n, arg);
    241         }
    242 
    243         @Override
    244         public void visit(ForeachStmt n, Void arg) {
    245             assertParentIsSet(n);
    246             super.visit(n, arg);
    247         }
    248 
    249         @Override
    250         public void visit(ForStmt n, Void arg) {
    251             assertParentIsSet(n);
    252             super.visit(n, arg);
    253         }
    254 
    255         @Override
    256         public void visit(IfStmt n, Void arg) {
    257             assertParentIsSet(n);
    258             super.visit(n, arg);
    259         }
    260 
    261         @Override
    262         public void visit(InitializerDeclaration n, Void arg) {
    263             assertParentIsSet(n);
    264             super.visit(n, arg);
    265         }
    266 
    267         @Override
    268         public void visit(InstanceOfExpr n, Void arg) {
    269             assertParentIsSet(n);
    270             super.visit(n, arg);
    271         }
    272 
    273         @Override
    274         public void visit(IntegerLiteralExpr n, Void arg) {
    275             assertParentIsSet(n);
    276             super.visit(n, arg);
    277         }
    278 
    279         @Override
    280         public void visit(JavadocComment n, Void arg) {
    281             super.visit(n, arg);
    282         }
    283 
    284         @Override
    285         public void visit(LabeledStmt n, Void arg) {
    286             assertParentIsSet(n);
    287             super.visit(n, arg);
    288         }
    289 
    290         @Override
    291         public void visit(LineComment n, Void arg) {
    292             super.visit(n, arg);
    293         }
    294 
    295         @Override
    296         public void visit(LambdaExpr n, Void arg) {
    297             assertParentIsSet(n);
    298             super.visit(n, arg);
    299         }
    300 
    301         @Override
    302         public void visit(LongLiteralExpr n, Void arg) {
    303             assertParentIsSet(n);
    304             super.visit(n, arg);
    305         }
    306 
    307         @Override
    308         public void visit(MarkerAnnotationExpr n, Void arg) {
    309             assertParentIsSet(n);
    310             super.visit(n, arg);
    311         }
    312 
    313         @Override
    314         public void visit(MemberValuePair n, Void arg) {
    315             assertParentIsSet(n);
    316             super.visit(n, arg);
    317         }
    318 
    319         @Override
    320         public void visit(MethodCallExpr n, Void arg) {
    321             assertParentIsSet(n);
    322             super.visit(n, arg);
    323         }
    324 
    325         @Override
    326         public void visit(MethodDeclaration n, Void arg) {
    327             assertParentIsSet(n);
    328             super.visit(n, arg);
    329         }
    330 
    331         @Override
    332         public void visit(MethodReferenceExpr n, Void arg) {
    333             assertParentIsSet(n);
    334             super.visit(n, arg);
    335         }
    336 
    337         @Override
    338         public void visit(NameExpr n, Void arg) {
    339             assertParentIsSet(n);
    340             super.visit(n, arg);
    341         }
    342 
    343         @Override
    344         public void visit(NormalAnnotationExpr n, Void arg) {
    345             assertParentIsSet(n);
    346             super.visit(n, arg);
    347         }
    348 
    349         @Override
    350         public void visit(NullLiteralExpr n, Void arg) {
    351             assertParentIsSet(n);
    352             super.visit(n, arg);
    353         }
    354 
    355         @Override
    356         public void visit(ObjectCreationExpr n, Void arg) {
    357             assertParentIsSet(n);
    358             super.visit(n, arg);
    359         }
    360 
    361         @Override
    362         public void visit(PackageDeclaration n, Void arg) {
    363             assertParentIsSet(n);
    364             super.visit(n, arg);
    365         }
    366 
    367         @Override
    368         public void visit(Parameter n, Void arg) {
    369             assertParentIsSet(n);
    370             super.visit(n, arg);
    371         }
    372 
    373         @Override
    374         public void visit(PrimitiveType n, Void arg) {
    375             assertParentIsSet(n);
    376             super.visit(n, arg);
    377         }
    378 
    379         @Override
    380         public void visit(Name n, Void arg) {
    381             assertParentIsSet(n);
    382             super.visit(n, arg);
    383         }
    384 
    385         @Override
    386         public void visit(SimpleName n, Void arg) {
    387             assertParentIsSet(n);
    388             super.visit(n, arg);
    389         }
    390 
    391         @Override
    392         public void visit(ArrayType n, Void arg) {
    393             assertParentIsSet(n);
    394             super.visit(n, arg);
    395         }
    396 
    397         @Override
    398         public void visit(ArrayCreationLevel n, Void arg) {
    399             assertParentIsSet(n);
    400             super.visit(n, arg);
    401         }
    402 
    403         @Override
    404         public void visit(IntersectionType n, Void arg) {
    405             assertParentIsSet(n);
    406             super.visit(n, arg);
    407         }
    408 
    409         @Override
    410         public void visit(UnionType n, Void arg) {
    411             assertParentIsSet(n);
    412             super.visit(n, arg);
    413         }
    414 
    415         @Override
    416         public void visit(ReturnStmt n, Void arg) {
    417             assertParentIsSet(n);
    418             super.visit(n, arg);
    419         }
    420 
    421         @Override
    422         public void visit(SingleMemberAnnotationExpr n, Void arg) {
    423             assertParentIsSet(n);
    424             super.visit(n, arg);
    425         }
    426 
    427         @Override
    428         public void visit(StringLiteralExpr n, Void arg) {
    429             assertParentIsSet(n);
    430             super.visit(n, arg);
    431         }
    432 
    433         @Override
    434         public void visit(SuperExpr n, Void arg) {
    435             assertParentIsSet(n);
    436             super.visit(n, arg);
    437         }
    438 
    439         @Override
    440         public void visit(SwitchEntryStmt n, Void arg) {
    441             assertParentIsSet(n);
    442             super.visit(n, arg);
    443         }
    444 
    445         @Override
    446         public void visit(SwitchStmt n, Void arg) {
    447             assertParentIsSet(n);
    448             super.visit(n, arg);
    449         }
    450 
    451         @Override
    452         public void visit(SynchronizedStmt n, Void arg) {
    453             assertParentIsSet(n);
    454             super.visit(n, arg);
    455         }
    456 
    457         @Override
    458         public void visit(ThisExpr n, Void arg) {
    459             assertParentIsSet(n);
    460             super.visit(n, arg);
    461         }
    462 
    463         @Override
    464         public void visit(ThrowStmt n, Void arg) {
    465             assertParentIsSet(n);
    466             super.visit(n, arg);
    467         }
    468 
    469         @Override
    470         public void visit(TryStmt n, Void arg) {
    471             assertParentIsSet(n);
    472             super.visit(n, arg);
    473         }
    474 
    475         @Override
    476         public void visit(LocalClassDeclarationStmt n, Void arg) {
    477             assertParentIsSet(n);
    478             super.visit(n, arg);
    479         }
    480 
    481         @Override
    482         public void visit(TypeExpr n, Void arg) {
    483             assertParentIsSet(n);
    484             super.visit(n, arg);
    485         }
    486 
    487         @Override
    488         public void visit(NodeList n, Void arg) {
    489             assertParentIsSet(n);
    490             super.visit(n, arg);
    491         }
    492 
    493         @Override
    494         public void visit(TypeParameter n, Void arg) {
    495             assertParentIsSet(n);
    496             super.visit(n, arg);
    497         }
    498 
    499         @Override
    500         public void visit(UnaryExpr n, Void arg) {
    501             assertParentIsSet(n);
    502             super.visit(n, arg);
    503         }
    504 
    505         @Override
    506         public void visit(UnknownType n, Void arg) {
    507             assertParentIsSet(n);
    508             super.visit(n, arg);
    509         }
    510 
    511         @Override
    512         public void visit(VariableDeclarationExpr n, Void arg) {
    513             assertParentIsSet(n);
    514             super.visit(n, arg);
    515         }
    516 
    517         @Override
    518         public void visit(VariableDeclarator n, Void arg) {
    519             assertParentIsSet(n);
    520             super.visit(n, arg);
    521         }
    522 
    523         @Override
    524         public void visit(VoidType n, Void arg) {
    525             assertParentIsSet(n);
    526             super.visit(n, arg);
    527         }
    528 
    529         @Override
    530         public void visit(WhileStmt n, Void arg) {
    531             assertParentIsSet(n);
    532             super.visit(n, arg);
    533         }
    534 
    535         @Override
    536         public void visit(WildcardType n, Void arg) {
    537             assertParentIsSet(n);
    538             super.visit(n, arg);
    539         }
    540     }
    541 
    542 }
    543