/*******************************************************************************
* 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.io.IOException;
import java.util.List;
import java.util.Map;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.wst.jsdt.core.IClassFile;
import org.eclipse.wst.jsdt.core.IJavaScriptProject;
import org.eclipse.wst.jsdt.core.IJavaScriptUnit;
import org.eclipse.wst.jsdt.core.JavaScriptCore;
import org.eclipse.wst.jsdt.core.JavaScriptModelException;
import org.eclipse.wst.jsdt.core.compiler.IProblem;
import org.eclipse.wst.jsdt.core.compiler.libraries.SystemLibraryLocation;
import org.eclipse.wst.jsdt.core.dom.AST;
import org.eclipse.wst.jsdt.core.dom.ASTNode;
import org.eclipse.wst.jsdt.core.dom.ASTParser;
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.BodyDeclaration;
import org.eclipse.wst.jsdt.core.dom.BooleanLiteral;
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.ExpressionStatement;
import org.eclipse.wst.jsdt.core.dom.FieldAccess;
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.ImportDeclaration;
import org.eclipse.wst.jsdt.core.dom.InfixExpression;
import org.eclipse.wst.jsdt.core.dom.Initializer;
import org.eclipse.wst.jsdt.core.dom.InstanceofExpression;
import org.eclipse.wst.jsdt.core.dom.JavaScriptUnit;
import org.eclipse.wst.jsdt.core.dom.MemberRef;
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.SimpleName;
import org.eclipse.wst.jsdt.core.dom.SimpleType;
import org.eclipse.wst.jsdt.core.dom.SingleVariableDeclaration;
import org.eclipse.wst.jsdt.core.dom.StringLiteral;
import org.eclipse.wst.jsdt.core.dom.SuperFieldAccess;
import org.eclipse.wst.jsdt.core.dom.SuperMethodInvocation;
import org.eclipse.wst.jsdt.core.dom.ThisExpression;
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.tests.util.Util;
public abstract class ConverterTestSetup extends AbstractASTTests {
/** @deprecated Using deprecated code */
public static final int AST_INTERNAL_JLS2 = AST.JLS2;
protected AST ast;
static List TEST_SUITES = null;
static boolean PROJECT_SETUP = false;
protected ConverterTestSetup(String name) {
super(name);
}
protected IPath getConverterJCLPath() {
return getConverterJCLPath(""); //$NON-NLS-1$
}
protected IPath getConverterJCLPath(String compliance) {
return new Path(new SystemLibraryLocation().getLibraryPath("system.js"));
}
protected IPath getConverterJCLRootSourcePath() {
return new Path(""); //$NON-NLS-1$
}
/**
* Reset the jar placeholder and delete project.
*/
public void tearDownSuite() throws Exception {
ast = null;
if (TEST_SUITES == null) {
this.deleteProject("Converter"); //$NON-NLS-1$
} else {
TEST_SUITES.remove(getClass());
if (TEST_SUITES.size() == 0) {
this.deleteProject("Converter"); //$NON-NLS-1$
}
}
super.tearDown();
}
public void setUpJCLClasspathVariables() throws JavaScriptModelException, IOException {
if (JavaScriptCore.getIncludepathVariable("CONVERTER_JCL_LIB") == null) {
JavaScriptCore.setIncludepathVariables(
new String[] {"CONVERTER_JCL_LIB", "CONVERTER_JCL_SRCROOT"},
new IPath[] {getConverterJCLPath(), getConverterJCLRootSourcePath()},
null);
}
}
/**
* Create project and set the jar placeholder.
*/
public void setUpSuite() throws Exception {
super.setUpSuite();
if (!PROJECT_SETUP) {
setUpJavaProject("Converter"); //$NON-NLS-1$
waitUntilIndexesReady(); // needed to find secondary types
PROJECT_SETUP = true;
}
}
public ASTNode runConversion(IJavaScriptUnit unit, boolean resolveBindings) {
return runConversion(AST_INTERNAL_JLS2, unit, resolveBindings);
}
public ASTNode runConversion(IJavaScriptUnit unit, int position, boolean resolveBindings) {
return runConversion(AST_INTERNAL_JLS2, unit, position, resolveBindings);
}
public ASTNode runConversion(IClassFile classFile, int position, boolean resolveBindings) {
return runConversion(AST_INTERNAL_JLS2, classFile, position, resolveBindings);
}
public ASTNode runConversion(char[] source, String unitName, IJavaScriptProject project) {
return runConversion(AST_INTERNAL_JLS2, source, unitName, project);
}
public ASTNode runConversion(char[] source, String unitName, IJavaScriptProject project, boolean resolveBindings) {
return runConversion(AST_INTERNAL_JLS2, source, unitName, project, resolveBindings);
}
public ASTNode runConversion(int astLevel, IJavaScriptUnit unit, boolean resolveBindings) {
return runConversion(astLevel, unit, resolveBindings, false);
}
public ASTNode runConversion(int astLevel, IJavaScriptUnit unit, boolean resolveBindings, boolean statementsRecovery) {
ASTParser parser = ASTParser.newParser(astLevel);
parser.setSource(unit);
parser.setResolveBindings(resolveBindings);
parser.setStatementsRecovery(statementsRecovery);
return parser.createAST(null);
}
class NullBindingVerifier extends ASTVisitor {
public void endVisit(ArrayAccess node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(ArrayCreation node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(ArrayInitializer node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(Assignment node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(BooleanLiteral node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(CharacterLiteral node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(ClassInstanceCreation node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(ConditionalExpression node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(FieldAccess node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(InfixExpression node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(InstanceofExpression node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(FunctionInvocation node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(NullLiteral node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(NumberLiteral node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(ParenthesizedExpression node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(PostfixExpression node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(PrefixExpression node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(StringLiteral node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(SuperFieldAccess node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(SuperMethodInvocation node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(ThisExpression node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(TypeLiteral node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(VariableDeclarationExpression node) {
assertNotNull(node+" should have a binding", node.resolveTypeBinding());
super.endVisit(node);
}
public void endVisit(AnonymousClassDeclaration node) {
assertNotNull(node+" should have a binding", node.resolveBinding());
super.endVisit(node);
}
public void endVisit(ArrayType node) {
assertNotNull(node+" should have a binding", node.resolveBinding());
super.endVisit(node);
}
public void endVisit(ImportDeclaration node) {
assertNotNull(node+" should have a binding", node.resolveBinding());
super.endVisit(node);
}
public void endVisit(MemberRef node) {
assertNotNull(node+" should have a binding", node.resolveBinding());
super.endVisit(node);
}
public void endVisit(FunctionDeclaration node) {
assertNotNull(node+" should have a binding", node.resolveBinding());
super.endVisit(node);
}
public void endVisit(FunctionRef node) {
assertNotNull(node+" should have a binding", node.resolveBinding());
super.endVisit(node);
}
public void endVisit(PackageDeclaration node) {
assertNotNull(node+" should have a binding", node.resolveBinding());
super.endVisit(node);
}
public void endVisit(PrimitiveType node) {
assertNotNull(node+" should have a binding", node.resolveBinding());
super.endVisit(node);
}
public void endVisit(QualifiedName node) {
assertNotNull(node+" should have a binding", node.resolveBinding());
super.endVisit(node);
}
public void endVisit(QualifiedType node) {
assertNotNull(node+" should have a binding", node.resolveBinding());
super.endVisit(node);
}
public void endVisit(SimpleName node) {
assertNotNull(node+" should have a binding", node.resolveBinding());
super.endVisit(node);
}
public void endVisit(SimpleType node) {
assertNotNull(node+" should have a binding", node.resolveBinding());
super.endVisit(node);
}
public void endVisit(SingleVariableDeclaration node) {
assertNotNull(node+" should have a binding", node.resolveBinding());
super.endVisit(node);
}
public void endVisit(TypeDeclaration node) {
assertNotNull(node+" should have a binding", node.resolveBinding());
super.endVisit(node);
}
public void endVisit(TypeDeclarationStatement node) {
assertNotNull(node+" should have a binding", node.resolveBinding());
super.endVisit(node);
}
public void endVisit(VariableDeclarationFragment node) {
assertNotNull(node+" should have a binding", node.resolveBinding());
super.endVisit(node);
}
}
public ASTNode runJLS3Conversion(IJavaScriptUnit unit, boolean resolveBindings, boolean checkJLS2) {
// Create parser
ASTParser parser;
if (checkJLS2) {
parser = ASTParser.newParser(AST_INTERNAL_JLS2);
parser.setSource(unit);
parser.setResolveBindings(resolveBindings);
parser.createAST(null);
}
parser = ASTParser.newParser(AST.JLS3);
parser.setSource(unit);
parser.setResolveBindings(resolveBindings);
// Parse compilation unit
ASTNode result = parser.createAST(null);
// Verify we get a compilation unit node and that binding are correct
assertTrue("Not a compilation unit", result.getNodeType() == ASTNode.JAVASCRIPT_UNIT);
JavaScriptUnit compilationUnit = (JavaScriptUnit) result;
if (resolveBindings && compilationUnit.getProblems().length == 0) {
compilationUnit.accept(new NullBindingVerifier());
}
return result;
}
public ASTNode runConversion(int astLevel, IJavaScriptUnit unit, int position, boolean resolveBindings) {
// Create parser
ASTParser parser = ASTParser.newParser(astLevel);
parser.setSource(unit);
parser.setFocalPosition(position);
parser.setResolveBindings(resolveBindings);
// Parse compilation unit
ASTNode result = parser.createAST(null);
// Verify we get a compilation unit node and that binding are correct
assertTrue("Not a compilation unit", result.getNodeType() == ASTNode.JAVASCRIPT_UNIT);
JavaScriptUnit compilationUnit = (JavaScriptUnit) result;
if (resolveBindings && compilationUnit.getProblems().length == 0) {
compilationUnit.accept(new NullBindingVerifier());
}
return result;
}
public ASTNode runConversion(int astLevel, IClassFile classFile, int position, boolean resolveBindings) {
// Create parser
ASTParser parser = ASTParser.newParser(astLevel);
parser.setSource(classFile);
parser.setFocalPosition(position);
parser.setResolveBindings(resolveBindings);
// Parse compilation unit
ASTNode result = parser.createAST(null);
// Verify we get a compilation unit node and that binding are correct
assertTrue("Not a compilation unit", result.getNodeType() == ASTNode.JAVASCRIPT_UNIT);
JavaScriptUnit compilationUnit = (JavaScriptUnit) result;
if (resolveBindings && compilationUnit.getProblems().length == 0) {
compilationUnit.accept(new NullBindingVerifier());
}
return result;
}
public ASTNode runConversion(int astLevel, char[] source, String unitName, IJavaScriptProject project) {
return runConversion(astLevel, source, unitName, project, false);
}
public ASTNode runConversion(int astLevel, char[] source, String unitName, IJavaScriptProject project, boolean resolveBindings) {
return runConversion(astLevel, source, unitName, project, null, resolveBindings);
}
public ASTNode runConversion(int astLevel, char[] source, String unitName, IJavaScriptProject project, Map options, boolean resolveBindings) {
ASTParser parser = ASTParser.newParser(astLevel);
parser.setSource(source);
parser.setUnitName(unitName);
parser.setProject(project);
if (options != null) {
parser.setCompilerOptions(options);
}
parser.setResolveBindings(resolveBindings);
return parser.createAST(null);
}
public ASTNode runConversion(int astLevel, char[] source, String unitName, IJavaScriptProject project, Map options) {
return runConversion(astLevel, source, unitName, project, options, false);
}
public ASTNode runConversion(char[] source, String unitName, IJavaScriptProject project, Map options, boolean resolveBindings) {
return runConversion(AST_INTERNAL_JLS2, source, unitName, project, options, resolveBindings);
}
public ASTNode runConversion(char[] source, String unitName, IJavaScriptProject project, Map options) {
return runConversion(AST_INTERNAL_JLS2, source, unitName, project, options);
}
protected ASTNode getASTNodeToCompare(org.eclipse.wst.jsdt.core.dom.JavaScriptUnit unit) {
ExpressionStatement statement = (ExpressionStatement) getASTNode(unit, 0, 0, 0);
return (ASTNode) ((FunctionInvocation) statement.getExpression()).arguments().get(0);
}
protected ASTNode getASTNode(org.eclipse.wst.jsdt.core.dom.JavaScriptUnit unit, int typeIndex, int bodyIndex, int statementIndex) {
BodyDeclaration bodyDeclaration = (BodyDeclaration) getASTNode(unit, typeIndex, bodyIndex);
if (bodyDeclaration instanceof FunctionDeclaration) {
FunctionDeclaration methodDeclaration = (FunctionDeclaration) bodyDeclaration;
Block block = methodDeclaration.getBody();
return (ASTNode) block.statements().get(statementIndex);
} else if (bodyDeclaration instanceof TypeDeclaration) {
TypeDeclaration typeDeclaration = (TypeDeclaration) bodyDeclaration;
return (ASTNode) typeDeclaration.bodyDeclarations().get(statementIndex);
} else if (bodyDeclaration instanceof Initializer) {
Initializer initializer = (Initializer) bodyDeclaration;
Block block = initializer.getBody();
return (ASTNode) block.statements().get(statementIndex);
}
return null;
}
protected ASTNode getASTNode(org.eclipse.wst.jsdt.core.dom.JavaScriptUnit unit, int typeIndex, int bodyIndex) {
return (ASTNode) unit.statements().get(bodyIndex);
}
protected ASTNode getASTNode(org.eclipse.wst.jsdt.core.dom.JavaScriptUnit unit, int typeIndex) {
return (ASTNode) unit.types().get(typeIndex);
}
protected void checkSourceRange(ASTNode node, String expectedContents, String source) {
assertNotNull("The node is null", node); //$NON-NLS-1$
assertTrue("The node(" + node.getClass() + ").getLength() == 0", node.getLength() != 0); //$NON-NLS-1$ //$NON-NLS-2$
assertTrue("The node.getStartPosition() == -1", node.getStartPosition() != -1); //$NON-NLS-1$
int length = node.getLength();
int start = node.getStartPosition();
String actualContentsString = source.substring(start, start + length);
assertSourceEquals("Unexpected source", Util.convertToIndependantLineDelimiter(expectedContents), Util.convertToIndependantLineDelimiter(actualContentsString));
}
protected void checkSourceRange(ASTNode node, String expectedContents, char[] source) {
assertNotNull("The node is null", node); //$NON-NLS-1$
assertTrue("The node(" + node.getClass() + ").getLength() == 0", node.getLength() != 0); //$NON-NLS-1$ //$NON-NLS-2$
assertTrue("The node.getStartPosition() == -1", node.getStartPosition() != -1); //$NON-NLS-1$
int length = node.getLength();
int start = node.getStartPosition();
char[] actualContents = new char[length];
System.arraycopy(source, start, actualContents, 0, length);
String actualContentsString = new String(actualContents);
assertSourceEquals("Unexpected source", Util.convertToIndependantLineDelimiter(expectedContents), Util.convertToIndependantLineDelimiter(actualContentsString));
}
protected boolean isMalformed(ASTNode node) {
return (node.getFlags() & ASTNode.MALFORMED) != 0;
}
protected boolean isRecovered(ASTNode node) {
return (node.getFlags() & ASTNode.RECOVERED) != 0;
}
protected boolean isOriginal(ASTNode node) {
return (node.getFlags() & ASTNode.ORIGINAL) != 0;
}
protected void assertProblemsSize(JavaScriptUnit compilationUnit, int expectedSize) {
assertProblemsSize(compilationUnit, expectedSize, "");
}
protected void assertProblemsSize(JavaScriptUnit compilationUnit, int expectedSize, String expectedOutput) {
final IProblem[] problems = compilationUnit.getProblems();
final int length = problems.length;
if (length != expectedSize) {
checkProblemMessages(expectedOutput, problems, length);
assertEquals("Wrong size", expectedSize, length);
}
checkProblemMessages(expectedOutput, problems, length);
}
private void checkProblemMessages(String expectedOutput, final IProblem[] problems, final int length) {
if (length != 0) {
if (expectedOutput != null) {
StringBuffer buffer = new StringBuffer();
for (int i = 0; i < length; i++) {
buffer.append(problems[i].getMessage());
if (i < length - 1) {
buffer.append('\n');
}
}
String actualOutput = String.valueOf(buffer);
expectedOutput = Util.convertToIndependantLineDelimiter(expectedOutput);
actualOutput = Util.convertToIndependantLineDelimiter(actualOutput);
if (!expectedOutput.equals(actualOutput)) {
System.out.println(Util.displayString(actualOutput));
assertEquals("different output", expectedOutput, actualOutput);
}
}
}
}
}