/*******************************************************************************
* 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.model;
import java.io.IOException;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.wst.jsdt.internal.core.*;
import org.eclipse.wst.jsdt.internal.core.util.Util;
import org.eclipse.wst.jsdt.core.*;
import junit.framework.Test;
public class CompilationUnitTests extends ModifyingResourceTests {
IJavaScriptUnit cu;
IJavaScriptUnit workingCopy;
IJavaScriptProject testProject;
public CompilationUnitTests(String name) {
super(name);
}
public void setUpSuite() throws Exception {
super.setUpSuite();
this.testProject = createJavaProject("P", new String[] {"src"}, new String[] {getSystemJsPathString()}, "bin", "1.5");
createFolder("/P/src/p");
createFile(
"/P/src/p/X.js",
"\n\n" + // package now includes comment (see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=93880)
// => need some empty line at beginning to be able to have cu without any other element (see testGetElementAt())
"/* some comment */" +
" var f1=1;\n" +
" /** @deprecated\n */" +
" var f2;\n" +
" var f3;\n" +
" var f4;\n" +
" var f5, f6, f7;\n" +
" // @Deprecated\n" +
" var f8;\n" +
" function foo( y) {\n" +
" }\n" +
" function bar() {\n" +
" }\n" +
" /** @deprecated\n */" +
" function fred() {\n" +
" }\n" +
" // @Deprecated\n" +
" function fred2() {\n" +
" }\n" +
""
);
this.cu = getCompilationUnit("/P/src/p/X.js");
}
// Use this static initializer to specify subset for tests
// All specified tests which do not belong to the class are skipped...
static {
// TESTS_PREFIX = "testGetChildren";
// TESTS_NAMES = new String[] { "testDefaultFlag1" };
// TESTS_NUMBERS = new int[] { 13 };
// TESTS_RANGE = new int[] { 16, -1 };
}
public static Test suite() {
return buildModelTestSuite(CompilationUnitTests.class);
}
protected void tearDown() throws Exception {
if (this.workingCopy != null)
this.workingCopy.discardWorkingCopy();
super.tearDown();
}
public void tearDownSuite() throws Exception {
this.deleteProject("P");
super.tearDownSuite();
}
/**
* Create working copy and compute problems.
*
* Note that in this case, a complete parse of javadoc comment is performed
* (ie. done with checkDocComment = true) instead of a "light" parse when
* problems are not computed.
*
* See JavaScriptUnit#buildStructure() line with comment: // disable javadoc parsing if not computing problems, not resolving and not creating ast
* and org.eclipse.wst.jsdt.internal.compiler.parser.JavadocParser#checkDeprecation(int)
*/
private IJavaScriptUnit createWorkingCopyComputingProblems(String source) throws JavaScriptModelException {
this.workingCopy = getWorkingCopy("/P/src/p/Y.js", source, true);
return this.workingCopy;
}
public void test00Class() throws CoreException {
try {
String source =
"MyClass.prototype.someMethod = MyClass_someMethod;\n" +
"function MyClass()\n" +
"{\n" +
"this.field1=0;\n" +
"}\n" +
"function MyClass_someMethod()\n" +
"{\n" +
"}";
createFile("/P/src/X.js", source);
final IJavaScriptUnit compilationUnit = getCompilationUnit("/P/src/X.js");
IType type = compilationUnit.getType("MyClass");
assertTrue("Type not defined", type.exists());
IField[] fields= type.getFields();
assertEquals("Wrong number of fields returned", 1, fields.length);
assertEquals("Incorrect name for the field", "field1", fields[0].getElementName());
assertTrue("Field should exist " , fields[0].exists());
IFunction[] methods= type.getFunctions();
assertEquals("Wrong number of methods returned", 2, methods.length);
assertEquals("Incorrect name for the method", "someMethod", methods[0].getElementName());
assertTrue("Field should exist " ,methods[0].exists());
} finally {
deleteFile("/P/src/X.js");
}
}
/**
* Calls methods that do nothing to ensure code coverage
*/
public void testCodeCoverage() throws JavaScriptModelException {
this.cu.discardWorkingCopy();
this.cu.restore();
}
/**
* Ensures <code>commitWorkingCopy(boolean, IProgressMonitor)</code> throws the correct
* <code>JavaScriptModelException</code> for a <code>JavaScriptUnit</code>.
*/
public void testCommitWorkingCopy() {
try {
this.cu.commitWorkingCopy(false, null);
} catch (JavaScriptModelException jme) {
assertTrue("Incorrect status for committing a JavaScriptUnit", jme.getStatus().getCode() == IJavaScriptModelStatusConstants.INVALID_ELEMENT_TYPES);
return;
}
assertTrue("A compilation unit should throw an exception is a commit is attempted", false);
}
/*
* Ensure that the deprecated flag is correctly reported
* (regression test fo bug 23207 Flags.isDeprecated(IFunction.getFlags()) doesn't work)
*/
//public void testDeprecatedFlag01() throws JavaScriptModelException {
// IType type = this.cu.getType("X");
// assertTrue("Type X should not be deprecated", !Flags.isDeprecated(type.getFlags()));
//}
//
/*
* Ensure that the deprecated flag is correctly reported
* (regression test fo bug 23207 Flags.isDeprecated(IFunction.getFlags()) doesn't work)
*/
//public void testDeprecatedFlag02() throws JavaScriptModelException {
// IType type = this.cu.getType("I");
// assertTrue("Type I should be deprecated", Flags.isDeprecated(type.getFlags()));
//}
/*
* Ensure that the deprecated flag is correctly reported
* (regression test fo bug 23207 Flags.isDeprecated(IFunction.getFlags()) doesn't work)
*/
public void testDeprecatedFlag03() throws JavaScriptModelException {
IField field = this.cu.getField("f1");
assertTrue("Field f1 should not be deprecated", !Flags.isDeprecated(field.getFlags()));
}
/*
* Ensure that the deprecated flag is correctly reported
* (regression test fo bug 23207 Flags.isDeprecated(IFunction.getFlags()) doesn't work)
*/
public void testDeprecatedFlag04() throws JavaScriptModelException {
IField field = this.cu.getField("f2");
assertTrue("Field f2 should be deprecated", Flags.isDeprecated(field.getFlags()));
}
/*
* Ensure that the deprecated flag is correctly reported
* (regression test fo bug 23207 Flags.isDeprecated(IFunction.getFlags()) doesn't work)
*/
public void testDeprecatedFlag05() throws JavaScriptModelException {
IFunction method = this.cu.getFunction("bar", new String[]{});
assertTrue("Method bar should not be deprecated", !Flags.isDeprecated(method.getFlags()));
}
/*
* Ensure that the deprecated flag is correctly reported
* (regression test fo bug 23207 Flags.isDeprecated(IFunction.getFlags()) doesn't work)
*/
public void testDeprecatedFlag06() throws JavaScriptModelException {
IFunction method = this.cu.getFunction("fred", new String[]{});
assertTrue("Method fred should be deprecated", Flags.isDeprecated(method.getFlags()));
}
/*
* Ensure that the deprecated flag is correctly reported
* (regression test fo bug 89807 Outliner should recognize @Deprecated annotation)
*/
public void testDeprecatedFlag07() throws JavaScriptModelException {
IType type = this.cu.getType("I3");
assertTrue("Type I3 should be deprecated", Flags.isDeprecated(type.getFlags()));
}
/*
* Ensure that the deprecated flag is correctly reported
* (regression test fo bug 89807 Outliner should recognize @Deprecated annotation)
*/
public void testDeprecatedFlag08() throws JavaScriptModelException {
IField field = this.cu.getType("X").getField("f8");
assertTrue("Field f8 should be deprecated", Flags.isDeprecated(field.getFlags()));
}
/*
* Ensure that the deprecated flag is correctly reported
* (regression test fo bug 89807 Outliner should recognize @Deprecated annotation)
*/
public void testDeprecatedFlag09() throws JavaScriptModelException {
IFunction method = this.cu.getType("X").getFunction("fred2", new String[0]);
assertTrue("Method fred2 should be deprecated", Flags.isDeprecated(method.getFlags()));
}
/*
* Ensures that the categories for a class are correct.
*/
public void testGetCategories01() throws CoreException {
createWorkingCopyComputingProblems(
"package p;\n" +
"/**\n" +
" * @category test\n" +
" */\n" +
"public class Y {\n" +
"}"
);
String[] categories = this.workingCopy.getType("Y").getCategories();
assertStringsEqual(
"Unexpected categories",
"test\n",
categories);
}
/*
* Ensures that the categories for an interface are correct.
*/
public void testGetCategories02() throws CoreException {
createWorkingCopyComputingProblems(
"package p;\n" +
"/**\n" +
" * @category test\n" +
" */\n" +
"public interface Y {\n" +
"}"
);
String[] categories = workingCopy.getType("Y").getCategories();
assertStringsEqual(
"Unexpected categories",
"test\n",
categories);
}
/*
* Ensures that the categories for an enumeration type are correct.
*/
public void testGetCategories03() throws CoreException {
createWorkingCopyComputingProblems(
"package p;\n" +
"/**\n" +
" * @category test\n" +
" */\n" +
"public enum Y {\n" +
"}"
);
String[] categories = workingCopy.getType("Y").getCategories();
assertStringsEqual(
"Unexpected categories",
"test\n",
categories);
}
/*
* Ensures that the categories for an annotation type type are correct.
*/
public void testGetCategories04() throws CoreException {
createWorkingCopyComputingProblems(
"package p;\n" +
"/**\n" +
" * @category test\n" +
" */\n" +
"public @interface Y {\n" +
"}"
);
String[] categories = workingCopy.getType("Y").getCategories();
assertStringsEqual(
"Unexpected categories",
"test\n",
categories);
}
/*
* Ensures that the categories for a method are correct.
*/
public void testGetCategories05() throws CoreException {
createWorkingCopyComputingProblems(
"package p;\n" +
"public class Y {\n" +
" /**\n" +
" * @category test\n" +
" */\n" +
" void foo() {}\n" +
"}"
);
String[] categories = workingCopy.getType("Y").getFunction("foo", new String[0]).getCategories();
assertStringsEqual(
"Unexpected categories",
"test\n",
categories);
}
/*
* Ensures that the categories for a constructor are correct.
*/
public void testGetCategories06() throws CoreException {
createWorkingCopyComputingProblems(
"package p;\n" +
"public class Y {\n" +
" /**\n" +
" * @category test\n" +
" */\n" +
" public Y() {}\n" +
"}"
);
String[] categories = workingCopy.getType("Y").getFunction("Y", new String[0]).getCategories();
assertStringsEqual(
"Unexpected categories",
"test\n",
categories);
}
/*
* Ensures that the categories for a field are correct.
*/
public void testGetCategories07() throws CoreException {
createWorkingCopyComputingProblems(
"package p;\n" +
"public class Y {\n" +
" /**\n" +
" * @category test\n" +
" */\n" +
" int field;\n" +
"}"
);
String[] categories = workingCopy.getType("Y").getField("field").getCategories();
assertStringsEqual(
"Unexpected categories",
"test\n",
categories);
}
/*
* Ensures that the categories for a member type are correct.
*/
public void testGetCategories08() throws CoreException {
createWorkingCopyComputingProblems(
"package p;\n" +
"public class Y {\n" +
" /**\n" +
" * @category test\n" +
" */\n" +
" class Member {}\n" +
"}"
);
String[] categories = workingCopy.getType("Y").getType("Member").getCategories();
assertStringsEqual(
"Unexpected categories",
"test\n",
categories);
}
/*
* Ensures that the categories for an element that has no categories is empty.
*/
public void testGetCategories09() throws CoreException {
createWorkingCopyComputingProblems(
"package p;\n" +
"public class Y {\n" +
" /**\n" +
" */\n" +
" void foo() {}\n" +
"}"
);
String[] categories = workingCopy.getType("Y").getFunction("foo", new String[0]).getCategories();
assertStringsEqual(
"Unexpected categories",
"",
categories);
}
/*
* Ensures that the categories for an element that has multiple category tags is correct.
*/
public void testGetCategories10() throws CoreException {
createWorkingCopyComputingProblems(
"package p;\n" +
"public class Y {\n" +
" /**\n" +
" * @category test1\n" +
" * @category test2\n" +
" */\n" +
" void foo() {}\n" +
"}"
);
String[] categories = workingCopy.getType("Y").getFunction("foo", new String[0]).getCategories();
assertStringsEqual(
"Unexpected categories",
"test1\n" +
"test2\n",
categories);
}
/*
* Ensures that the categories for an element that has multiple categories for one category tag is correct.
*/
public void testGetCategories11() throws CoreException {
createWorkingCopyComputingProblems(
"package p;\n" +
"public class Y {\n" +
" /**\n" +
" * @category test1 test2\n" +
" */\n" +
" void foo() {}\n" +
"}"
);
String[] categories = workingCopy.getType("Y").getFunction("foo", new String[0]).getCategories();
assertStringsEqual(
"Unexpected categories",
"test1\n" +
"test2\n",
categories);
}
public void testGetCategories12() throws CoreException {
createWorkingCopyComputingProblems(
"package p;\n" +
"public class Y {\n" +
" /**\n" +
" * @category test1 test2\n" +
" */\n" +
" void foo() {}\n" +
"}"
);
String[] categories = this.workingCopy.getType("Y").getFunction("foo", new String[0]).getCategories();
assertStringsEqual(
"Unexpected categories",
"test1\n" +
"test2\n",
categories);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=125676
public void testGetCategories13() throws CoreException {
createWorkingCopyComputingProblems(
"package p;\n" +
"public class Y {\n" +
" /**\n" +
" * @category " +
" * test\n" +
" */\n" +
" void foo() {}\n" +
"}"
);
String[] categories = this.workingCopy.getType("Y").getFunction("foo", new String[0]).getCategories();
assertStringsEqual(
"Unexpected categories",
"",
categories);
}
public void testGetCategories14() throws CoreException {
createWorkingCopyComputingProblems(
"package p;\n" +
"public class Y {\n" +
" /**\n" +
" * @category" +
" * test\n" +
" */\n" +
" void foo() {}\n" +
"}"
);
String[] categories = this.workingCopy.getType("Y").getFunction("foo", new String[0]).getCategories();
assertStringsEqual(
"Unexpected categories",
"",
categories);
}
public void testGetCategories15() throws CoreException {
createWorkingCopyComputingProblems(
"package p;\n" +
"public class Y {\n" +
" /**\n" +
" * @category test1" +
" * test2\n" +
" */\n" +
" void foo() {}\n" +
"}"
);
String[] categories = this.workingCopy.getType("Y").getFunction("foo", new String[0]).getCategories();
assertStringsEqual(
"Unexpected categories",
"test1\n",
categories);
}
/*
* Ensures that the children of a type for a given category are correct.
*/
public void testGetChildrenForCategory01() throws CoreException {
createWorkingCopyComputingProblems(
"package p;\n" +
"public class Y {\n" +
" /**\n" +
" * @category test\n" +
" */\n" +
" int field;\n" +
" /**\n" +
" * @category test\n" +
" */\n" +
" void foo1() {}\n" +
" /**\n" +
" * @category test\n" +
" */\n" +
" void foo2() {}\n" +
" /**\n" +
" * @category other\n" +
" */\n" +
" void foo3() {}\n" +
"}"
);
IJavaScriptElement[] children = workingCopy.getType("Y").getChildrenForCategory("test");
assertElementsEqual(
"Unexpected children",
"field [in Y [in [Working copy] Y.js [in p [in src [in P]]]]]\n" +
"foo1() [in Y [in [Working copy] Y.js [in p [in src [in P]]]]]\n" +
"foo2() [in Y [in [Working copy] Y.js [in p [in src [in P]]]]]",
children);
}
/*
* Ensures that the children of a type for a given category are correct.
*/
public void testGetChildrenForCategory02() throws CoreException {
createWorkingCopyComputingProblems(
"package p;\n" +
"public class Y {\n" +
" /**\n" +
" * @category test1 test2\n" +
" */\n" +
" class Member {}\n" +
" /**\n" +
" * @category test1\n" +
" */\n" +
" void foo1() {}\n" +
" /**\n" +
" * @category test2\n" +
" */\n" +
" void foo2() {}\n" +
"}"
);
IJavaScriptElement[] children = workingCopy.getType("Y").getChildrenForCategory("test1");
assertElementsEqual(
"Unexpected children",
"Member [in Y [in [Working copy] Y.js [in p [in src [in P]]]]]\n" +
"foo1() [in Y [in [Working copy] Y.js [in p [in src [in P]]]]]",
children);
}
public void testGetChildrenForCategory03() throws CoreException, IOException {
createWorkingCopyComputingProblems(
"package p;\n" +
"public class Y {\n" +
" /**\n" +
" * @category fields test all\n" +
" */\n" +
" int field;\n" +
" /**\n" +
" * @category methods test all\n" +
" */\n" +
" void foo1() {}\n" +
" /**\n" +
" * @category methods test all\n" +
" */\n" +
" void foo2() {}\n" +
" /**\n" +
" * @category methods other all\n" +
" */\n" +
" void foo3() {}\n" +
"}"
);
IJavaScriptElement[] tests = this.workingCopy.getType("Y").getChildrenForCategory("test");
assertElementsEqual(
"Unexpected children",
"field [in Y [in [Working copy] Y.js [in p [in src [in P]]]]]\n" +
"foo1() [in Y [in [Working copy] Y.js [in p [in src [in P]]]]]\n" +
"foo2() [in Y [in [Working copy] Y.js [in p [in src [in P]]]]]",
tests);
IJavaScriptElement[] methods = this.workingCopy.getType("Y").getChildrenForCategory("methods");
assertElementsEqual(
"Unexpected children",
"foo1() [in Y [in [Working copy] Y.js [in p [in src [in P]]]]]\n" +
"foo2() [in Y [in [Working copy] Y.js [in p [in src [in P]]]]]\n" +
"foo3() [in Y [in [Working copy] Y.js [in p [in src [in P]]]]]",
methods);
IJavaScriptElement[] others = this.workingCopy.getType("Y").getChildrenForCategory("other");
assertElementsEqual(
"Unexpected children",
"foo3() [in Y [in [Working copy] Y.js [in p [in src [in P]]]]]",
others);
IJavaScriptElement[] all = this.workingCopy.getType("Y").getChildrenForCategory("all");
assertElementsEqual(
"Unexpected children",
"field [in Y [in [Working copy] Y.js [in p [in src [in P]]]]]\n" +
"foo1() [in Y [in [Working copy] Y.js [in p [in src [in P]]]]]\n" +
"foo2() [in Y [in [Working copy] Y.js [in p [in src [in P]]]]]\n" +
"foo3() [in Y [in [Working copy] Y.js [in p [in src [in P]]]]]",
all);
}
/**
* Ensures <code>getContents()</code> returns the correct value
* for a <code>JavaScriptUnit</code> that is not present
*/
public void testGetContentsForNotPresent() {
CompilationUnit compilationUnit = (CompilationUnit)getCompilationUnit("/P/src/p/Absent.js");
assertSourceEquals("Unexpected contents for non present cu", "", new String(compilationUnit.getContents()));
}
/**
* Tests Java element retrieval via source position
*/
public void testGetElementAt() throws JavaScriptModelException {
IField field = this.cu.getField( "f2");
ISourceRange sourceRange= field.getSourceRange();
//ensure that we are into the body of the type
IJavaScriptElement element=
this.cu.getElementAt(sourceRange.getOffset() + field.getElementName().length() + 1);
assertTrue("Should have found a type", element instanceof IField);
assertEquals(
"Should have found f2",
"f2",
element.getElementName());
//ensure that null is returned if there is no element other than the compilation
//unit itself at the given position
element= this.cu.getElementAt(this.cu.getSourceRange().getOffset() + 1);
assertEquals("Should have not found any element", null, element);
}
///**
// * Tests import declararion retrieval via source position.
// * (regression test for bug 14331 IJavaScriptUnit.getElementAt dos not find import decl)
// */
//public void testGetElementAt2() throws JavaScriptModelException {
// IImportContainer container = this.cu.getImportContainer();
// ISourceRange sourceRange= container.getSourceRange();
// //ensure that we are inside the import container
// IJavaScriptElement element= this.cu.getElementAt(sourceRange.getOffset() + 1);
// assertTrue("Should have found an import", element instanceof IImportDeclaration);
// assertEquals(
// "Import not found",
// "p2.*",
// element.getElementName());
//}
/*
* Ensures that the right field is returnd in a muti-declaration field.
*/
public void testGetElementAt3() throws JavaScriptModelException {
int fieldPos = this.cu.getSource().indexOf("f5");
IJavaScriptElement element= this.cu.getElementAt(fieldPos);
assertEquals(
"Unexpected field found",
this.cu.getField("f5"),
element);
}
/*
* Ensures that the right field is returnd in a muti-declaration field.
*/
public void testGetElementAt4() throws JavaScriptModelException {
int fieldPos = this.cu.getSource().indexOf("f6");
IJavaScriptElement element= this.cu.getElementAt(fieldPos);
assertEquals(
"Unexpected field found",
this.cu.getField("f6"),
element);
}
/*
* Ensures that the right field is returnd in a muti-declaration field.
*/
public void testGetElementAt5() throws JavaScriptModelException {
int fieldPos = this.cu.getSource().indexOf("f7");
IJavaScriptElement element= this.cu.getElementAt(fieldPos);
assertEquals(
"Unexpected field found",
this.cu.getField("f7"),
element);
}
/*
* Ensures that the right field is returned in a muti-declaration field.
*/
public void testGetElementAt6() throws JavaScriptModelException {
int fieldPos = this.cu.getSource().indexOf("var f5");
IJavaScriptElement element= this.cu.getElementAt(fieldPos);
assertEquals(
"Unexpected field found",
this.cu.getField("f5"),
element);
}
///*
// * Ensures that the right type is returnd if an annotation type as a comment in its header.
// */
//public void testGetElementAt7() throws JavaScriptModelException {
// int fieldPos = this.cu.getSource().indexOf("Annot");
// IJavaScriptElement element= this.cu.getElementAt(fieldPos);
// assertEquals(
// "Unexpected type found",
// this.cu.getType("Annot"),
// element);
//}
/**
* Ensures that correct number of fields with the correct names, modifiers, signatures
* and declaring types exist in a type.
*/
public void testGetFields() throws JavaScriptModelException {
// IType type = this.cu.getType("X");
IField[] fields= this.cu.getFields();
String[] fieldNames = new String[] {"f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8"};
String[] flags = new String[] {"public", "protected", "private", "", "", "", "", ""};
String[] signatures = new String[] {"I", "QObject;", "QX;", "Qjava.lang.String;", "I", "I", "I", "I"};
assertEquals("Wrong number of fields returned", fieldNames.length, fields.length);
for (int i = 0; i < fields.length; i++) {
assertEquals("Incorrect name for the " + i + " field", fieldNames[i], fields[i].getElementName());
// String mod= Flags.toString(fields[i].getFlags());
// assertEquals("Unexpected modifier for " + fields[i].getElementName(), flags[i], mod);
// assertEquals("Unexpected type signature for " + fields[i].getElementName(), signatures[i], fields[i].getTypeSignature());
// assertEquals("Unexpected declaring type for " + fields[i].getElementName(), type, fields[i].getDeclaringType());
assertTrue("Field should exist " + fields[i], fields[i].exists());
}
}
///**
// * Ensure that import declaration handles are returned from the
// * compilation unit.
// * Checks non-existant handle, on demand and not.
// */
//public void testGetImport() {
// IImportDeclaration imprt = this.cu.getImport("java.lang");
// assertTrue("Import should not exist " + imprt, !imprt.exists());
//
// imprt = this.cu.getImport("p2.*");
// assertTrue("Import should exist " + imprt, imprt.exists());
//
// imprt = this.cu.getImport("p3.Z");
// assertTrue("Import should exist " + imprt, imprt.exists());
//}
///**
// * Ensures that correct number of imports with the correct names
// * exist in "GraphicsTest" compilation unit.
// */
//public void testGetImports() throws JavaScriptModelException {
// IImportDeclaration[] imprts = this.cu.getImports();
// IImportContainer container= this.cu.getImportContainer();
// String[] importNames = new String[] {"p2.*", "p3.Z"};
//
// assertEquals("Wrong number of imports returned", importNames.length, imprts.length);
// for (int i = 0; i < imprts.length; i++) {
// assertTrue("Incorrect name for the type in this position: " + imprts[i].getElementName(), imprts[i].getElementName().equals(importNames[i]));
// assertTrue("Import does not exist " + imprts[i], imprts[i].exists());
// if (i == 0) {
// assertTrue("Import is not on demand " + imprts[i], imprts[i].isOnDemand());
// assertTrue("Import should be non-static " + imprts[i], imprts[i].getFlags() == Flags.AccDefault);
// } else {
// assertTrue("Import is on demand " + imprts[i], !imprts[i].isOnDemand());
// assertTrue("Import should be non-static " + imprts[i], imprts[i].getFlags() == Flags.AccDefault);
// }
// assertTrue("Container import does not equal import", container.getImport(imprts[i].getElementName()).equals(imprts[i]));
// }
//
// assertTrue("Import container must exist and have children", container.exists() && container.hasChildren());
// ISourceRange containerRange= container.getSourceRange();
// assertEquals(
// "Offset container range not correct",
// imprts[0].getSourceRange().getOffset(),
// containerRange.getOffset());
// assertEquals(
// "Length container range not correct",
// imprts[imprts.length-1].getSourceRange().getOffset() + imprts[imprts.length-1].getSourceRange().getLength(),
// containerRange.getOffset() + containerRange.getLength());
// assertSourceEquals("Source not correct",
// "import p2.*;\n" +
// "import p3.Z;",
// container.getSource());
//
//}
/**
* Ensure that type handles are returned from the
* compilation unit for an inner type.
*/
//public void testGetInnerTypes() throws JavaScriptModelException {
// IType type1 = cu.getType("X");
// assertTrue("X type should have children", type1.hasChildren());
// assertTrue("X type superclass name should be null", type1.getSuperclassName() == null);
// String[] superinterfaceNames= type1.getSuperInterfaceNames();
// assertEquals("X type should have one superinterface", 1, superinterfaceNames.length);
// assertEquals("Unexpected super interface name", "Runnable", superinterfaceNames[0]);
// assertEquals("Fully qualified name of the type is incorrect", "p.X", type1.getFullyQualifiedName());
// IType type2 = type1.getType("Inner");
// superinterfaceNames = type2.getSuperInterfaceNames();
// assertEquals("X$Inner type should not have a superinterface", 0, superinterfaceNames.length);
// assertEquals("Fully qualified name of the inner type is incorrect", "p.X$Inner", type2.getFullyQualifiedName());
// assertEquals("Declaring type of the inner type is incorrect", type1, type2.getDeclaringType());
// IType type3 = type2.getType("InnerInner");
// assertTrue("InnerInner type should not have children", !type3.hasChildren());
//}
/*
* Ensures that the key for a top level type is correct
*/
public void testGetKey1() {
// IType type = this.cu.getType("X");
// assertEquals("Lp/X;", type.getKey());
IField type = this.cu.getField("f2");
assertEquals("Up/X.js;.f2", type.getKey());
}
/*
* Ensures that the key for a member type is correct
*/
public void testGetKey2() {
IType type = this.cu.getType("X").getType("Inner");
assertEquals("Lp/X$Inner;", type.getKey());
}
/*
* Ensures that the key for a secondary type is correct
*/
public void testGetKey3() {
IType type = this.cu.getType("I");
assertEquals("Lp/X~I;", type.getKey());
}
/*
* Ensures that the key for an anonymous type is correct
*/
public void testGetKey4() {
IType type = this.cu.getType("X").getFunction("foo", new String[0]).getType("", 1);
assertEquals("Lp/X$1;", type.getKey());
}
/**
* Ensures that a method has the correct return type, parameters and exceptions.
*/
public void testGetMethod1() throws JavaScriptModelException {
// IType type = this.cu.getType("X");
IFunction foo = this.cu.getFunction("foo", new String[]{null});
// String[] exceptionTypes= foo.getExceptionTypes();
// assertEquals("Wrong number of exception types", 1, exceptionTypes.length);
// assertEquals("Unxepected exception type", "QIOException;", exceptionTypes[0]);
// assertEquals("Wrong return type", "V", foo.getReturnType());
String[] parameterNames = foo.getParameterNames();
assertEquals("Wrong number of parameter names", 1, parameterNames.length);
assertEquals("Unexpected parameter name", "y", parameterNames[0]);
}
///**
// * Ensures that a method has the correct AccVarargs flag set.
// */
//public void testGetMethod2() throws JavaScriptModelException {
// IType type = this.cu.getType("X");
// IFunction method = type.getMethod("testIsVarArgs", new String[]{"QString;", "[QObject;"});
// assertTrue("Should have the AccVarargs flag set", Flags.isVarargs(method.getFlags()));
//}
///**
// * Ensures that a constructor has the correct AccVarargs flag set.
// * (regression test for bug 77422 [1.5] ArrayIndexOutOfBoundsException with vararg constructor of generic superclass)
// */
//public void testGetMethod3() throws JavaScriptModelException {
// IType type = this.cu.getType("X");
// IFunction method = type.getMethod("X", new String[]{"[QString;"});
// assertTrue("Should have the AccVarargs flag set", Flags.isVarargs(method.getFlags()));
//}
/**
* Ensures that correct number of methods with the correct names and modifiers
* exist in a type.
*/
public void testGetMethods() throws JavaScriptModelException {
// IType type = this.cu.getType("X");
IFunction[] methods= this.cu.getFunctions();
String[] methodNames = new String[] {"foo", "bar", "fred", "fred2"};
String[] flags = new String[] {"public", "protected static", "private", "private"};
assertEquals("Wrong number of methods returned", methodNames.length, methods.length);
for (int i = 0; i < methods.length; i++) {
assertEquals("Incorrect name for the " + i + " method", methodNames[i], methods[i].getElementName());
int modifiers = methods[i].getFlags() & ~Flags.AccVarargs;
// String mod= Flags.toString(modifiers);
// assertEquals("Unexpected modifier for " + methods[i].getElementName(), flags[i], mod);
assertTrue("Method does not exist " + methods[i], methods[i].exists());
}
}
///**
// * Ensures that correct modifiers are reported for a method in an interface.
// */
//public void testCheckInterfaceMethodModifiers() throws JavaScriptModelException {
// IType type = this.cu.getType("I");
// IFunction method = type.getMethod("run", new String[0]);
// String expectedModifiers = "";
// String modifiers = Flags.toString(method.getFlags() & ~Flags.AccVarargs);
// assertEquals("Expected modifier for " + method.getElementName(), expectedModifiers, modifiers);
//}
///*
// * Ensures that IType#getSuperInterfaceTypeSignatures() is correct for a source type.
// */
//public void testGetSuperInterfaceTypeSignatures() throws JavaScriptModelException {
// IType type = this.cu.getType("Y");
// assertStringsEqual(
// "Unexpected signatures",
// "QI2<QE;>;\n",
// type.getSuperInterfaceTypeSignatures());
//}
/**
* Ensure that the same element is returned for the primary element of a
* compilation unit.
*/
public void testGetPrimary() {
IJavaScriptElement primary = this.cu.getPrimaryElement();
assertEquals("Primary element for a compilation unit should be the same", this.cu, primary);
primary = this.cu.getPrimary();
assertEquals("Primary for a compilation unit should be the same", this.cu, primary);
}
///////*
////// * Ensures that the occurrence count for an initializer is correct
////// */
//////public void testGetOccurrenceCount01() {
////// IInitializer initializer = this.cu.getType("X").getInitializer(2);
////// assertEquals("Unexpected occurrence count", 2, initializer.getOccurrenceCount());
//////}
/////*
//// * Ensures that the occurrence count for an anonymous type is correct
//// */
////public void testGetOccurrenceCount02() {
//// IType type = this.cu.getType("X").getMethod("foo", new String[]{"QY;"}).getType("", 3);
//// assertEquals("Unexpected occurrence count", 3, type.getOccurrenceCount());
////}
///**
// * Ensures that correct number of package declarations with the correct names
// * exist a compilation unit.
// */
//public void testGetPackages() throws JavaScriptModelException {
// IPackageDeclaration[] packages = this.cu.getPackageDeclarations();
// String packageName = "p";
// assertEquals("Wrong number of packages returned", 1, packages.length);
// assertEquals("Wrong package declaration returned: ", packageName, packages[0].getElementName());
//}
/**
* Ensure that type handles are returned from the
* compilation unit.
* Checks non-existant handle and existing handles.
*/
public void testGetType() {
IField type = this.cu.getField("someType");
assertTrue("Type should not exist " + type, !type.exists());
type = this.cu.getField("f2");
assertTrue("Type should exist " + type, type.exists());
// type = this.cu.getType("I"); // secondary type
// assertTrue("Type should exist " + type, type.exists());
}
///**
// * Ensures that correct number of types with the correct names and modifiers
// * exist in a compilation unit.
// */
//public void testGetTypes() throws JavaScriptModelException {
// IType[] types = this.cu.getTypes();
// String[] typeNames = new String[] {"X", "I", "I2", "I3", "Y", "Colors", "Annot"};
// String[] flags = new String[] {"public", "", "", "", "", "", ""};
// boolean[] isClass = new boolean[] {true, false, false, false, true, false, false};
// boolean[] isInterface = new boolean[] {false, true, true, true, false, false, true};
// boolean[] isAnnotation = new boolean[] {false, false, false, false, false, false, true};
// boolean[] isEnum = new boolean[] {false, false, false, false, false, true, false};
// String[] superclassName = new String[] {null, null, null, null, null, null, null};
// String[] superclassType = new String[] {null, null, null, null, null, null, null};
// String[][] superInterfaceNames = new String[][] {
// new String[] {"Runnable"}, new String[0], new String[0], new String[0], new String[] {"I2<E>"}, new String[0], new String[0]
// };
// String[][] superInterfaceTypes = new String[][] {
// new String[] {"QRunnable;"}, new String[0], new String[0], new String[0], new String[] {"QI2<QE;>;"}, new String[0], new String[0]
// };
// String[][] formalTypeParameters = new String[][] {
// new String[0], new String[0], new String[] {"E"}, new String[0], new String[] {"E"}, new String[0], new String[0]
// };
//
// assertEquals("Wrong number of types returned", typeNames.length, types.length);
// for (int i = 0; i < types.length; i++) {
// assertEquals("Incorrect name for the " + i + " type", typeNames[i], types[i].getElementName());
// String mod= Flags.toString(types[i].getFlags());
// assertEquals("Unexpected modifier for " + types[i].getElementName(), flags[i], mod);
// assertTrue("Type does not exist " + types[i], types[i].exists());
// assertEquals("Incorrect isClass for the " + i + " type", isClass[i], types[i].isClass());
// assertEquals("Incorrect isInterface for the " + i + " type", isInterface[i], types[i].isInterface());
// assertEquals("Incorrect isAnnotation for the " + i + " type", isAnnotation[i], types[i].isAnnotation());
// assertEquals("Incorrect isEnum for the " + i + " type", isEnum[i], types[i].isEnum());
// assertEquals("Incorrect superclassName for the " + i + " type", superclassName[i], types[i].getSuperclassName());
// assertEquals("Incorrect superclassType for the " + i + " type", superclassType[i], types[i].getSuperclassTypeSignature());
// assertEquals("Incorrect superInterfaceNames for the " + i + " type", superInterfaceNames[i].length, types[i].getSuperInterfaceNames().length);
// assertEquals("Incorrect superInterfaceTypes for the " + i + " type", superInterfaceTypes[i].length, types[i].getSuperInterfaceTypeSignatures().length);
// assertEquals("Incorrect formalTypeParameters for the " + i + " type", formalTypeParameters[i].length, types[i].getTypeParameters().length);
// }
//}
/**
* Ensures that a compilation unit has children.
*/
public void testHasChildren() throws JavaScriptModelException {
this.cu.close();
assertTrue("A closed compilation unit should have children", this.cu.hasChildren());
this.cu.getChildren();
assertTrue("The compilation unit should have children", this.cu.hasChildren());
}
/**
* Ensures that a compilation unit's resource has not changed.
*/
public void testHasResourceChanged() {
assertTrue(
"A compilation unit's resource should not have changed",
!this.cu.hasResourceChanged());
}
///*
// * Ensures that hasChildren doesn't return true for an import container that doesn't exist
// * (regression test for bug 76761 [model] ImportContainer.hasChildren() should not return true
// */
//public void testImportContainerHasChildren() throws JavaScriptModelException {
// IImportContainer importContainer = getCompilationUnit("/Test/DoesNotExist.js").getImportContainer();
// boolean gotException = false;
// try {
// importContainer.hasChildren();
// } catch (JavaScriptModelException e) {
// gotException = e.isDoesNotExist();
// }
// assertTrue("Should get a not present exception", gotException);
//}
///*
// * Ensures that isEnumConstant returns true for a field representing an enum constant.
// */
//public void testIsEnumConstant1() throws JavaScriptModelException {
// IField field = this.cu.getType("Colors").getField("BLUE");
// assertTrue("Colors#BLUE should be an enum constant", field.isEnumConstant());
//}
///*
// * Ensures that isEnumConstant returns false for a field that is not representing an enum constant.
// */
//public void testIsEnumConstant2() throws JavaScriptModelException {
// IField field = this.cu.getType("X").getField("f1");
// assertTrue("X#f1 should not be an enum constant", !field.isEnumConstant());
//}
/*
* Ensure that the utility method Util.#getNameWithoutJavaLikeExtension(String) works as expected
* (regression test for bug 107735 StringIndexOutOfBoundsException in Util.getNameWithoutJavaLikeExtension())
*/
public void testNameWithoutJavaLikeExtension() {
String name = Util.getNameWithoutJavaLikeExtension("Test.aj");
assertEquals("Unepected name without extension", "Test.aj", name);
}
/**
* Ensures that a compilation unit that does not exist responds
* false to #exists() and #isOpen()
*/
public void testNotPresent1() {
IJavaScriptUnit compilationUnit = ((IPackageFragment)this.cu.getParent()).getJavaScriptUnit("DoesNotExist.js");
assertTrue("CU should not be open", !compilationUnit.isOpen());
assertTrue("CU should not exist", !compilationUnit.exists());
assertTrue("CU should still not be open", !compilationUnit.isOpen());
}
///**
// * Ensures that a compilation unit that does not exist
// * (because it is a child of a jar package fragment)
// * responds false to #exists() and #isOpen()
// * (regression test for PR #1G2RKD2)
// */
//public void testNotPresent2() throws CoreException {
// IJavaScriptUnit compilationUnit = getPackageFragment("P", getExternalJCLPathString(), "java.lang").getCompilationUnit("DoesNotExist.js");
// assertTrue("CU should not be open", !compilationUnit.isOpen());
// assertTrue("CU should not exist", !compilationUnit.exists());
// assertTrue("CU should still not be open", !compilationUnit.isOpen());
//}
/*
* Ensure that the absence of visibility flags is correctly reported as package default
* (regression test fo bug 127213 Flags class missing methods)
*/
public void testPackageDefaultFlag1() throws JavaScriptModelException {
IField field = this.cu.getField("f4");
assertTrue("X#f4 should be package default", Flags.isPackageDefault(field.getFlags()));
}
///*
// * Ensure that the presence of a visibility flags is correctly reported as non package default
// * (regression test fo bug 127213 Flags class missing methods)
// */
//public void testPackageDefaultFlag2() throws JavaScriptModelException {
// IType type = this.cu.getType("X");
// assertTrue("X should not be package default", !Flags.isPackageDefault(type.getFlags()));
//}
/*
* Ensure that the presence of a visibility flags as well as the deprecated flag is correctly reported as non package default
* (regression test fo bug 127213 Flags class missing methods)
*/
public void testPackageDefaultFlag3() throws JavaScriptModelException {
IField field = this.cu.getType("X").getField("f2");
assertTrue("X#f2 should not be package default", !Flags.isPackageDefault(field.getFlags()));
}
/*
* Ensure that the absence of a visibility flags and the presence of the deprecated flag is correctly reported as package default
* (regression test fo bug 127213 Flags class missing methods)
*/
public void testPackageDefaultFlag4() throws JavaScriptModelException {
IType type = this.cu.getType("I");
assertTrue("X should be package default", Flags.isPackageDefault(type.getFlags()));
}
/**
* Ensures that the "structure is known" flag is set for a valid compilation unit.
*/
public void testStructureKnownForCU() throws JavaScriptModelException {
assertTrue("Structure is unknown for valid CU", this.cu.isStructureKnown());
}
/**
* Ensures that the "structure is unknown" flag is set for a non valid compilation unit.
*/
public void testStructureUnknownForCU() throws CoreException {
try {
this.createFile(
"/P/src/p/Invalid.js",
"@#D(03");
IJavaScriptUnit badCU = getCompilationUnit("/P/src/p/Invalid.js");
assertTrue("Structure is known for an invalid CU", !badCU.isStructureKnown());
} finally {
this.deleteFile("/P/src/p/Invalid.js");
}
}
///*
// * Ensure that the super flags is correctly reported
// * (regression test fo bug 127213 Flags class missing methods)
// */
//public void testSuperFlag1() throws JavaScriptModelException {
// assertTrue("Should contain super flag", Flags.isSuper(Flags.AccSuper));
//}
//
///*
// * Ensure that the super flags is correctly reported
// * (regression test fo bug 127213 Flags class missing methods)
// */
//public void testSuperFlag2() throws JavaScriptModelException {
// assertTrue("Should not contain super flag", !Flags.isSuper(Flags.AccDefault));
//}
///*
// * Verify fix for bug 73884: [1.5] Unexpected error for class implementing generic interface
// * (see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=73884)
// */
//public void testBug73884() throws CoreException {
// try {
// String cuSource =
// "package p;\n" +
// "public interface I<T> {\n" +
// "}";
// createFile("/P/src/p/I.js", cuSource);
// ITypeParameter[] typeParameters = getCompilationUnit("/P/src/p/I.js").getType("I").getTypeParameters();
// assertTypeParametersEqual(
// "T\n",
// typeParameters);
// } finally {
// deleteFile("/P/src/p/I.js");
// }
//}
///*
// * Ensure that the type parameters for a type are correct.
// */
//public void testTypeParameter1() throws CoreException {
// createWorkingCopy(
// "package p;\n" +
// "public class Y<T> {\n" +
// "}"
// );
// ITypeParameter[] typeParameters = workingCopy.getType("Y").getTypeParameters();
// assertTypeParametersEqual(
// "T\n",
// typeParameters);
//}
//
///*
// * Ensure that the type parameters for a type are correct.
// */
//public void testTypeParameter2() throws CoreException {
// createWorkingCopy(
// "package p;\n" +
// "public class Y<T, U> {\n" +
// "}"
// );
// ITypeParameter[] typeParameters = workingCopy.getType("Y").getTypeParameters();
// assertTypeParametersEqual(
// "T\n" +
// "U\n",
// typeParameters);
//}
//
///*
// * Ensure that the type parameters for a type are correct.
// */
//public void testTypeParameter3() throws CoreException {
// createWorkingCopy(
// "package p;\n" +
// "public class Y<T extends List> {\n" +
// "}"
// );
// ITypeParameter[] typeParameters = workingCopy.getType("Y").getTypeParameters();
// assertTypeParametersEqual(
// "T extends List\n",
// typeParameters);
//}
//
///*
// * Ensure that the type parameters for a type are correct.
// */
//public void testTypeParameter4() throws CoreException {
// createWorkingCopy(
// "package p;\n" +
// "public class Y<T extends List & Runnable & Comparable> {\n" +
// "}"
// );
// ITypeParameter[] typeParameters = workingCopy.getType("Y").getTypeParameters();
// assertTypeParametersEqual(
// "T extends List & Runnable & Comparable\n",
// typeParameters);
//}
//
///*
// * Ensure that the type parameters for a method are correct.
// * (regression test for bug 75658 [1.5] SourceElementParser do not compute correctly bounds of type parameter)
// */
//public void testTypeParameter5() throws CoreException {
// createWorkingCopy(
// "package p;\n" +
// "public class Y {\n" +
// " <T extends List, U extends X & Runnable> void foo() {\n" +
// " }\n" +
// "}"
// );
// ITypeParameter[] typeParameters = workingCopy.getType("Y").getMethod("foo", new String[]{}).getTypeParameters();
// assertTypeParametersEqual(
// "T extends List\n" +
// "U extends X & Runnable\n",
// typeParameters);
//}
//
///*
// * Verify fix for bug 78275: [recovery] NPE in GoToNextPreviousMemberAction with syntax error
// * (see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=78275)
// */
//public void testBug78275() throws CoreException {
// try {
// String cuSource =
// " function a() {\n" +
// " }\n" +
// " }\n" +
// " function m() {}\n" +
// "";
// createFile("/P/src/X.js", cuSource);
// IType type = getCompilationUnit("/P/src/X.js").getType("X");
// IInitializer[] initializers = type.getInitializers();
// assertEquals("Invalid number of initializers", 1, initializers.length);
// assertTrue("Invalid length for initializer", initializers[0].getSourceRange().getLength() > 0);
// } finally {
// deleteFile("/P/src/X.js");
// }
//}
public void test110172() throws CoreException {
try {
String source =
" /**\n" +
" * Javadoc for field f \n" +
" */\n" +
" var f;\n" +
" \n" +
" /**\n" +
" * Javadoc for method foo\n" +
" */\n" +
" function foo( i, l, s) {\n" +
" }\n" +
" \n" +
" /**\n" +
" * Javadoc for member type A\n" +
" */\n" +
" \n" +
" /**\n" +
" * Javadoc for f3\n" +
" */\n" +
" /*\n" +
" * Not a javadoc comment\n" +
" */\n" +
" /**\n" +
" * Real javadoc for f3\n" +
" */\n" +
" var f3;\n" +
" \n" +
" var f2;\n" +
" \n" +
" function foo2() {\n" +
" }\n" +
" \n" +
"\n" +
"";
createFile("/P/src/X.js", source);
// IType type = getCompilationUnit("/P/src/X.js").getType("X");
IJavaScriptElement[] members = getCompilationUnit("/P/src/X.js").getChildren();
final int length = members.length;
assertEquals("Wrong number", 5, length);
for (int i = 0; i < length; i++) {
final IJavaScriptElement element = members[i];
assertTrue(element instanceof IMember);
final ISourceRange javadocRange = ((IMember) element).getJSdocRange();
final String elementName = element.getElementName();
if ("f".equals(elementName)) {
assertNotNull("No javadoc source range", javadocRange);
final int start = javadocRange.getOffset();
final int end = javadocRange.getLength() + start - 1;
String javadocSource = source.substring(start, end);
assertTrue("Wrong javadoc", javadocSource.indexOf("field f") != -1);
} else if ("foo".equals(elementName)) {
assertNotNull("No javadoc source range", javadocRange);
final int start = javadocRange.getOffset();
final int end = javadocRange.getLength() + start - 1;
String javadocSource = source.substring(start, end);
assertTrue("Wrong javadoc", javadocSource.indexOf("method foo") != -1);
} else if ("A".equals(elementName)) {
assertNotNull("No javadoc source range", javadocRange);
final int start = javadocRange.getOffset();
final int end = javadocRange.getLength() + start - 1;
String javadocSource = source.substring(start, end);
assertTrue("Wrong javadoc", javadocSource.indexOf("member type A") != -1);
} else if ("X".equals(elementName)) {
// need treatment for the two constructors
assertTrue("Not an IFunction", element instanceof IFunction);
IFunction method = (IFunction) element;
switch(method.getNumberOfParameters()) {
case 0 :
assertNull("Has a javadoc source range", javadocRange);
break;
case 1:
assertNotNull("No javadoc source range", javadocRange);
final int start = javadocRange.getOffset();
final int end = javadocRange.getLength() + start - 1;
String javadocSource = source.substring(start, end);
assertTrue("Wrong javadoc", javadocSource.indexOf("constructor") != -1);
}
} else if ("f3".equals(elementName)) {
assertNotNull("No javadoc source range", javadocRange);
final int start = javadocRange.getOffset();
final int end = javadocRange.getLength() + start - 1;
String javadocSource = source.substring(start, end);
assertTrue("Wrong javadoc", javadocSource.indexOf("Real") != -1);
} else if ("f2".equals(elementName)) {
assertNull("Has a javadoc source range", javadocRange);
} else if ("foo2".equals(elementName)) {
assertNull("Has a javadoc source range", javadocRange);
} else if ("B".equals(elementName)) {
assertNull("Has a javadoc source range", javadocRange);
} else if (element instanceof IInitializer) {
IInitializer initializer = (IInitializer) element;
if (Flags.isStatic(initializer.getFlags())) {
assertNotNull("No javadoc source range", javadocRange);
final int start = javadocRange.getOffset();
final int end = javadocRange.getLength() + start - 1;
String javadocSource = source.substring(start, end);
assertTrue("Wrong javadoc", javadocSource.indexOf("initializer") != -1);
} else {
assertNull("Has a javadoc source range", javadocRange);
}
}
}
} finally {
deleteFile("/P/src/X.js");
}
}
public void test120902() throws CoreException {
try {
String source =
"/**\r\n" +
" * Toy\r\n" +
" */\r\n" +
"function foo() {\r\n" +
"}";
createFile("/P/src/X.js", source);
final IJavaScriptUnit compilationUnit = getCompilationUnit("/P/src/X.js");
IFunction type = compilationUnit.getFunction("foo",null);
ISourceRange javadocRange = type.getJSdocRange();
assertNotNull("No source range", javadocRange);
compilationUnit.getBuffer().setContents("");
try {
javadocRange = type.getJSdocRange();
assertNull("Got a source range", javadocRange);
} catch (ArrayIndexOutOfBoundsException e) {
assertFalse("Should not happen", true);
}
} finally {
deleteFile("/P/src/X.js");
}
}
}