tests/org.eclipse.wst.jsdt.core.tests.model/src/org/eclipse/wst/jsdt/core/tests/model/CompilationUnitTests.java

/*******************************************************************************
 * 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 v2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * 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");
	}
}
}