| /******************************************************************************* |
| * Copyright (c) 2000, 2009 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.wst.jsdt.core.tests.dom; |
| |
| import java.lang.reflect.Method; |
| |
| import junit.framework.Test; |
| |
| import org.eclipse.wst.jsdt.core.dom.AST; |
| import org.eclipse.wst.jsdt.core.dom.ASTMatcher; |
| import org.eclipse.wst.jsdt.core.dom.ASTNode; |
| import org.eclipse.wst.jsdt.core.dom.ASTVisitor; |
| import org.eclipse.wst.jsdt.core.dom.AnonymousClassDeclaration; |
| import org.eclipse.wst.jsdt.core.dom.ArrayAccess; |
| import org.eclipse.wst.jsdt.core.dom.ArrayCreation; |
| import org.eclipse.wst.jsdt.core.dom.ArrayInitializer; |
| import org.eclipse.wst.jsdt.core.dom.ArrayType; |
| import org.eclipse.wst.jsdt.core.dom.Assignment; |
| import org.eclipse.wst.jsdt.core.dom.Block; |
| import org.eclipse.wst.jsdt.core.dom.BlockComment; |
| import org.eclipse.wst.jsdt.core.dom.BooleanLiteral; |
| import org.eclipse.wst.jsdt.core.dom.BreakStatement; |
| import org.eclipse.wst.jsdt.core.dom.CatchClause; |
| import org.eclipse.wst.jsdt.core.dom.CharacterLiteral; |
| import org.eclipse.wst.jsdt.core.dom.ClassInstanceCreation; |
| import org.eclipse.wst.jsdt.core.dom.ConditionalExpression; |
| import org.eclipse.wst.jsdt.core.dom.ConstructorInvocation; |
| import org.eclipse.wst.jsdt.core.dom.ContinueStatement; |
| import org.eclipse.wst.jsdt.core.dom.DoStatement; |
| import org.eclipse.wst.jsdt.core.dom.EmptyStatement; |
| import org.eclipse.wst.jsdt.core.dom.EnhancedForStatement; |
| import org.eclipse.wst.jsdt.core.dom.Expression; |
| import org.eclipse.wst.jsdt.core.dom.ExpressionStatement; |
| import org.eclipse.wst.jsdt.core.dom.FieldAccess; |
| import org.eclipse.wst.jsdt.core.dom.FieldDeclaration; |
| import org.eclipse.wst.jsdt.core.dom.ForStatement; |
| import org.eclipse.wst.jsdt.core.dom.FunctionDeclaration; |
| import org.eclipse.wst.jsdt.core.dom.FunctionInvocation; |
| import org.eclipse.wst.jsdt.core.dom.FunctionRef; |
| import org.eclipse.wst.jsdt.core.dom.FunctionRefParameter; |
| import org.eclipse.wst.jsdt.core.dom.IfStatement; |
| import org.eclipse.wst.jsdt.core.dom.ImportDeclaration; |
| import org.eclipse.wst.jsdt.core.dom.InfixExpression; |
| import org.eclipse.wst.jsdt.core.dom.Initializer; |
| import org.eclipse.wst.jsdt.core.dom.JSdoc; |
| import org.eclipse.wst.jsdt.core.dom.JavaScriptUnit; |
| import org.eclipse.wst.jsdt.core.dom.LabeledStatement; |
| import org.eclipse.wst.jsdt.core.dom.LineComment; |
| import org.eclipse.wst.jsdt.core.dom.MemberRef; |
| import org.eclipse.wst.jsdt.core.dom.Modifier; |
| import org.eclipse.wst.jsdt.core.dom.Name; |
| import org.eclipse.wst.jsdt.core.dom.NullLiteral; |
| import org.eclipse.wst.jsdt.core.dom.NumberLiteral; |
| import org.eclipse.wst.jsdt.core.dom.PackageDeclaration; |
| import org.eclipse.wst.jsdt.core.dom.ParenthesizedExpression; |
| import org.eclipse.wst.jsdt.core.dom.PostfixExpression; |
| import org.eclipse.wst.jsdt.core.dom.PrefixExpression; |
| import org.eclipse.wst.jsdt.core.dom.PrimitiveType; |
| import org.eclipse.wst.jsdt.core.dom.QualifiedName; |
| import org.eclipse.wst.jsdt.core.dom.QualifiedType; |
| import org.eclipse.wst.jsdt.core.dom.ReturnStatement; |
| import org.eclipse.wst.jsdt.core.dom.SimpleName; |
| import org.eclipse.wst.jsdt.core.dom.SimpleType; |
| import org.eclipse.wst.jsdt.core.dom.SingleVariableDeclaration; |
| import org.eclipse.wst.jsdt.core.dom.Statement; |
| import org.eclipse.wst.jsdt.core.dom.StringLiteral; |
| import org.eclipse.wst.jsdt.core.dom.SuperConstructorInvocation; |
| import org.eclipse.wst.jsdt.core.dom.SuperFieldAccess; |
| import org.eclipse.wst.jsdt.core.dom.SuperMethodInvocation; |
| import org.eclipse.wst.jsdt.core.dom.SwitchCase; |
| import org.eclipse.wst.jsdt.core.dom.SwitchStatement; |
| import org.eclipse.wst.jsdt.core.dom.TagElement; |
| import org.eclipse.wst.jsdt.core.dom.TextElement; |
| import org.eclipse.wst.jsdt.core.dom.ThisExpression; |
| import org.eclipse.wst.jsdt.core.dom.ThrowStatement; |
| import org.eclipse.wst.jsdt.core.dom.TryStatement; |
| import org.eclipse.wst.jsdt.core.dom.Type; |
| import org.eclipse.wst.jsdt.core.dom.TypeDeclaration; |
| import org.eclipse.wst.jsdt.core.dom.TypeDeclarationStatement; |
| import org.eclipse.wst.jsdt.core.dom.TypeLiteral; |
| import org.eclipse.wst.jsdt.core.dom.VariableDeclarationExpression; |
| import org.eclipse.wst.jsdt.core.dom.VariableDeclarationFragment; |
| import org.eclipse.wst.jsdt.core.dom.VariableDeclarationStatement; |
| import org.eclipse.wst.jsdt.core.dom.WhileStatement; |
| |
| /** |
| * Test suite for <code>ASTMatcher</code> and <code>ASTNode.subtreeMatch</code>. |
| */ |
| public class ASTMatcherTest extends org.eclipse.wst.jsdt.core.tests.junit.extension.TestCase { |
| |
| /** @deprecated using deprecated code */ |
| public static Test suite() { |
| // TODO (frederic) use buildList + setAstLevel(init) instead... |
| junit.framework.TestSuite suite = new junit.framework.TestSuite(ASTMatcherTest.class.getName()); |
| |
| Class c = ASTMatcherTest.class; |
| Method[] methods = c.getMethods(); |
| for (int i = 0, max = methods.length; i < max; i++) { |
| if (methods[i].getName().startsWith("test")) { //$NON-NLS-1$ |
| suite.addTest(new ASTMatcherTest(methods[i].getName(), AST.JLS3)); |
| } |
| } |
| return suite; |
| } |
| |
| AST ast; |
| SimpleName N1; |
| SimpleName N2; |
| SimpleName N3; |
| SimpleName N4; |
| Expression E1; |
| Expression E2; |
| Type T1; |
| String T1S; |
| Type T2; |
| String T2S; |
| String PT1S; |
| Statement S1; |
| Statement S2; |
| Block B1; |
| SingleVariableDeclaration V1; |
| SingleVariableDeclaration V2; |
| VariableDeclarationFragment W1; |
| VariableDeclarationFragment W2; |
| FieldDeclaration FD1; |
| FieldDeclaration FD2; |
| PackageDeclaration PD1; |
| ImportDeclaration ID1; |
| ImportDeclaration ID2; |
| TypeDeclaration TD1; |
| TypeDeclaration TD2; |
| AnonymousClassDeclaration ACD1; |
| JSdoc JD1; |
| JSdoc JD2; |
| String JD2S; |
| String TP1S; |
| String TP2S; |
| TagElement TAG1; |
| TagElement TAG2; |
| TextElement TEXT1; |
| MemberRef MBREF1; |
| FunctionRef MTHREF1; |
| FunctionRefParameter MPARM1; |
| LineComment LC1; |
| BlockComment BC1; |
| Modifier MOD1; |
| Modifier MOD2; |
| |
| final StringBuffer b = new StringBuffer(); |
| |
| int API_LEVEL; |
| |
| public ASTMatcherTest(String name, int apiLevel) { |
| super(name); |
| this.API_LEVEL = apiLevel; |
| } |
| |
| /** |
| * @deprecated (not really - just suppressing the warnings |
| * that come from testing Javadoc.getComment()) |
| * |
| */ |
| protected void setUp() throws Exception { |
| super.setUp(); |
| |
| ast = AST.newAST(this.API_LEVEL); |
| N1 = ast.newSimpleName("N"); //$NON-NLS-1$ |
| N2 = ast.newSimpleName("M"); //$NON-NLS-1$ |
| N3 = ast.newSimpleName("O"); //$NON-NLS-1$ |
| N4 = ast.newSimpleName("P"); //$NON-NLS-1$ |
| E1 = ast.newSimpleName("X"); //$NON-NLS-1$ |
| E2 = ast.newSimpleName("Y"); //$NON-NLS-1$ |
| T1 = ast.newSimpleType(ast.newSimpleName("Z")); //$NON-NLS-1$ |
| T1S = "(tS(nSZZnS)tS)"; //$NON-NLS-1$ |
| T2 = ast.newSimpleType(ast.newSimpleName("Y")); //$NON-NLS-1$ |
| T2S = "(tS(nSYYnS)tS)"; //$NON-NLS-1$ |
| S1 = ast.newContinueStatement(); |
| S2 = ast.newBreakStatement(); |
| B1 = ast.newBlock(); |
| V1 = ast.newSingleVariableDeclaration(); |
| V1.setType(ast.newPrimitiveType(PrimitiveType.INT)); |
| V1.setName(ast.newSimpleName("a")); //$NON-NLS-1$ |
| V2 = ast.newSingleVariableDeclaration(); |
| V2.setType(ast.newPrimitiveType(PrimitiveType.BYTE)); |
| V2.setName(ast.newSimpleName("b")); //$NON-NLS-1$ |
| W1 = ast.newVariableDeclarationFragment(); |
| W1.setName(ast.newSimpleName("a")); //$NON-NLS-1$ |
| W2 = ast.newVariableDeclarationFragment(); |
| W2.setName(ast.newSimpleName("b")); //$NON-NLS-1$ |
| { |
| VariableDeclarationFragment temp = ast.newVariableDeclarationFragment(); |
| temp.setName(ast.newSimpleName("f")); //$NON-NLS-1$ |
| FD1 = ast.newFieldDeclaration(temp); |
| FD1.setType(ast.newPrimitiveType(PrimitiveType.INT)); |
| } |
| { |
| VariableDeclarationFragment temp = ast.newVariableDeclarationFragment(); |
| temp.setName(ast.newSimpleName("g")); //$NON-NLS-1$ |
| FD2 = ast.newFieldDeclaration(temp); |
| FD2.setType(ast.newPrimitiveType(PrimitiveType.CHAR)); |
| } |
| PD1 = ast.newPackageDeclaration(); |
| PD1.setName(ast.newSimpleName("p")); //$NON-NLS-1$ |
| ID1 = ast.newImportDeclaration(); |
| ID1.setName(ast.newSimpleName("i")); //$NON-NLS-1$ |
| ID2 = ast.newImportDeclaration(); |
| ID2.setName(ast.newSimpleName("j")); //$NON-NLS-1$ |
| TD1 = ast.newTypeDeclaration(); |
| TD1.setName(ast.newSimpleName("c")); //$NON-NLS-1$ |
| TD2 = ast.newTypeDeclaration(); |
| TD2.setName(ast.newSimpleName("d")); //$NON-NLS-1$ |
| |
| ACD1 = ast.newAnonymousClassDeclaration(); |
| |
| JD1 = ast.newJSdoc(); |
| JD2 = ast.newJSdoc(); |
| if (ast.apiLevel() == AST.JLS2) { |
| JD1.setComment("/**X*/"); //$NON-NLS-1$ |
| JD2.setComment("/**Y*/"); //$NON-NLS-1$ |
| } |
| |
| BC1 = ast.newBlockComment(); |
| |
| TAG1 = ast.newTagElement(); |
| TAG1.setTagName("@foo"); //$NON-NLS-1$ |
| |
| TAG2 = ast.newTagElement(); |
| TAG2.setTagName("@bar"); //$NON-NLS-1$ |
| |
| TEXT1 = ast.newTextElement(); |
| TEXT1.setText("foo"); //$NON-NLS-1$ |
| |
| MBREF1 = ast.newMemberRef(); |
| MBREF1.setName(ast.newSimpleName("p")); //$NON-NLS-1$ |
| |
| MTHREF1 = ast.newFunctionRef(); |
| MTHREF1.setName(ast.newSimpleName("p")); //$NON-NLS-1$ |
| |
| MPARM1 = ast.newFunctionRefParameter(); |
| MPARM1.setType(ast.newPrimitiveType(PrimitiveType.CHAR)); |
| |
| if (ast.apiLevel() >= AST.JLS3) { |
| PT1S = "[(tM[(tS[(nSZZnS)]tS)]tM)]"; //$NON-NLS-1$ |
| |
| TP1S = "[(tTP[(nSxxnS)]tTP)]"; //$NON-NLS-1$ |
| |
| TP2S = "[(tTP[(nSyynS)]tTP)]"; //$NON-NLS-1$ |
| LC1 = ast.newLineComment(); |
| |
| |
| MOD1 = ast.newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD); |
| MOD2 = ast.newModifier(Modifier.ModifierKeyword.FINAL_KEYWORD); |
| |
| } |
| |
| } |
| |
| protected void tearDown() throws Exception { |
| ast = null; |
| super.tearDown(); |
| } |
| |
| /** @deprecated using deprecated code */ |
| public String getName() { |
| String name = super.getName(); |
| switch (this.API_LEVEL) { |
| case AST.JLS2: |
| name = "JLS2 - " + name; |
| break; |
| case AST.JLS3: |
| name = "JLS3 - " + name; |
| break; |
| } |
| return name; |
| } |
| |
| /** |
| * An ASTMatcher that simply records the arguments it is passed, |
| * immediately returns a pre-ordained answer, and counts how many |
| * times it is called. |
| */ |
| class TestMatcher extends ASTMatcher { |
| |
| public Object receiverNode; |
| public Object otherNode; |
| public boolean result; |
| public boolean superMatch; |
| public boolean superMatchResult; |
| public int matchCalls = 0; |
| |
| TestMatcher() { |
| this(false); |
| } |
| |
| TestMatcher(boolean visitDocTags) { |
| super(visitDocTags); |
| } |
| |
| boolean standardBody(ASTNode receiver, Object other, boolean matchResult) { |
| matchCalls++; |
| this.receiverNode = receiver; |
| this.otherNode = other; |
| this.superMatchResult = matchResult; |
| if (superMatch) { |
| return this.superMatchResult; |
| } |
| return this.result; |
| } |
| |
| public boolean match(AnonymousClassDeclaration node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(ArrayAccess node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(ArrayCreation node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(ArrayInitializer node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(ArrayType node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(Assignment node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(Block node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(BlockComment node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(BooleanLiteral node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(BreakStatement node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(CatchClause node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(CharacterLiteral node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(ClassInstanceCreation node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(JavaScriptUnit node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(ConditionalExpression node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(ConstructorInvocation node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(ContinueStatement node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(DoStatement node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(EmptyStatement node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(EnhancedForStatement node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(ExpressionStatement node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(FieldAccess node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(FieldDeclaration node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(ForStatement node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(IfStatement node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(ImportDeclaration node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(InfixExpression node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(Initializer node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(JSdoc node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(LabeledStatement node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(LineComment node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(MemberRef node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(FunctionDeclaration node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(FunctionInvocation node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(FunctionRef node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(FunctionRefParameter node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(Modifier node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(NullLiteral node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(NumberLiteral node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(PackageDeclaration node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(ParenthesizedExpression node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(PostfixExpression node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(PrefixExpression node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(PrimitiveType node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(QualifiedName node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(QualifiedType node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(ReturnStatement node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(SimpleName node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(SimpleType node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(SingleVariableDeclaration node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(StringLiteral node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(SuperConstructorInvocation node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(SuperFieldAccess node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(SuperMethodInvocation node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(SwitchCase node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(SwitchStatement node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| |
| public boolean match(TagElement node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(TextElement node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(ThisExpression node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(ThrowStatement node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(TryStatement node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(TypeDeclaration node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(TypeDeclarationStatement node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(TypeLiteral node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(VariableDeclarationExpression node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(VariableDeclarationFragment node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(VariableDeclarationStatement node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| public boolean match(WhileStatement node, Object other) { |
| return standardBody(node, other, superMatch ? super.match(node, other) : false); |
| } |
| } |
| |
| /** |
| * AST node visitor that counts the nodes visited. |
| */ |
| static class NodeCounter extends ASTVisitor { |
| public NodeCounter(boolean visitDocTags) { |
| super(visitDocTags); |
| } |
| |
| public int count = 0; |
| |
| /* (no javadoc for this method) |
| * Method declared on ASTVisitor. |
| */ |
| public void preVisit(ASTNode node) { |
| count++; |
| } |
| |
| } |
| |
| /** |
| * Returns the number of AST nodes in the given subtree. |
| * |
| * @param node the root of the subtree |
| * @param visitDocTags true if doc tags should be visited |
| * @return the number of nodes (always positive) |
| */ |
| static int nodeCount(ASTNode node, boolean visitDocTags) { |
| NodeCounter c = new NodeCounter(visitDocTags); |
| node.accept(c); |
| return c.count; |
| } |
| |
| /** |
| * Checks that the ASTNode.subtreeMatch mechanism is working |
| * for a node of a given type. |
| */ |
| void basicMatch(ASTNode node) { |
| TestMatcher[] m = { |
| new TestMatcher(), |
| new TestMatcher(true), |
| new TestMatcher(false)}; |
| for (int i = 0; i < m.length; i++) { |
| // check that matcher was called with right arguments |
| // and that matches succeed |
| TestMatcher m1 = m[i]; |
| Object o1 = new Object(); |
| m1.result = true; |
| boolean result = node.subtreeMatch(m1, o1); |
| assertTrue(m1.matchCalls == 1); |
| assertTrue(m1.receiverNode == node); |
| assertTrue(m1.otherNode == o1); |
| assertTrue(result == true); |
| } |
| |
| m = new TestMatcher[] { |
| new TestMatcher(), |
| new TestMatcher(true), |
| new TestMatcher(false)}; |
| for (int i = 0; i < m.length; i++) { |
| // check that matcher was called with right arguments |
| // and that non-matches fail |
| TestMatcher m1 = m[i]; |
| Object o1 = new Object(); |
| m1.result = false; |
| boolean result = node.subtreeMatch(m1, o1); |
| assertTrue(m1.matchCalls == 1); |
| assertTrue(m1.receiverNode == node); |
| assertTrue(m1.otherNode == o1); |
| assertTrue(result == false); |
| } |
| |
| // check that ASTMatcher() default implementations delegate |
| { |
| int count = nodeCount(node, false); // ignore doc tags |
| TestMatcher m1 = new TestMatcher(); |
| m1.superMatch = true; |
| boolean result = node.subtreeMatch(m1, node); |
| assertTrue(m1.matchCalls == count); |
| assertTrue(result == true); |
| } |
| |
| // check that ASTMatcher(false) default implementations delegate |
| { |
| int count = nodeCount(node, false); // ignore doc tags |
| TestMatcher m1 = new TestMatcher(false); |
| m1.superMatch = true; |
| boolean result = node.subtreeMatch(m1, node); |
| assertTrue(m1.matchCalls == count); |
| assertTrue(result == true); |
| } |
| |
| // check that ASTMatcher(true) default implementations delegate |
| { |
| int count = nodeCount(node, true); // include doc tags |
| TestMatcher m1 = new TestMatcher(true); |
| m1.superMatch = true; |
| boolean result = node.subtreeMatch(m1, node); |
| assertTrue(m1.matchCalls == count); |
| assertTrue(result == true); |
| } |
| |
| } |
| |
| // NAMES |
| public void testSimpleName() { |
| Name x1 = ast.newName(new String[]{"Z"}); //$NON-NLS-1$ |
| basicMatch(x1); |
| } |
| |
| public void testQualifiedName() { |
| Name x1 = ast.newName(new String[]{"X", "Y"}); //$NON-NLS-1$ //$NON-NLS-2$ |
| basicMatch(x1); |
| } |
| |
| |
| // TYPES |
| public void testPrimitiveType() { |
| Type x1 = ast.newPrimitiveType(PrimitiveType.CHAR); |
| basicMatch(x1); |
| } |
| |
| public void testSimpleType() { |
| Type x1 = ast.newSimpleType(N1); |
| basicMatch(x1); |
| } |
| |
| public void testArrayType() { |
| Type x0 = ast.newPrimitiveType(PrimitiveType.CHAR); |
| Type x1 = ast.newArrayType(x0); |
| basicMatch(x1); |
| } |
| |
| /** @deprecated using deprecated code */ |
| public void testQualifiedType() { |
| if (ast.apiLevel() == AST.JLS2) { |
| return; |
| } |
| Type x1 = ast.newQualifiedType(T1, N1); |
| basicMatch(x1); |
| } |
| |
| // EXPRESSIONS and STATEMENTS |
| |
| public void testAnonymousClassDeclaration() { |
| AnonymousClassDeclaration x1 = ast.newAnonymousClassDeclaration(); |
| x1.bodyDeclarations().add(FD1); |
| x1.bodyDeclarations().add(FD2); |
| basicMatch(x1); |
| } |
| public void testArrayAccess() { |
| ArrayAccess x1 = ast.newArrayAccess(); |
| x1.setArray(E1); |
| x1.setIndex(E2); |
| basicMatch(x1); |
| } |
| public void testArrayCreation() { |
| ArrayCreation x1 = ast.newArrayCreation(); |
| x1.setType(ast.newArrayType(T1)); |
| x1.dimensions().add(E1); |
| x1.dimensions().add(E2); |
| x1.setInitializer(ast.newArrayInitializer()); |
| basicMatch(x1); |
| } |
| public void testArrayInitializer() { |
| ArrayInitializer x1 = ast.newArrayInitializer(); |
| x1.expressions().add(E1); |
| x1.expressions().add(E2); |
| basicMatch(x1); |
| } |
| public void testAssignment() { |
| Assignment x1 = ast.newAssignment(); |
| x1.setLeftHandSide(E1); |
| x1.setRightHandSide(E2); |
| basicMatch(x1); |
| } |
| public void testBlock() { |
| Block x1 = ast.newBlock(); |
| x1.statements().add(S1); |
| x1.statements().add(S2); |
| basicMatch(x1); |
| } |
| |
| public void testBlockComment() { |
| BlockComment x1 = ast.newBlockComment(); |
| basicMatch(x1); |
| } |
| |
| public void testBooleanLiteral() { |
| BooleanLiteral x1 = ast.newBooleanLiteral(true); |
| basicMatch(x1); |
| } |
| public void testBreakStatement() { |
| BreakStatement x1 = ast.newBreakStatement(); |
| x1.setLabel(N1); |
| basicMatch(x1); |
| } |
| public void testCatchClause() { |
| CatchClause x1 = ast.newCatchClause(); |
| x1.setException(V1); |
| x1.setBody(B1); |
| basicMatch(x1); |
| } |
| public void testCharacterLiteral() { |
| CharacterLiteral x1 = ast.newCharacterLiteral(); |
| x1.setCharValue('q'); |
| basicMatch(x1); |
| } |
| /** @deprecated using deprecated code */ |
| public void testClassInstanceCreation() { |
| ClassInstanceCreation x1 = ast.newClassInstanceCreation(); |
| x1.setExpression(E1); |
| if (ast.apiLevel() == AST.JLS2) { |
| x1.setName(N1); |
| } else { |
| x1.setType(T1); |
| } |
| x1.setAnonymousClassDeclaration(ACD1); |
| basicMatch(x1); |
| } |
| public void testConditionalExpression() { |
| ConditionalExpression x1 = ast.newConditionalExpression(); |
| x1.setExpression(E1); |
| x1.setThenExpression(E2); |
| x1.setElseExpression(N1); |
| basicMatch(x1); |
| } |
| public void testConstructorInvocation() { |
| ConstructorInvocation x1 = ast.newConstructorInvocation(); |
| |
| x1.arguments().add(E1); |
| x1.arguments().add(E2); |
| basicMatch(x1); |
| } |
| public void testContinueStatement() { |
| ContinueStatement x1 = ast.newContinueStatement(); |
| x1.setLabel(N1); |
| basicMatch(x1); |
| } |
| public void testDoStatement() { |
| DoStatement x1 = ast.newDoStatement(); |
| x1.setExpression(E1); |
| x1.setBody(S1); |
| basicMatch(x1); |
| } |
| public void testEmptyStatement() { |
| EmptyStatement x1 = ast.newEmptyStatement(); |
| basicMatch(x1); |
| } |
| /** @deprecated using deprecated code */ |
| public void testEnhancedForStatement() { |
| if (ast.apiLevel() == AST.JLS2) { |
| return; |
| } |
| EnhancedForStatement x1 = ast.newEnhancedForStatement(); |
| x1.setParameter(V1); |
| x1.setExpression(E1); |
| x1.setBody(S1); |
| basicMatch(x1); |
| } |
| public void testExpressionStatement() { |
| ExpressionStatement x1 = ast.newExpressionStatement(E1); |
| basicMatch(x1); |
| } |
| public void testFieldAccess() { |
| FieldAccess x1 = ast.newFieldAccess(); |
| x1.setExpression(E1); |
| x1.setName(N1); |
| basicMatch(x1); |
| } |
| public void testFieldDeclaration() { |
| FieldDeclaration x1 = ast.newFieldDeclaration(W1); |
| x1.setJavadoc(JD1); |
| if (ast.apiLevel() >= AST.JLS3) { |
| x1.modifiers().add(MOD1); |
| x1.modifiers().add(MOD2); |
| } |
| x1.setType(T1); |
| x1.fragments().add(W2); |
| basicMatch(x1); |
| } |
| public void testForStatement() { |
| ForStatement x1 = ast.newForStatement(); |
| x1.initializers().add(E1); |
| x1.initializers().add(E2); |
| x1.setExpression(N1); |
| x1.updaters().add(N2); |
| x1.updaters().add(N3); |
| x1.setBody(S1); |
| basicMatch(x1); |
| } |
| public void testIfStatement() { |
| IfStatement x1 = ast.newIfStatement(); |
| x1.setExpression(E1); |
| x1.setThenStatement(S1); |
| x1.setElseStatement(S2); |
| basicMatch(x1); |
| } |
| public void testImportDeclaration() { |
| ImportDeclaration x1 = ast.newImportDeclaration(); |
| x1.setName(N1); |
| basicMatch(x1); |
| } |
| public void testInfixExpression() { |
| InfixExpression x1 = ast.newInfixExpression(); |
| x1.setOperator(InfixExpression.Operator.PLUS); |
| x1.setLeftOperand(E1); |
| x1.setRightOperand(E2); |
| x1.extendedOperands().add(N1); |
| x1.extendedOperands().add(N2); |
| basicMatch(x1); |
| } |
| public void testInitializer() { |
| Initializer x1 = ast.newInitializer(); |
| x1.setJavadoc(JD1); |
| if (ast.apiLevel() >= AST.JLS3) { |
| x1.modifiers().add(MOD1); |
| x1.modifiers().add(MOD2); |
| } |
| x1.setBody(B1); |
| basicMatch(x1); |
| } |
| /** |
| * @deprecated (not really - just suppressing the warnings |
| * that come from testing Javadoc.getComment()) |
| * |
| */ |
| public void testJavadoc() { |
| JSdoc x1 = ast.newJSdoc(); |
| if (ast.apiLevel() == AST.JLS2) { |
| x1.setComment("/**?*/"); //$NON-NLS-1$ |
| } |
| x1.tags().add(TAG1); |
| x1.tags().add(TAG2); |
| basicMatch(x1); |
| } |
| |
| public void testLabeledStatement() { |
| LabeledStatement x1 = ast.newLabeledStatement(); |
| x1.setLabel(N1); |
| x1.setBody(S1); |
| basicMatch(x1); |
| } |
| |
| public void testLineComment() { |
| LineComment x1 = ast.newLineComment(); |
| basicMatch(x1); |
| } |
| |
| public void testMemberRef() { |
| MemberRef x1 = ast.newMemberRef(); |
| x1.setQualifier(N1); |
| x1.setName(N2); |
| basicMatch(x1); |
| } |
| |
| /** @deprecated using deprecated code */ |
| public void testMethodDeclaration() { |
| FunctionDeclaration x1 = ast.newFunctionDeclaration(); |
| x1.setJavadoc(JD1); |
| if (ast.apiLevel() == AST.JLS2) { |
| x1.setReturnType(T1); |
| } else { |
| x1.modifiers().add(MOD1); |
| x1.modifiers().add(MOD2); |
| x1.setReturnType2(T1); |
| } |
| x1.setName(N1); |
| x1.parameters().add(V1); |
| x1.parameters().add(V2); |
| x1.thrownExceptions().add(N2); |
| x1.thrownExceptions().add(N3); |
| x1.setBody(B1); |
| basicMatch(x1); |
| } |
| public void testMethodInvocation() { |
| FunctionInvocation x1 = ast.newFunctionInvocation(); |
| x1.setExpression(N1); |
| |
| x1.setName(N2); |
| x1.arguments().add(E1); |
| x1.arguments().add(E2); |
| basicMatch(x1); |
| } |
| |
| public void testMethodRef() { |
| FunctionRef x1 = ast.newFunctionRef(); |
| basicMatch(x1); |
| x1.setQualifier(N1); |
| x1.setName(N2); |
| x1.parameters().add(MPARM1); |
| } |
| public void testMethodRefParameter() { |
| FunctionRefParameter x1 = ast.newFunctionRefParameter(); |
| x1.setType(T1); |
| x1.setName(N1); |
| basicMatch(x1); |
| } |
| |
| public void testNullLiteral() { |
| NullLiteral x1 = ast.newNullLiteral(); |
| basicMatch(x1); |
| } |
| public void testNumberLiteral() { |
| NumberLiteral x1 = ast.newNumberLiteral("1.0"); //$NON-NLS-1$ |
| basicMatch(x1); |
| } |
| public void testParenthesizedExpression() { |
| ParenthesizedExpression x1 = ast.newParenthesizedExpression(); |
| basicMatch(x1); |
| } |
| public void testPostfixExpression() { |
| PostfixExpression x1 = ast.newPostfixExpression(); |
| x1.setOperand(E1); |
| x1.setOperator(PostfixExpression.Operator.INCREMENT); |
| basicMatch(x1); |
| } |
| public void testPrefixExpression() { |
| PrefixExpression x1 = ast.newPrefixExpression(); |
| x1.setOperand(E1); |
| x1.setOperator(PrefixExpression.Operator.INCREMENT); |
| basicMatch(x1); |
| } |
| public void testReturnStatement() { |
| ReturnStatement x1 = ast.newReturnStatement(); |
| x1.setExpression(E1); |
| basicMatch(x1); |
| } |
| public void testSingleVariableDeclaration() { |
| SingleVariableDeclaration x1 = ast.newSingleVariableDeclaration(); |
| if (ast.apiLevel() >= AST.JLS3) { |
| x1.modifiers().add(MOD1); |
| x1.modifiers().add(MOD2); |
| } |
| x1.setType(T1); |
| x1.setName(N1); |
| x1.setInitializer(E1); |
| basicMatch(x1); |
| } |
| public void testStringLiteral() { |
| StringLiteral x1 = ast.newStringLiteral(); |
| x1.setLiteralValue("H"); //$NON-NLS-1$ |
| basicMatch(x1); |
| } |
| public void testSuperConstructorInvocation() { |
| SuperConstructorInvocation x1 = ast.newSuperConstructorInvocation(); |
| x1.setExpression(N1); |
| |
| x1.arguments().add(E1); |
| x1.arguments().add(E2); |
| basicMatch(x1); |
| } |
| public void testSuperFieldAccess() { |
| SuperFieldAccess x1 = ast.newSuperFieldAccess(); |
| x1.setQualifier(N1); |
| x1.setName(N2); |
| basicMatch(x1); |
| } |
| public void testSuperMethodInvocation() { |
| SuperMethodInvocation x1 = ast.newSuperMethodInvocation(); |
| x1.setQualifier(N1); |
| |
| x1.setName(N2); |
| x1.arguments().add(E1); |
| x1.arguments().add(E2); |
| basicMatch(x1); |
| } |
| public void testSwitchCase() { |
| SwitchCase x1 = ast.newSwitchCase(); |
| x1.setExpression(E1); |
| basicMatch(x1); |
| } |
| public void testSwitchStatement() { |
| SwitchStatement x1 = ast.newSwitchStatement(); |
| x1.setExpression(E1); |
| x1.statements().add(S1); |
| x1.statements().add(S2); |
| basicMatch(x1); |
| } |
| |
| public void testTagElement() { |
| TagElement x1 = ast.newTagElement(); |
| x1.setTagName("@foo"); //$NON-NLS-1$ |
| x1.fragments().add(TAG1); |
| x1.fragments().add(TEXT1); |
| x1.fragments().add(N1); |
| x1.fragments().add(MTHREF1); |
| basicMatch(x1); |
| } |
| public void testTextElement() { |
| TextElement x1 = ast.newTextElement(); |
| x1.setText("foo"); //$NON-NLS-1$ |
| basicMatch(x1); |
| } |
| |
| public void testThisExpression() { |
| ThisExpression x1 = ast.newThisExpression(); |
| x1.setQualifier(N1); |
| basicMatch(x1); |
| } |
| public void testThrowStatement() { |
| ThrowStatement x1 = ast.newThrowStatement(); |
| x1.setExpression(E1); |
| basicMatch(x1); |
| } |
| public void testTryStatement() { |
| TryStatement x1 = ast.newTryStatement(); |
| x1.setBody(B1); |
| CatchClause c1 = ast.newCatchClause(); |
| c1.setException(V1); |
| c1.setBody(ast.newBlock()); |
| x1.catchClauses().add(c1); |
| CatchClause c2 = ast.newCatchClause(); |
| c2.setException(V2); |
| c2.setBody(ast.newBlock()); |
| x1.catchClauses().add(c2); |
| x1.setFinally(ast.newBlock()); |
| basicMatch(x1); |
| } |
| /** @deprecated using deprecated code */ |
| public void testTypeDeclaration() { |
| TypeDeclaration x1 = ast.newTypeDeclaration(); |
| x1.setJavadoc(JD1); |
| x1.setName(N1); |
| if (ast.apiLevel() == AST.JLS2) { |
| x1.setSuperclass(N2); |
| } else { |
| x1.modifiers().add(MOD1); |
| x1.modifiers().add(MOD2); |
| } |
| x1.bodyDeclarations().add(FD1); |
| x1.bodyDeclarations().add(FD2); |
| basicMatch(x1); |
| } |
| public void testTypeDeclarationStatement() { |
| TypeDeclarationStatement x1 = ast.newTypeDeclarationStatement(TD1); |
| basicMatch(x1); |
| } |
| public void testTypeLiteral() { |
| TypeLiteral x1 = ast.newTypeLiteral(); |
| x1.setType(T1); |
| basicMatch(x1); |
| } |
| public void testVariableDeclarationFragment() { |
| VariableDeclarationFragment x1 = ast.newVariableDeclarationFragment(); |
| x1.setName(N1); |
| x1.setInitializer(E1); |
| basicMatch(x1); |
| } |
| public void testVariableDeclarationExpression() { |
| VariableDeclarationExpression x1 = ast.newVariableDeclarationExpression(W1); |
| if (ast.apiLevel() >= AST.JLS3) { |
| x1.modifiers().add(MOD1); |
| x1.modifiers().add(MOD2); |
| } |
| x1.setType(T1); |
| x1.fragments().add(W2); |
| basicMatch(x1); |
| } |
| public void testVariableDeclarationStatement() { |
| VariableDeclarationStatement x1 = ast.newVariableDeclarationStatement(W1); |
| if (ast.apiLevel() >= AST.JLS3) { |
| x1.modifiers().add(MOD1); |
| x1.modifiers().add(MOD2); |
| } |
| x1.setType(T1); |
| x1.fragments().add(W2); |
| basicMatch(x1); |
| } |
| public void testWhileStatement() { |
| WhileStatement x1 = ast.newWhileStatement(); |
| x1.setExpression(E1); |
| x1.setBody(S1); |
| basicMatch(x1); |
| } |
| |
| |
| } |
