Attachment #199703 for bug #352160

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.wst.jsdt.core.compiler.CharOperation;
import org.eclipse.wst.jsdt.internal.codeassist.InternalCompletionProposal;
import org.eclipse.wst.jsdt.internal.core.util.TypeQulificationHelpers;

/**
 * Completion proposal.

//		return this.declarationPackageName;
//	}
//
	/**
	 * Returns the type name of the relevant
	 * declaration in the context without the package fragment,
	 * or <code>null</code> if none.
	 * <p>
	 * This field is available for the following kinds of
	 * completion proposals:
	 * <ul>
	 * <li><code>ANONYMOUS_CLASS_DECLARATION</code> - the dot-based type name
	 * of the type that is being subclassed or implemented</li>
	 * 	<li><code>FIELD_REF</code> - the dot-based type name
	 * of the type that declares the field that is referenced
	 * or an anonymous type instantiation ("new X(){}") if it is an anonymous type</li>
	 * 	<li><code>FUNCTION_REF</code> - the dot-based type name
	 * of the type that declares the method that is referenced
	 * or an anonymous type instantiation ("new X(){}") if it is an anonymous type</li>
	 * 	<li><code>FUNCTION_DECLARATION</code> - the dot-based type name
	 * of the type that declares the method that is being
	 * implemented or overridden</li>
	 * </ul>
	 * For kinds of completion proposals, this method returns
	 * <code>null</code>. Clients must not modify the array
	 * returned.
	 * </p>
	 *
	 * @return the dot-based package name, or
	 * <code>null</code> if none
	 * @see #getDeclarationSignature()
	 * @see #getSignature()
	 *
	 */
	public char[] getDeclarationTypeName() {
		return this.declarationTypeName;
	}

	public char[][] getParameterTypeNames() {
		return this.parameterTypeNames;
	}
	
	public char[] getReturnType() {
		return TypeQulificationHelpers.createFullyQualifedTypeName(this.getReturnQualification(), this.getReturnSimpleName());
	}

	/**
	 * Returns the accessibility of the proposal.




	int size = length - 1;
	int index = length;
	while (--index >= 0) {
		if ((array[index] == null || array[index].length == 0) && ignoreEmptyElements) {
			size--;
		} else {
			size += array[index] != null ? array[index].length : 0;
		}
	}
	if (size <= 0)
		return CharOperation.NO_CHAR;
	char[] result = new char[size];
	index = length;
	while (--index >= 0) {
		length = array[index] != null ? array[index].length : 0;
		if (length > 0 || (length == 0 && !ignoreEmptyElements)) {
			System.arraycopy(
				array[index] != null ? array[index] : NO_CHAR,
				0,
				result,
				(size -= length),




				selectorChars,
				declaringTypeQualification,
				declaringTypeSimpleName,
				declaringTypeSignature,
				returnTypeQualification,
				returnTypeSimpleName,
				returnTypeSignature,
				parameterTypeQualifications,
				parameterTypeSimpleNames,
				parameterTypeSignatures,
				typeArguments,
				matchRule);
	}
}

						declaringSimpleName,
						returnQualification,
						returnSimpleName,
						returnSignature,
						parameterQualifications,
						parameterSimpleNames,
						parameterSignatures,
						method,
						matchRule);
			}




import org.eclipse.wst.jsdt.internal.core.SourceMethodElementInfo;
import org.eclipse.wst.jsdt.internal.core.SourceType;
import org.eclipse.wst.jsdt.internal.core.SourceTypeElementInfo;
import org.eclipse.wst.jsdt.internal.core.util.TypeQulificationHelpers;
import org.eclipse.wst.jsdt.internal.oaametadata.ClassData;
import org.eclipse.wst.jsdt.internal.oaametadata.Method;


	}
	
	/**
	 * @see org.eclipse.wst.jsdt.internal.codeassist.ISearchRequestor#acceptMethod(char[], int, char[][], char[][], char[][], char[], char[], char[], char[], int, java.lang.String)
	 */
	public void acceptMethod(char[] signature, int parameterCount,
			char[][] parameterQualifications, char[][] parameterSimpleNames,
			char[][] parameterNames, char[] returnQualification,
			char[] returnSimpleName, char[] declaringQualification,
			char[] declaringSimpleName, int modifiers, String path) {
		
		this.proposeMethod(signature, parameterCount, parameterQualifications, parameterSimpleNames, parameterNames,
				returnQualification, returnSimpleName, declaringQualification, declaringSimpleName, modifiers, path);
	}
	
	/**
	 * @see org.eclipse.wst.jsdt.internal.codeassist.ISearchRequestor#acceptConstructor(
	 * 		int, char[], int, char[][], char[][], java.lang.String, org.eclipse.wst.jsdt.internal.compiler.env.AccessRestriction)
	 */

		if(!CompletionEngine.this.requestor.isIgnored(CompletionProposal.LOCAL_VARIABLE_REF)) {
			CompletionProposal proposal = CompletionEngine.this.createProposal(CompletionProposal.LOCAL_VARIABLE_REF, CompletionEngine.this.actualCompletionPosition);
			proposal.setSignature(JAVA_LANG_OBJECT_SIGNATURE);
			proposal.setReturnQualification(JAVA_LANG_NAME);
			proposal.setReturnSimpleName(OBJECT);
			proposal.setName(name);
			proposal.setCompletion(name);
			proposal.setFlags(Flags.AccDefault);

	 * @param name the name of the binding
	 * @param exactMatch <code>true</code> if an exact match is needed, <code>false</code> otherwise
	 * @param prefixRequired
	 * @param onlyConstructors <code>true</code> if only constructors should be accepted,
	 * <code>false</code> otherwise.  Only applies when matching on {@link Binding#METHOD}s.
	 */
	private void acceptBindings(char[] name,boolean exactMatch, boolean prefixRequired) {
		

						proposal.setParameterTypeNames(parameterFullTypeNames);

						if(method.returnType!=null) {
							proposal.setReturnQualification(method.returnType.qualifiedPackageName());
							proposal.setReturnSimpleName(method.returnType.qualifiedSourceName());
						}else {
							proposal.setReturnSimpleName(null);
						}



						proposal.setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
						proposal.setParameterPackageNames(parameterPackageNames);
						proposal.setParameterTypeNames(parameterFullTypeNames);
						proposal.setReturnQualification(method.returnType.qualifiedPackageName());
						proposal.setReturnSimpleName(method.returnType.qualifiedSourceName());
						proposal.setName(bindingName);
						proposal.setCompletion(javadocCompletion);
						proposal.setFlags( modifiers);

					}
					proposal.setSignature(getSignature(variableBinding.type));
					proposal.setDeclarationTypeName(packageName);
					proposal.setReturnQualification(variableBinding.type.qualifiedPackageName());
					proposal.setReturnSimpleName(variableBinding.type.qualifiedSourceName());
					proposal.setName(variableBinding.name);
					proposal.setCompletion(completion);
					proposal.setFlags(variableBinding.modifiers);

					CompletionProposal proposal = this.createProposal(CompletionProposal.JSDOC_FIELD_REF, this.actualCompletionPosition);
					proposal.setSignature(getSignature(variableBinding.type));
					proposal.setDeclarationPackageName(packageName);
					proposal.setReturnQualification(variableBinding.type.qualifiedPackageName());
					proposal.setReturnSimpleName(variableBinding.type.qualifiedSourceName());
					proposal.setName(variableBinding.name);
					proposal.setCompletion(javadocCompletion);
					proposal.setFlags(variableBinding.modifiers);

			long completionPosition = access.nameSourcePosition;
			setSourceRange((int) (completionPosition >>> 32), (int) completionPosition);



//			this.assistNodeIsClass = true;
//			this.assistNodeIsConstructor = true;

			// can be the start of a qualified type name
			if (qualifiedBinding == null) {
			

			} else {
				this.completionToken = access.token;
				if (qualifiedBinding.problemId() == ProblemReasons.NotFound) {
					/* complete method members with missing return type
					 * class X {
					 *   Missing f() {return null;}
					 *   void foo() {
					 *     f().|
					 *   }
					 * }
					 */
					if (this.assistNodeInJavadoc == 0 &&
							(this.requestor.isAllowingRequiredProposals(CompletionProposal.FIELD_REF, CompletionProposal.TYPE_REF) ||
									this.requestor.isAllowingRequiredProposals(CompletionProposal.METHOD_REF, CompletionProposal.TYPE_REF))) {

				proposal.setSignature(signature);
				//proposal.setDeclarationPackageName(null);
				//proposal.setDeclarationTypeName(null);
				proposal.setReturnQualification(CharOperation.concatWith(JAVA_LANG, '.'));
				proposal.setReturnSimpleName(CLASS);
				proposal.setName(classField);
				proposal.setCompletion(classField);
				proposal.setFlags(Flags.AccStatic | Flags.AccPublic);

				proposal.setSignature(getSignature(field.type));
				proposal.setDeclarationPackageName(field.declaringClass.qualifiedPackageName());
				proposal.setDeclarationTypeName(field.declaringClass.qualifiedSourceName());
				proposal.setReturnQualification(field.type.qualifiedPackageName());
				proposal.setReturnSimpleName(field.type.qualifiedSourceName());
				proposal.setName(field.name);
				if (missingElements != null) {
					CompletionProposal[] subProposals = new CompletionProposal[missingElements.length];

				proposal.setSignature(getSignature(field.type));
				proposal.setDeclarationPackageName(field.declaringClass.qualifiedPackageName());
				proposal.setDeclarationTypeName(field.declaringClass.qualifiedSourceName());
				proposal.setReturnQualification(field.type.qualifiedPackageName());
				proposal.setReturnSimpleName(field.type.qualifiedSourceName());
				proposal.setName(field.name);
				proposal.setCompletion(javadocCompletion);
				proposal.setFlags(field.modifiers);

					proposal.setSignature(getSignature(field.type));
					proposal.setDeclarationPackageName(field.declaringClass.qualifiedPackageName());
					proposal.setDeclarationTypeName(field.declaringClass.qualifiedSourceName());
					proposal.setReturnQualification(field.type.qualifiedPackageName());
					proposal.setReturnSimpleName(field.type.qualifiedSourceName());
					proposal.setName(field.name);
					proposal.setCompletion(completion);
					proposal.setFlags(field.modifiers);

					char[] packageName = receiverType.qualifiedPackageName();
					typeImportProposal.setDeclarationSignature(packageName);
					typeImportProposal.setSignature(getSignature(receiverType));
					typeImportProposal.setReturnQualification(packageName);
					typeImportProposal.setReturnSimpleName(receiverType.qualifiedSourceName());
					typeImportProposal.setCompletion(typeImportCompletion);
					typeImportProposal.setFlags(receiverType.modifiers);
					typeImportProposal.setAdditionalFlags(CompletionFlags.Default);

					proposal.setSignature(getSignature(field.type));
					proposal.setDeclarationPackageName(field.declaringClass.qualifiedPackageName());
					proposal.setDeclarationTypeName(field.declaringClass.qualifiedSourceName());
					proposal.setReturnQualification(field.type.qualifiedPackageName());
					proposal.setReturnSimpleName(field.type.qualifiedSourceName());
					proposal.setName(field.name);
					proposal.setCompletion(completion);
					proposal.setFlags(field.modifiers);

					fieldImportProposal.setSignature(getSignature(field.type));
					fieldImportProposal.setDeclarationPackageName(field.declaringClass.qualifiedPackageName());
					fieldImportProposal.setDeclarationTypeName(field.declaringClass.qualifiedSourceName());
					fieldImportProposal.setReturnQualification(field.type.qualifiedPackageName());
					fieldImportProposal.setReturnSimpleName(field.type.qualifiedSourceName());
					fieldImportProposal.setName(field.name);
					fieldImportProposal.setCompletion(fieldImportCompletion);
					fieldImportProposal.setFlags(field.modifiers);

				proposal.setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
				proposal.setParameterPackageNames(parameterPackageNames);
				proposal.setParameterTypeNames(parameterTypeNames);
				proposal.setReturnQualification(method.returnType.qualifiedPackageName());
				proposal.setReturnSimpleName(method.returnType.qualifiedSourceName());
				proposal.setName(method.selector);
				proposal.setIsContructor(method.isConstructor());
				

				proposal.setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
				proposal.setParameterPackageNames(parameterPackageNames);
				proposal.setParameterTypeNames(parameterTypeNames);
				proposal.setReturnQualification(method.returnType.qualifiedPackageName());
				proposal.setReturnSimpleName(method.returnType.qualifiedSourceName());
				proposal.setName(method.selector);
				proposal.setCompletion(javadocCompletion);
				proposal.setFlags(method.modifiers);

							proposal.setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
							proposal.setParameterPackageNames(parameterPackageNames);
							proposal.setParameterTypeNames(parameterTypeNames);
							proposal.setReturnQualification(method.returnType.qualifiedPackageName());
							proposal.setReturnSimpleName(method.returnType.qualifiedSourceName());
							proposal.setName(method.selector);
							proposal.setCompletion(completion);
							proposal.setFlags(method.modifiers);

						proposal.setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
						proposal.setParameterPackageNames(parameterPackageNames);
						proposal.setParameterTypeNames(parameterTypeNames);
						proposal.setReturnQualification(method.returnType.qualifiedPackageName());
						proposal.setReturnSimpleName(method.returnType.qualifiedSourceName());
						proposal.setName(method.selector);
						proposal.setCompletion(completion);
						proposal.setFlags(method.modifiers);

						char[] packageName = receiverType.qualifiedPackageName();
						typeImportProposal.setDeclarationSignature(packageName);
						typeImportProposal.setSignature(getSignature(receiverType));
						typeImportProposal.setReturnQualification(packageName);
						typeImportProposal.setReturnSimpleName(receiverType.qualifiedSourceName());
						typeImportProposal.setCompletion(typeImportCompletion);
						typeImportProposal.setFlags(receiverType.modifiers);
						typeImportProposal.setAdditionalFlags(CompletionFlags.Default);

						proposal.setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
						proposal.setParameterPackageNames(parameterPackageNames);
						proposal.setParameterTypeNames(parameterTypeNames);
						proposal.setReturnQualification(method.returnType.qualifiedPackageName());
						proposal.setReturnSimpleName(method.returnType.qualifiedSourceName());
						proposal.setName(method.selector);
						proposal.setCompletion(completion);
						proposal.setFlags(method.modifiers);

						methodImportProposal.setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
						methodImportProposal.setParameterPackageNames(parameterPackageNames);
						methodImportProposal.setParameterTypeNames(parameterTypeNames);
						methodImportProposal.setReturnQualification(method.returnType.qualifiedPackageName());
						methodImportProposal.setReturnSimpleName(method.returnType.qualifiedSourceName());
						methodImportProposal.setName(method.selector);
						methodImportProposal.setCompletion(methodImportCompletion);
						methodImportProposal.setFlags(method.modifiers);

			proposal.completionEngine = this;
			proposal.setDeclarationSignature(packageName);
			proposal.setSignature(getSignature(typeBinding));
			proposal.setReturnQualification(packageName);
			proposal.setReturnSimpleName(typeName);
			proposal.setCompletion(fullyQualifiedName);
			proposal.setFlags(typeBinding.modifiers);
			proposal.setReplaceRange(start - this.offset, end - this.offset);


			proposal = this.createProposal(CompletionProposal.PACKAGE_REF, this.actualCompletionPosition);
			proposal.setDeclarationSignature(packageName);
			proposal.setReturnQualification(packageName);
			proposal.setCompletion(packageName);
			proposal.setReplaceRange(start - this.offset, end - this.offset);
			proposal.setRelevance(relevance);

				proposal.setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
				proposal.setParameterPackageNames(parameterPackageNames);
				proposal.setParameterTypeNames(parameterFullTypeNames);
				proposal.setReturnQualification(method.returnType.qualifiedPackageName());
				proposal.setReturnSimpleName(method.returnType.qualifiedSourceName());
				proposal.setCompletion(completion.toString().toCharArray());
				proposal.setName(method.selector);
				proposal.setFlags(method.modifiers);

									: getSignature(local.type));
								if(local.type == null) {
									//proposal.setPackageName(null);
									proposal.setReturnSimpleName(local.declaration.getTypeName().toCharArray());
								} else {
									proposal.setReturnQualification(local.type.qualifiedPackageName());
									proposal.setReturnSimpleName(local.type.qualifiedSourceName());
								}
								proposal.setName(local.name);
								proposal.setCompletion(local.name);


						}
						break;
//					case Scope.CLASS_SCOPE :
					case Scope.COMPILATION_UNIT_SCOPE :
						CompilationUnitScope compilationUnitScope = (CompilationUnitScope) currentScope;
//						ClassScope classScope = (ClassScope) currentScope;
						SourceTypeBinding enclosingType = compilationUnitScope.enclosingCompilationUnit();
						/*				if (tokenLength == 0) { // only search inside the type itself if no prefix was provided
											findFields(token, enclosingType.fields(), classScope, fieldsFound, staticsOnly);
											findMethods(token, enclosingType.methods(), classScope, methodsFound, staticsOnly, false);
											break done;
										} else { */
						if(!insideTypeAnnotation) {
							if(proposeField) {
								findFields(

						}
						staticsOnly |= enclosingType.isStatic();
						insideTypeAnnotation = false;
						//				}
//						break;

//					case Scope.COMPILATION_UNIT_SCOPE :
						break done2;
				}
				currentScope = currentScope.parent;

			}
			
			//propose methods from environment if token length is not 0
			if (proposeMethod  && token.length > 0) {
				this.nameEnvironment.findMethods(
				this.nameEnvironment.findBindings(
						token,
						null,
						this.options.camelCaseMatch,
						this);
				acceptBindings(token,false,false);
			}
			
			//propose fields from environment if token length is not 0

						if(!CompletionEngine.this.requestor.isIgnored(CompletionProposal.VARIABLE_DECLARATION)) {
							CompletionProposal proposal = CompletionEngine.this.createProposal(CompletionProposal.VARIABLE_DECLARATION, CompletionEngine.this.actualCompletionPosition);
							proposal.setSignature(getSignature(type.resolvedType));
							proposal.setReturnQualification(type.resolvedType.qualifiedPackageName());
							proposal.setReturnSimpleName(type.resolvedType.qualifiedSourceName());
							proposal.setName(name);
							proposal.setCompletion(name);
							//proposal.setFlags(Flags.AccDefault);

					if(!CompletionEngine.this.requestor.isIgnored(CompletionProposal.VARIABLE_DECLARATION)) {
						CompletionProposal proposal = CompletionEngine.this.createProposal(CompletionProposal.VARIABLE_DECLARATION, CompletionEngine.this.actualCompletionPosition);
						proposal.setSignature(getSignature(typeBinding));
						proposal.setReturnQualification(q);
						proposal.setReturnSimpleName(displayName);
						proposal.setName(name);
						proposal.setCompletion(name);
						//proposal.setFlags(Flags.AccDefault);

			proposal.setDeclarationTypeName(reference.qualifiedSourceName());

			//proposal.setPackageName(null);
			proposal.setReturnSimpleName(VOID);
			proposal.setName(token);
			//proposal.setParameterPackageNames(null);
			//proposal.setParameterTypeNames(null);

			proposal.completionEngine = this;
			proposal.setDeclarationSignature(packageName);
			proposal.setSignature(createNonGenericTypeSignature(typeName));
			proposal.setReturnQualification(packageName);
			proposal.setReturnSimpleName(typeName);
			proposal.setCompletion(completionName);
			proposal.setFlags(modifiers);
			proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);

			proposal.completionEngine = this;
			proposal.setDeclarationSignature(packageName);
			proposal.setSignature(createNonGenericTypeSignature(typeName));
			proposal.setReturnQualification(packageName);
			proposal.setReturnSimpleName(typeName);
			proposal.setCompletion(javadocCompletion);
			proposal.setFlags(modifiers);
			int start = (this.assistNodeInJavadoc & CompletionOnJavadoc.REPLACE_TAG) != 0 ? this.javadocTagPosition : this.startPosition;

			proposal.completionEngine = this;
			proposal.setDeclarationSignature(refBinding.qualifiedPackageName());
			proposal.setSignature(getSignature(refBinding));
			proposal.setReturnQualification(refBinding.qualifiedPackageName());
			proposal.setReturnSimpleName(typeName);
			proposal.setCompletion(completionName);
			proposal.setFlags(refBinding.modifiers);
			proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);

			proposal.completionEngine = this;
			proposal.setDeclarationSignature(refBinding.qualifiedPackageName());
			proposal.setSignature(getSignature(refBinding));
			proposal.setReturnQualification(refBinding.qualifiedPackageName());
			proposal.setReturnSimpleName(typeName);
			proposal.setCompletion(javadocCompletion);
			proposal.setFlags(refBinding.modifiers);
			int start = (this.assistNodeInJavadoc & CompletionOnJavadoc.REPLACE_TAG) != 0 ? this.javadocTagPosition : this.startPosition;

								CompletionProposal proposal =  createProposal(CompletionProposal.TYPE_REF, this.actualCompletionPosition);
								proposal.setDeclarationSignature(packageName);
								proposal.setSignature(getSignature(refBinding));
								proposal.setReturnQualification(packageName);
								proposal.setReturnSimpleName(typeName);
								proposal.setCompletion(completionName);
								proposal.setFlags(refBinding.modifiers);
								proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);

		return typeName;
	}
	
	private void proposeMethod(char[] signature,
			int parameterCount,
			char[][] parameterQualifications,
			char[][] parameterSimpleNames,
			char[][] parameterNames,
			char[] returnQualification,
			char[] returnSimpleName,
			char[] declaringQualification,
			char[] declaringSimpleName,
			int modifiers,
			String path) {
		
		//compute completion
		char[] completion;
		if (this.source != null
				&& this.source.length > this.endPosition
				&& this.source[this.endPosition] == '(') {
			
			completion = signature;
		} else {
			completion = CharOperation.concat(signature, new char[] { '(', ')' });
		}
		
		//compute relevance
		int relevance = computeBaseRelevance();
		relevance += computeRelevanceForInterestingProposal();
		if (this.completionToken != null) relevance += computeRelevanceForCaseMatching(this.completionToken, signature);
		relevance += computeRelevanceForExpectingType(returnQualification, returnSimpleName);
		relevance += computeRelevanceForQualification(false);
		relevance += computeRelevanceForRestrictions(IAccessRule.K_ACCESSIBLE);
		
		this.noProposal = false;
		// Standard proposal
		if(!this.requestor.isIgnored(CompletionProposal.METHOD_REF) && (this.assistNodeInJavadoc & CompletionOnJavadoc.ONLY_INLINE_TAG) == 0) {
			CompletionProposal proposal = this.createProposal(CompletionProposal.METHOD_REF, this.actualCompletionPosition);
			proposal.setDeclarationSignature(TypeQulificationHelpers.createFullyQualifedTypeName(declaringQualification, declaringSimpleName));
			proposal.setDeclarationPackageName(declaringQualification);
			proposal.setDeclarationTypeName(declaringSimpleName);
			proposal.setParameterPackageNames(parameterQualifications);
			proposal.setParameterTypeNames(parameterSimpleNames);
			proposal.setReturnQualification(returnQualification);
			proposal.setReturnSimpleName(returnSimpleName);
			proposal.setName(signature);
			proposal.setCompletion(completion);
			proposal.setFlags(modifiers);
			proposal.setReplaceRange(this.startPosition - this.offset, this.endPosition - this.offset);
			proposal.setRelevance(relevance);
			if(parameterNames != null) proposal.setParameterNames(parameterNames);
			proposal.setIsContructor(false);
			this.requestor.accept(proposal);
			if(DEBUG) {
				this.printDebug(proposal);
			}
		}
	}
	
	/**
	 * <p>Represents a constructor accepted from the index.</p>
	 */




			char[][] parameterNames,
			String path,
			AccessRestriction access);
	
	/**
	 * 
	 * TODO: IAN: doc me!
	 * 
	 * @param signature
	 * @param parameterCount
	 * @param parameterQualifications
	 * @param parameterSimpleNames
	 * @param parameterNames
	 * @param returnQualification
	 * @param returnSimpleName
	 * @param declaringQualification
	 * @param declaringSimpleName
	 * @param modifiers
	 * @param path
	 */
	public void acceptMethod(char[] signature,
			int parameterCount,
			char[][] parameterQualifications,
			char[][] parameterSimpleNames,
			char[][] parameterNames,
			char[] returnQualification,
			char[] returnSimpleName,
			char[] declaringQualification,
			char[] declaringSimpleName,
			int modifiers,
			String path);
}





	protected char[] declarationPackageName;
	protected char[] declarationTypeName;
	protected char[] returnQualification;
	protected char[] returnSimpleName;
	protected char[][] parameterPackageNames;
	protected char[][] parameterTypeNames;


		return this.declarationTypeName;
	}

	protected char[] getReturnQualification() {
		return this.returnQualification;
	}

	protected char[] getReturnSimpleName() {
		return this.returnSimpleName;
	}

	protected char[][] getParameterPackageNames() {

		this.declarationTypeName = declarationTypeName;
	}

	protected void setReturnQualification(char[] packageName) {
		this.returnQualification = packageName;
	}

	protected void setReturnSimpleName(char[] typeName) {
		this.returnSimpleName = typeName;
	}

	protected void setParameterPackageNames(char[][] parameterPackageNames) {




				
				//do nothing
			}
			
			/**
			 * @see org.eclipse.wst.jsdt.internal.codeassist.ISearchRequestor#acceptMethod(char[], int, char[][], char[][], char[][], char[], char[], char[], char[], int, java.lang.String)
			 */
			public void acceptMethod(char[] signature, int parameterCount,
					char[][] parameterQualifications,
					char[][] parameterSimpleNames, char[][] parameterNames,
					char[] returnQualification, char[] returnSimpleName,
					char[] declaringQualification, char[] declaringSimpleName,
					int modifiers, String path) {
				
				//do nothing
			}
		};
		nameEnvironment.findExactTypes(missingSimpleName, true, IJavaScriptSearchConstants.TYPE, storage);
		if(results.size() == 0) return null;




		
		// do nothing
	}
	
	/**
	 * @see org.eclipse.wst.jsdt.internal.codeassist.ISearchRequestor#acceptMethod(char[], int, char[][], char[][], char[][], char[], char[], char[], char[], int, java.lang.String)
	 */
	public void acceptMethod(char[] signature, int parameterCount,
			char[][] parameterQualifications,
			char[][] parameterSimpleNames, char[][] parameterNames,
			char[] returnQualification, char[] returnSimpleName,
			char[] declaringQualification, char[] declaringSimpleName,
			int modifiers, String path) {
		
		//do nothing
	}

	private void acceptQualifiedTypes() {
		if(this.acceptedClasses != null){

			localParser.inferTypes(parsedUnit,this.compilerOptions);
			return parsedUnit;
		} catch (AbortCompilationUnit e) {
			throw e; // want to abort enclosing request to compile
//			// one requested further along to resolve sourceUnit.
//			if (unitResult.compilationUnit == sourceUnit) { // only report once
//				requestor.acceptResult(unitResult.tagAsAccepted());
//			} else {
				throw e; // want to abort enclosing request to compile
//			}
		}

	}

}

Lines 60-65 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/ISourceElementRequestor.java (+1 lines)
60	public int nameSourceEnd;	60	public int nameSourceEnd;
61	public char[][] parameterTypes;	61	public char[][] parameterTypes;
62	public char[][] parameterNames;	62	public char[][] parameterNames;
		63	public char[] declaringType;
63	public char[][] categories;	64	public char[][] categories;
64	}	65	}
65		66

Lines 193-199 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/SourceElementParser.java (-1 / +22 lines)
193		193
194	char[] selector = Util.getTypeName(leftHandSide);	194	char[] selector = Util.getTypeName(leftHandSide);
195	MethodDeclaration methodDecl = ((IFunctionExpression) righHandSide).getMethodDeclaration();	195	MethodDeclaration methodDecl = ((IFunctionExpression) righHandSide).getMethodDeclaration();
196	if(selector != null && methodDecl.isConstructor()) {	196	if(selector != null /&& methodDecl.isConstructor() /) {
197	notifySourceElementRequestor(methodDecl,	197	notifySourceElementRequestor(methodDecl,
198	selector);	198	selector);
199	}	199	}
Lines 798-803 Link Here
798	methodInfo.parameterTypes = argumentTypes;	798	methodInfo.parameterTypes = argumentTypes;
799	methodInfo.parameterNames = argumentNames;	799	methodInfo.parameterNames = argumentNames;
800	methodInfo.categories = (char[][]) this.nodesToCategories.get(methodDeclaration);	800	methodInfo.categories = (char[][]) this.nodesToCategories.get(methodDeclaration);
		801	InferredMethod inferredMeth = methodDeclaration.getInferredMethod();
		802	if(inferredMeth != null) {
		803	InferredType declaringType = inferredMeth.inType;
		804	if(declaringType != null) {
		805	methodInfo.declaringType = declaringType.getName();
		806	}
		807	}
801		808
802	//enter either constructor or method where appropriate	809	//enter either constructor or method where appropriate
803	if(methodInfo.isConstructor) {	810	if(methodInfo.isConstructor) {
Lines 916-921 Link Here
916	methodInfo.parameterTypes = argumentTypes;	923	methodInfo.parameterTypes = argumentTypes;
917	methodInfo.parameterNames = argumentNames;	924	methodInfo.parameterNames = argumentNames;
918	methodInfo.categories = (char[][]) this.nodesToCategories.get(methodDeclaration);	925	methodInfo.categories = (char[][]) this.nodesToCategories.get(methodDeclaration);
		926	InferredMethod inferredMeth = methodDeclaration.getInferredMethod();
		927	if(inferredMeth != null) {
		928	InferredType declaringType = inferredMeth.inType;
		929	if(declaringType != null) {
		930	methodInfo.declaringType = declaringType.getName();
		931	}
		932	}
919	requestor.enterConstructor(methodInfo);	933	requestor.enterConstructor(methodInfo);
920	}	934	}
921	/* need this check because a constructor could have been made a constructor after the	935	/* need this check because a constructor could have been made a constructor after the
Lines 970-975 Link Here
970	methodInfo.parameterTypes = argumentTypes;	984	methodInfo.parameterTypes = argumentTypes;
971	methodInfo.parameterNames = argumentNames;	985	methodInfo.parameterNames = argumentNames;
972	methodInfo.categories = (char[][]) this.nodesToCategories.get(methodDeclaration);	986	methodInfo.categories = (char[][]) this.nodesToCategories.get(methodDeclaration);
		987	InferredMethod inferredMeth = methodDeclaration.getInferredMethod();
		988	if(inferredMeth != null) {
		989	InferredType declaringType = inferredMeth.inType;
		990	if(declaringType != null) {
		991	methodInfo.declaringType = declaringType.getName();
		992	}
		993	}
973	requestor.enterMethod(methodInfo);	994	requestor.enterMethod(methodInfo);
974	}	995	}
975		996




}

void connectTypeHierarchy(char[][] typeNames) {
		// if(superType!=null) {
		// if(superType instanceof SourceTypeBinding) {
		// ((SourceTypeBinding)superType).classScope.buildFieldsAndMethods();
		// ((SourceTypeBinding)superType).classScope.connectTypeHierarchy();
		//
		// }
		// ReferenceBinding[] memberTypes = superType.memberTypes();
		// ReferenceBinding[] memberFields = superType.typeVariables();
		// FunctionBinding[] memberMethods = superType.availableMethods();
		// for(int i=0;i<memberTypes.length;i++) {
		// recordReference(memberTypes[i], memberTypes[i].sourceName);
		// }
		// }

		// if(superTypeName!=null) {
		// ReferenceBinding binding = environment.askForType(new char[][]
		// {superTypeName});
		// this.recordSuperTypeReference(binding);
		// }
		if (classScope != null)
			classScope.connectTypeHierarchy();
		nextType: for (int i = 0; i < referenceContext.numberInferredTypes; i++) {

					continue nextType;
			
		}
			if (inferredType.binding != null && inferredType.binding.classScope != null) {
				inferredType.binding.classScope.connectTypeHierarchy();
			}
		}
}
void connectTypeHierarchy() {




import org.eclipse.wst.jsdt.internal.compiler.impl.ITypeRequestor;
import org.eclipse.wst.jsdt.internal.core.search.BasicSearchEngine;
import org.eclipse.wst.jsdt.internal.core.search.IConstructorRequestor;
import org.eclipse.wst.jsdt.internal.core.search.IMethodRequestor;
import org.eclipse.wst.jsdt.internal.core.search.IRestrictedAccessBindingRequestor;
import org.eclipse.wst.jsdt.internal.core.search.IRestrictedAccessTypeRequestor;


					for (int i = 0, index = 1; i < length; i++) {
						ISourceType otherType = (ISourceType) ((JavaElement) types[i])
								.getElementInfo();
						//check that the index is in bounds (see Bug 62861)
						if (!otherType.equals(topLevelType) && index < length) {
																				// the
																				// index
																				// is
																				// in
																				// bounds
																				// (see
																				// https://bugs.eclipse.org/bugs/show_bug.cgi?id=62861)
							sourceTypes[index++] = otherType;
						}
					}
					return new NameEnvironmentAnswer(sourceTypes,
							answer.restriction);

				System.arraycopy(elements, 0, units, 0, elements.length);
				return new NameEnvironmentAnswer(units,answer.restriction);
			}
				// return new NameEnvironmentAnswer((IBinaryType) ((BinaryType)
				// answer.type).getElementInfo(), answer.restriction);
		}
		return null;
	}

				}
			}

			IProgressMonitor progressMonitor = new CancelableProgressMonitor();
			

				public void beginTask(String name, int totalWork) {
					// implements interface method
				}

				public void done() {
					// implements interface method
				}

				public void internalWorked(double work) {
					// implements interface method
				}

				public boolean isCanceled() {
					return isCanceled;
				}

				public void setCanceled(boolean value) {
					isCanceled = value;
				}

				public void setTaskName(String name) {
					// implements interface method
				}

				public void subTask(String name) {
					// implements interface method
				}

				public void worked(int work) {
					// implements interface method
				}
			};
			IRestrictedAccessBindingRequestor bindingRequestor = new IRestrictedAccessBindingRequestor() {
				String exclude;
				public boolean acceptBinding(int type,int modifiers, char[] packageName,

			findTypes(new String(prefix), storage, NameLookup.ACCEPT_ALL);
		}
	}
	
	/**
	 * 
	 * TODO: IAN: doc me!
	 * 
	 * @param selectorPrefix
	 * @param declaringTypeName
	 * @param storage
	 */
	public void findMethods(char[] selectorPrefix, String declaringTypeName, final ISearchRequestor storage) {
		
		//calculate the exclude path
		final String excludePath;
		if (this.unitToSkip != null && this.unitToSkip instanceof IJavaScriptElement) {
			excludePath = ((IJavaScriptElement)this.unitToSkip).getPath().toString();
		} else {
			excludePath = null;
		}
		
		//create the requester
		IMethodRequestor requestor = new IMethodRequestor() {
			public void acceptMethod(char[] signature,
					int parameterCount,
					char[][] parameterQualifications, char[][] parameterSimpleNames,
					char[][] parameterNames,
					char[] returnQualification, char[] returnSimpleName,
					char[] declaringQualification, char[] declaringSimpleName,
					int modifiers,
					String path) {
				
				if (excludePath == null || !excludePath.equals(path)) {
					storage.acceptMethod(signature, parameterCount, parameterQualifications, parameterSimpleNames, parameterNames,
							returnQualification, returnSimpleName, declaringQualification, declaringSimpleName, modifiers, path);
				}
			}
		};
		
		/* if selector specified then search for any selector with the given selector as a prefix
		 * else search for any selector
		 */
		char[] selectorPattern;
		int selectorPatternMatchRule;
		if(selectorPrefix != null) {
			selectorPattern = selectorPrefix;
			selectorPatternMatchRule = SearchPattern.R_PREFIX_MATCH;
		} else {
			selectorPattern = new char[] {'*'};
			selectorPatternMatchRule = SearchPattern.R_PATTERN_MATCH;
		}
		
		/* if a declaring type name is specified then make it the pattern for matching
		 * else find methods not on a type
		 */
		String declaringType;
		if(declaringTypeName != null) {
			declaringType = declaringTypeName;
		} else {
			declaringType = null;
		}
		
		//do the search
		new BasicSearchEngine(this.workingCopies).searchAllMethods(
				requestor,
				selectorPattern,
				declaringType,
				selectorPatternMatchRule,
				this.searchScope,
				WAIT_UNTIL_READY_TO_SEARCH,
				new CancelableProgressMonitor());
	}

	/**
	 * <p>The progress monitor is used to be able to cancel completion operations</p>

			excludePath = null;
		}

		IProgressMonitor progressMonitor = new CancelableProgressMonitor();
			boolean isCanceled = false;
			public void beginTask(String name, int totalWork) {
				// implements interface method
			}
			public void done() {
				// implements interface method
			}
			public void internalWorked(double work) {
				// implements interface method
			}
			public boolean isCanceled() {
				return this.isCanceled;
			}
			public void setCanceled(boolean value) {
				this.isCanceled = value;
			}
			public void setTaskName(String name) {
				// implements interface method
			}
			public void subTask(String name) {
				// implements interface method
			}
			public void worked(int work) {
				// implements interface method
			}
		};
		
		IConstructorRequestor constructorRequestor = new IConstructorRequestor() {
			/**

			this.nameLookup.seekBindings(prefix, bindingType,null, true, type, requestor);
		} else {
			throw new UnimplementedException("shouldnt get here"); //$NON-NLS-1$
//			String packageName = prefix.substring(0, index);
//			JavaElementRequestor elementRequestor = new JavaElementRequestor();
//			this.nameLookup.seekPackageFragments(packageName, false,
//					elementRequestor);
//			IPackageFragment[] fragments = elementRequestor
//					.getPackageFragments();
//			if (fragments != null) {
//				String className = prefix.substring(index + 1);
//				for (int i = 0, length = fragments.length; i < length; i++)
//					if (fragments[i] != null)
//						this.nameLookup.seekTypes(className, fragments[i],
//								true, type, requestor);
//			}
		}
	}
	/**

	{
		nameLookup.setScriptFile(file);
	}
	
	/**
	 * 
	 * TODO: IAN: doc me!
	 *
	 */
	private static class CancelableProgressMonitor implements IProgressMonitor {
		boolean isCanceled = false;
		public void beginTask(String name, int totalWork) {
			// implements interface method
		}
		public void done() {
			// implements interface method
		}
		public void internalWorked(double work) {
			// implements interface method
		}
		public boolean isCanceled() {
			return this.isCanceled;
		}
		public void setCanceled(boolean value) {
			this.isCanceled = value;
		}
		public void setTaskName(String name) {
			// implements interface method
		}
		public void subTask(String name) {
			// implements interface method
		}
		public void worked(int work) {
			// implements interface method
		}
	}
}

Lines 52-58 Link Here

(-)src/org/eclipse/wst/jsdt/internal/core/index/DiskIndex.java (-1 / +1 lines)
52	private int bufferIndex, bufferEnd; // used when reading from the file into the streamBuffer	52	private int bufferIndex, bufferEnd; // used when reading from the file into the streamBuffer
53	private int streamEnd; // used when writing data from the streamBuffer to the file	53	private int streamEnd; // used when writing data from the streamBuffer to the file
54		54
55	public static final String SIGNATURE= "INDEX VERSION 1.122"; //$NON-NLS-1$	55	public static final String SIGNATURE= "INDEX VERSION 1.123"; //$NON-NLS-1$
56	private static final char[] SIGNATURE_CHARS = SIGNATURE.toCharArray();	56	private static final char[] SIGNATURE_CHARS = SIGNATURE.toCharArray();
57	public static boolean DEBUG = false;	57	public static boolean DEBUG = false;
58		58




							true,false,true,
							bindingName,
							null,null,null,null,
							null,null,
							matchRule);

				}

						searchPattern = new MethodPattern(
								true,false,true,
								bindingName,
								null,null,null,null,
								null,null,null,
								matchRule);

					}


			// Get working copy path(s). Store in a single string in case of only one to optimize comparison in requestor
			final HashSet workingCopyPaths = new HashSet();
			String workingCopyPath = null;
			IJavaScriptUnit[] copies = getWorkingCopies();
			final int copiesLength = copies == null ? 0 : copies.length;
			if (copies != null) {
				for (int i = 0; i < copiesLength; i++) {
					IJavaScriptUnit workingCopy = copies[i];
					workingCopyPaths.add(workingCopy.getPath().toString());
					for (int i = 0; i < copiesLength; i++) {
						IJavaScriptUnit workingCopy = copies[i];
						workingCopyPaths.add(workingCopy.getPath().toString());
					}
				}
			}
			final String singleWkcpPath = workingCopyPath;

			// Index requester
			IndexQueryRequestor searchRequestor = new IndexQueryRequestor(){
				public boolean acceptIndexMatch(String documentPath, SearchPattern indexRecord, SearchParticipant participant, AccessRuleSet access) {
					// Filter unexpected types

										}
										return true;
									}
//									public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope classScope) {
//										if (match(typeSuffix, packageName, bindingName, matchRule, TypeDeclaration.kind(memberTypeDeclaration.modifiers), packageDeclaration, memberTypeDeclaration.name)) {
//											// compute encloising type names
//											TypeDeclaration enclosing = memberTypeDeclaration.enclosingType;
//											char[][] enclosingTypeNames = CharOperation.NO_CHAR_CHAR;
//											while (enclosing != null) {
//												enclosingTypeNames = CharOperation.arrayConcat(new char[][] {enclosing.name}, enclosingTypeNames);
//												if ((enclosing.bits & ASTNode.IsMemberType) != 0) {
//													enclosing = enclosing.enclosingType;
//												} else {
//													enclosing = null;
//												}
//											}
//											// report
//											nameRequestor.acceptType(memberTypeDeclaration.modifiers, packageDeclaration, memberTypeDeclaration.name, enclosingTypeNames, path, null);
//										}
//										return true;
//									}
									public boolean visit(InferredType inferredType, BlockScope scope) {
										if (bindingType==Binding.TYPE &&
													match(typeSuffix, packageName, bindingName, matchRule, TypeDeclaration.kind(0), packageDeclaration, inferredType.getName())) {

						record.modifiers,
						record.declaringSimpleName,
						record.parameterCount,
						record.parameterTypeNames,
						record.parameterNames,
						documentPath,
						accessRestriction);

			}
		}
	}
	
	/**
	 * 
	 * TODO: IAN: doc me!
	 * 
	 * @param selectorPattern
	 * @param declaringType
	 * @param selectorPatternMatchRule
	 * @param declaringTypepatternMatchRule
	 */
	public void searchAllMethods(final IMethodRequestor methodRequestor,
			char[] selectorPattern, String declaringType, int selectorPatternMatchRule,
			IJavaScriptSearchScope scope,
			int waitingPolicy, IProgressMonitor progressMonitor) {
		
		char[] declaringTypePatternChars = null;
		if(declaringType != null && declaringType.trim().length() > 0) {
			declaringTypePatternChars = declaringType.toCharArray();
		}
		
		MethodPattern pattern = new MethodPattern(true, false,
				selectorPattern, declaringTypePatternChars, selectorPatternMatchRule);
		
		IndexQueryRequestor queryRequestor = new IndexQueryRequestor() {
			
			/**
			 * @see org.eclipse.wst.jsdt.internal.core.search.IndexQueryRequestor#acceptIndexMatch(java.lang.String, org.eclipse.wst.jsdt.core.search.SearchPattern, org.eclipse.wst.jsdt.core.search.SearchParticipant, org.eclipse.wst.jsdt.internal.compiler.env.AccessRuleSet)
			 */
			public boolean acceptIndexMatch(String documentPath,
					SearchPattern indexRecord, SearchParticipant participant,
					AccessRuleSet access) {
				
				MethodPattern record = (MethodPattern)indexRecord;
				methodRequestor.acceptMethod(record.selector, record.parameterCount, record.parameterQualifications, record.parameterSimpleNames,
						record.parameterNames, record.returnQualification, record.returnSimpleName,
						record.declaringQualification, record.declaringSimpleName, record.modifiers,
						documentPath);
				
				return true;
			}
		};
		
		IndexManager indexManager = JavaModelManager.getJavaModelManager().getIndexManager();
		try {
			if (progressMonitor != null) {
				progressMonitor.beginTask(Messages.engine_searching, 1000);
			}
			// Find constructor declarations from index
			indexManager.performConcurrentJob(
				new PatternSearchJob(
					pattern,
					getDefaultSearchParticipant(), // JavaScript search only
					scope,
					queryRequestor),
				waitingPolicy,
				progressMonitor == null ? null : new SubProgressMonitor(progressMonitor, 1000));
		} finally {
			if (progressMonitor != null) {
				progressMonitor.done();
			}
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2011 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.internal.core.search;

/**
 * TODO: IAN: doc me!
 *
 */
public interface IMethodRequestor {

	/**
	 * 
	 * TODO: IAN: doc me!
	 * 
	 * @param signature
	 * @param parameterCount
	 * @param parameterQualifications
	 * @param parameterSimpleNames
	 * @param parameterNames
	 * @param returnQualification
	 * @param returnSimpleName
	 * @param declaringQualification
	 * @param declaringSimpleName
	 * @param modifiers
	 * @param path
	 */
	public void acceptMethod(
				char[] signature,
				int parameterCount,
				char[][] parameterQualifications,
				char[][] parameterSimpleNames,
				char[][] parameterNames,
				char[] returnQualification,
				char[] returnSimpleName,
				char[] declaringQualification,
				char[] declaringSimpleName,
				int modifiers,
				String path);
}




/*******************************************************************************
 * Copyright (c) 2000, 2011 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

 */
public abstract class IndexQueryRequestor {

	/**
	 * 
	 * TODO: IAN: doc me!
	 * 
	 * @param documentPath
	 * @param indexRecord
	 * @param participant
	 * @param access
	 * 
	 * @return <code>true</code> to continue search, <code>false</code> to request cancel of search
	 */
	public abstract boolean acceptIndexMatch(String documentPath, SearchPattern indexRecord, SearchParticipant participant, AccessRuleSet access);

}

Lines 74-83 Link Here

(-)src/org/eclipse/wst/jsdt/internal/core/search/indexing/AbstractIndexer.java (-4 / +13 lines)
74	protected void addIndexEntry(char[] category, char[] key) {	74	protected void addIndexEntry(char[] category, char[] key) {
75	this.document.addIndexEntry(category, key);	75	this.document.addIndexEntry(category, key);
76	}	76	}
77	public void addMethodDeclaration(char[] methodName, char[][] parameterTypes,	77	public void addMethodDeclaration(char[] methodName, char[][] parameterTypes, char[][] paramaterNames,
78	char[] returnType,boolean isFunction) {	78	char[] returnType, char[] declaringType, boolean isFunction, int modifiers) {
79	int argCount = parameterTypes == null ? 0 : parameterTypes.length;	79	int argCount = parameterTypes == null ? 0 : parameterTypes.length;
80	addIndexEntry(isFunction ? FUNCTION_DECL : METHOD_DECL, MethodPattern.createIndexKey(methodName, argCount));	80
		81	//compute key
		82	char[] key = MethodPattern.createIndexKey(methodName, argCount,
		83	parameterTypes, paramaterNames, declaringType, returnType, modifiers);
		84	if(key != null) {
		85	addIndexEntry(isFunction ? FUNCTION_DECL : METHOD_DECL, key);
		86	}
81		87
82	if (parameterTypes != null) {	88	if (parameterTypes != null) {
83	for (int i = 0; i < argCount; i++)	89	for (int i = 0; i < argCount; i++)
Lines 87-93 Link Here
87	addTypeReference(returnType);	93	addTypeReference(returnType);
88	}	94	}
89	public void addMethodReference(char[] methodName, int argCount) {	95	public void addMethodReference(char[] methodName, int argCount) {
90	addIndexEntry(METHOD_REF, MethodPattern.createIndexKey(methodName, argCount));	96	char[] key = MethodPattern.createIndexKey(methodName, argCount);
		97	if(key != null) {
		98	addIndexEntry(METHOD_REF, key);
		99	}
91	}	100	}
92	public void addNameReference(char[] name) {	101	public void addNameReference(char[] name) {
93	addIndexEntry(REF, name);	102	addIndexEntry(REF, name);




public interface IIndexConstants {

	/* index encoding */
	final char[] REF= "ref".toCharArray(); //$NON-NLS-1$
	final char[] METHOD_REF= "methodRef".toCharArray(); //$NON-NLS-1$
	final char[] CONSTRUCTOR_REF= "constructorRef".toCharArray(); //$NON-NLS-1$
	final char[] SUPER_REF = "superRef".toCharArray(); //$NON-NLS-1$
	final char[] TYPE_DECL = "typeDecl".toCharArray(); //$NON-NLS-1$
	final char[] METHOD_DECL= "methodDecl".toCharArray(); //$NON-NLS-1$
	final char[] FUNCTION_DECL= "functionDecl".toCharArray(); //$NON-NLS-1$
	final char[] CONSTRUCTOR_DECL= "constructorDecl".toCharArray(); //$NON-NLS-1$
	final char[] FIELD_DECL= "fieldDecl".toCharArray(); //$NON-NLS-1$
	final char[] VAR_DECL= "varDecl".toCharArray(); //$NON-NLS-1$
	final char[] OBJECT = "Object".toCharArray(); //$NON-NLS-1$
	final char[][] COUNTS=
		new char[][] { new char[] {'/', '0'}, new char[] {'/', '1'}, new char[] {'/', '2'}, new char[] {'/', '3'}, new char[] {'/', '4'},
			new char[] {'/', '5'}, new char[] {'/', '6'}, new char[] {'/', '7'}, new char[] {'/', '8'}, new char[] {'/', '9'}
	};
	final char CLASS_SUFFIX = 'C';
	final char TYPE_SUFFIX = 0;
	final char SEPARATOR= '/';
	final char PARAMETER_SEPARATOR= ',';
	final char SECONDARY_SUFFIX = 'S';
	final char DOT = '.';

	final char[] ONE_STAR = new char[] {'*'};
	final char[][] ONE_STAR_CHAR = new char[][] {ONE_STAR};

	// used as special marker for enclosing type name of local and anonymous classes
	final char ZERO_CHAR = '0';
	final char[] ONE_ZERO = new char[] { ZERO_CHAR };
	final char[][] ONE_ZERO_CHAR = new char[][] {ONE_ZERO};

	final int PKG_REF_PATTERN = 0x0001;
	final int PKG_DECL_PATTERN = 0x0002;
	final int TYPE_REF_PATTERN = 0x0004;
	final int TYPE_DECL_PATTERN = 0x0008;
	final int SUPER_REF_PATTERN = 0x0010;
	final int CONSTRUCTOR_PATTERN = 0x0020;
	final int FIELD_PATTERN = 0x0040;
	final int METHOD_PATTERN = 0x0080;
	final int OR_PATTERN = 0x0100;
	final int LOCAL_VAR_PATTERN = 0x0200;
}




import org.eclipse.wst.jsdt.internal.compiler.util.SuffixConstants;
import org.eclipse.wst.jsdt.internal.core.BasicCompilationUnit;
import org.eclipse.wst.jsdt.internal.core.JavaModelManager;
import org.eclipse.wst.jsdt.internal.core.Logger;
import org.eclipse.wst.jsdt.internal.core.search.JavaSearchDocument;
import org.eclipse.wst.jsdt.internal.core.search.processing.JobManager;
import org.eclipse.wst.jsdt.internal.oaametadata.LibraryAPIs;
import org.eclipse.wst.jsdt.internal.oaametadata.MetadataReader;
import org.eclipse.wst.jsdt.internal.oaametadata.MetadataSourceElementNotifier;

		try {
			parser.parseCompilationUnit(compilationUnit, true/*full parse*/);
		} catch (Exception e) {
			Logger.logException("Error while indexing document", e);
				e.printStackTrace();
			}
		}
	}
	public void indexMetadata() {

Lines 190-196 Link Here

(-)src/org/eclipse/wst/jsdt/internal/core/search/indexing/SourceIndexerRequestor.java (-1 / +3 lines)
190	*/	190	*/
191	public void enterMethod(MethodInfo methodInfo) {	191	public void enterMethod(MethodInfo methodInfo) {
192	boolean isFunction=this.depth==0;	192	boolean isFunction=this.depth==0;
193	this.indexer.addMethodDeclaration(methodInfo.name, methodInfo.parameterTypes, methodInfo.returnType,isFunction);	193	this.indexer.addMethodDeclaration(methodInfo.name, methodInfo.parameterTypes,
		194	methodInfo.parameterNames, methodInfo.returnType, methodInfo.declaringType,
		195	isFunction, methodInfo.modifiers);
194	this.methodDepth++;	196	this.methodDepth++;
195	}	197	}
196	/**	198	/**





import org.eclipse.wst.jsdt.core.compiler.CharOperation;
import org.eclipse.wst.jsdt.core.search.SearchPattern;
import org.eclipse.wst.jsdt.internal.compiler.classfmt.ClassFileConstants;

/**
 * <p>Pattern used to find and store constructor declarations.</p>
 */
public class ConstructorDeclarationPattern extends ConstructorPattern {
	/** <p> Modifiers for the constructor</p> */
	public int modifiers;
	
	/** <p>Fully qualified type names for the parameters of the constructor</p> */
	public char[][] parameterTypeNames;
	
	/** <p>names of the parameters</p> */
	public char[][] parameterNames;

	public ConstructorDeclarationPattern(char[] declaringSimpleName, int matchRule) {

		
		// initialize optional fields
		this.modifiers = 0;
		this.parameterTypeNames = null;
		this.parameterNames = null;
		
		/* if no parameters just decode modifiers
		 * else decode parameters and modifiers
		 */
		start = slash + 1;
		if (this.parameterCount <= 0 ) {
			slash = slash + 3;
			last = slash - 1;
			

			last = slash - 1;
			
			
			this.parameterTypeNames = CharOperation.splitOn(PARAMETER_SEPARATOR, key, start, slash);
			
			start = slash + 1;
			slash = CharOperation.indexOf(SEPARATOR, key, start);

			last = slash - 1;
			
			this.modifiers = key[last-1] + (key[last]<<16);
		} else {
			this.modifiers = ClassFileConstants.AccPublic;
		}
	}
	

		if (parameterCount > 0) {
			//get param types
			if (parameterTypes != null && parameterTypes.length == parameterCount) {
				parameterTypesChars = CharOperation.concatWith(parameterTypes, PARAMETER_SEPARATOR, false);
				for (int i = 0; i < parameterTypes.length; i++) {
					parameterTypeErasures[i] = getTypeErasure(parameterTypes[i]);
				}
				parameterTypesChars = CharOperation.concatWith(parameterTypeErasures, PARAMETER_SEPARATOR, false);
			}
			
			//get param names

		
		return result;
	}
	
	private static char[] getTypeErasure(char[] typeName) {
		char[] typeErasurename = new char[0];
		if(typeName != null) {
			int index;
			if ((index = CharOperation.indexOf('<', typeName)) == -1) return typeName;
			
			int length = typeName.length;
			typeErasurename = new char[length - 2];
			
			System.arraycopy(typeName, 0, typeErasurename, 0, index);
			
			int depth = 1;
			for (int i = index + 1; i < length; i++) {
				switch (typeName[i]) {
					case '<':
						depth++;
						break;
					case '>':
						depth--;
						break;
					default:
						if (depth == 0) {
							typeErasurename[index++] = typeName[i];
						}
						break;
				}
			}
			
			System.arraycopy(typeErasurename, 0, typeErasurename = new char[index], 0, index);
		}
		return typeErasurename;
	}
}

Lines 21-27 Link Here

(-)src/org/eclipse/wst/jsdt/internal/core/search/matching/DeclarationOfReferencedMethodsPattern.java (-1 / +1 lines)
21	protected SimpleSet knownMethods;	21	protected SimpleSet knownMethods;
22		22
23	public DeclarationOfReferencedMethodsPattern(IJavaScriptElement enclosingElement) {	23	public DeclarationOfReferencedMethodsPattern(IJavaScriptElement enclosingElement) {
24	super(false, true, false,null, null, null, null, null, null, null, null, R_PATTERN_MATCH);	24	super(false, true, false,null, R_PATTERN_MATCH);
25		25
26	this.enclosingElement = enclosingElement;	26	this.enclosingElement = enclosingElement;
27	this.knownMethods = new SimpleSet();	27	this.knownMethods = new SimpleSet();




import org.eclipse.wst.jsdt.core.infer.InferredMethod;
import org.eclipse.wst.jsdt.core.search.MethodDeclarationMatch;
import org.eclipse.wst.jsdt.core.search.SearchMatch;
import org.eclipse.wst.jsdt.core.search.SearchPattern;
import org.eclipse.wst.jsdt.internal.compiler.ast.ASTNode;
import org.eclipse.wst.jsdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.wst.jsdt.internal.compiler.ast.Argument;

		}
	}

	// Verify type arguments (do not reject if pattern has no argument as it can be an erasure match)
	if (this.pattern.hasMethodArguments()) {
		return IMPOSSIBLE_MATCH;
	}

	// Method declaration may match pattern
	return nodeSet.addMatch(node, resolve ? POSSIBLE_MATCH : ACCURATE_MATCH);
}

	if (!this.pattern.findReferences) return IMPOSSIBLE_MATCH;

	if (!matchesName(this.pattern.selector, node.selector)) return IMPOSSIBLE_MATCH;
	if (this.pattern.parameterSimpleNames != null && ((node.bits & ASTNode.InsideJavadoc) != 0)) {
		int length = this.pattern.parameterSimpleNames.length;
		ASTNode[] args = node.arguments;
		int argsLength = args == null ? 0 : args.length;

	}
}
void matchReportReference(MessageSend messageSend, MatchLocator locator, MethodBinding methodBinding) throws CoreException {

	if (this.pattern.hasMethodArguments()) { // binding has no type params, compatible erasure if pattern does
		match.setRule(SearchPattern.R_ERASURE_MATCH);
	}

	// See whether it is necessary to report or not
	if (match.getRule() == 0) return; // impossible match
	boolean report = (this.isErasureMatch && match.isErasure()) || (this.isEquivalentMatch && match.isEquivalent()) || match.isExact();

	match.setLength(messageSend.sourceEnd - offset + 1);
	locator.report(match);
}
/*
 * Return whether method parameters are equals to pattern ones.
 */
private boolean methodParametersEqualsPattern(MethodBinding method) {
	TypeBinding[] methodParameters = method.parameters;

	int length = methodParameters.length;
	if (length != this.pattern.parameterSimpleNames.length) return false;

	for (int i = 0; i < length; i++) {
		char[] paramQualifiedName = qualifiedPattern(this.pattern.parameterSimpleNames[i], this.pattern.parameterQualifications[i]);
		if (!CharOperation.match(paramQualifiedName, methodParameters[i].readableName(), this.isCaseSensitive)) {
			return false;
		}
	}
	return true;
}
public SearchMatch newDeclarationMatch(ASTNode reference, IJavaScriptElement element, Binding elementBinding, int accuracy, int length, MatchLocator locator) {
	if (elementBinding != null) {
		MethodBinding methodBinding = (MethodBinding) elementBinding;

						nodeSet.mustResolve = true;
						resolve = true;
					}
					this.methodDeclarationsWithInvalidParam.put(inferredMethod.getFunctionDeclaration(), null);
				} else {
					return IMPOSSIBLE_MATCH;
				}





import java.io.IOException;

import org.eclipse.wst.jsdt.core.Flags;
import org.eclipse.wst.jsdt.core.IFunction;
import org.eclipse.wst.jsdt.core.IType;
import org.eclipse.wst.jsdt.core.JavaScriptModelException;
import org.eclipse.wst.jsdt.core.compiler.CharOperation;
import org.eclipse.wst.jsdt.core.search.SearchPattern;
import org.eclipse.wst.jsdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.wst.jsdt.internal.core.Logger;
import org.eclipse.wst.jsdt.internal.core.index.EntryResult;
import org.eclipse.wst.jsdt.internal.core.index.Index;
import org.eclipse.wst.jsdt.internal.core.util.TypeQulificationHelpers;

public class MethodPattern extends JavaSearchPattern  {

protected boolean findDeclarations;
protected boolean findReferences;

public char[] selector;

public char[] declaringQualification;
public char[] declaringSimpleName;

public char[] returnQualification;
public char[] returnSimpleName;

public char[][] parameterQualifications;
public char[][] parameterSimpleNames;
public int parameterCount;
public boolean varargs = false;

protected boolean isFunction;
// extra reference info
protected IType declaringType;

// Signatures and arguments for generic search
char[][] returnTypeSignatures;
char[][][] returnTypeArguments;
char[][][] parametersTypeSignatures;
char[][][][] parametersTypeArguments;
boolean methodParameters = false;
char[][] methodArguments;

protected static char[][] REF_CATEGORIES = { METHOD_REF };
protected static char[][] REF_AND_DECL_CATEGORIES = { METHOD_REF, METHOD_DECL };
protected static char[][] DECL_CATEGORIES = { METHOD_DECL };
protected static char[][] FUNCTION_REF_AND_DECL_CATEGORIES = { METHOD_REF, FUNCTION_DECL, METHOD_DECL };
protected static char[][] FUNCTION_DECL_CATEGORIES = { FUNCTION_DECL, METHOD_DECL };

/**
 * 
 * TODO: IAN: doc me!
 *
 */
public class MethodPattern extends JavaSearchPattern  {
	char[] countChars = argCount < 10
		? COUNTS[argCount]
		: ("/" + String.valueOf(argCount)).toCharArray(); //$NON-NLS-1$
	return CharOperation.concat(selector, countChars);
}

MethodPattern(int matchRule, boolean isFunction) {
	super(METHOD_PATTERN, matchRule);
	this.isFunction=isFunction;
}
public MethodPattern(
	boolean findDeclarations,
	boolean findReferences,
	boolean isFunction,
	char[] selector,
	char[] declaringQualification,
	char[] declaringSimpleName,
	char[] returnQualification,
	char[] returnSimpleName,
	char[][] parameterQualifications,
	char[][] parameterSimpleNames,
	IType declaringType,
	int matchRule) {

	this(matchRule,isFunction);

	this.findDeclarations = findDeclarations;
	this.findReferences = findReferences;

	protected static final char[][] REF_CATEGORIES = { METHOD_REF };
	protected static final char[][] REF_AND_DECL_CATEGORIES = { METHOD_REF, METHOD_DECL };
	protected static final char[][] DECL_CATEGORIES = { METHOD_DECL };
	protected static final char[][] FUNCTION_REF_AND_DECL_CATEGORIES = { METHOD_REF, FUNCTION_DECL, METHOD_DECL };
	protected static final char[][] FUNCTION_DECL_CATEGORIES = { FUNCTION_DECL, METHOD_DECL };
	
	/**
	 * <p><b>Required</b></p>
	 * 
	 * <p>Name of the function</p>
	 */
	public char[] selector;
	
	/**
	 * <p><b>Optional</b></p>
	 * 
	 * <p>Qualification of the declaring type containing this function.</p>
	 * 
	 * <p><b>Note:</b> If this field is defined then the {@link #declaringSimpleName} must
	 * also be defined.</p>
	 * 
	 * @see #declaringSimpleName
	 */
	public char[] declaringQualification;
	
	/**
	 * <p><b>Optional</b></p>
	 * 
	 * <p>Simple name of the declaring type containing this function.</p>
	 * 
	 * <p><b>Note:</b> If this field is defined then the {@link #declaringQualification}
	 * can be defined, but does not have to be.</p>
	 * 
	 * @see #declaringQualification
	 */
	public char[] declaringSimpleName;
	
	/**
	 * <p><b>Required</b></p>
	 * 
	 * <p>Number of specified parameters for this function.
	 * Must be equal to or greater then 0.</p>
	 */
	public int parameterCount;
	
	/**
	 * <p><b>Optional</b></p>
	 * 
	 * <p>Qualifications of the parameter types for this function.</p>
	 * <p>This should have the same length as {@link #parameterCount}, or
	 * <code>null</code> if {@link #parameterCount} is 0</p>
	 * 
	 * <p><b>Note:</b> If this field is defined then the {@link #parameterSimpleNames} must
	 * also be defined.</p>
	 * 
	 * @see #parameterSimpleNames
	 */
	public char[][] parameterQualifications;
	
	/**
	 * <p><b>Optional</b></p>
	 * 
	 * <p>Simple names of the parameter types for this function.</p>
	 * <p>This should have the same length as {@link #parameterCount}, or
	 * <code>null</code> if {@link #parameterCount} is 0</p>
	 * 
	 * <p><b>Note:</b> If this field is defined then the {@link #parameterQualifications}
	 * filed can be defined, but does not have to be.</p>
	 * 
	 * @see #parameterQualifications
	 */
	public char[][] parameterSimpleNames;
	
	/**
	 * <p><b>Required</b> if {@link #parameterCount} is greater then 0</p>
	 * 
	 * <p>Names of the defined parameters for this function.</p>
	 * <p>This should have the same length as {@link #parameterCount}, or
	 * <code>null</code> if {@link #parameterCount} is 0</p>
	 */
	public char[][] parameterNames;
	
	/**
	 * <p><b>Optional</b></p>
	 * 
	 * <p>Qualification of the return type of this function.</p>
	 * 
	 * <p><b>Note:</b> If this field is defined then the {@link #returnSimpleName} must
	 * also be defined.</p>
	 */
	public char[] returnQualification;
	
	/**
	 * <p><b>Optional</b></p>
	 * 
	 * <p>Simple name of the return type of this function.</p>
	 * 
	 * <p><b>Note:</b> If this field is defined then the {@link #returnQualification}
	 * filed can be defined, but does not have to be.</p>
	 */
	public char[] returnSimpleName;
	
	/**
	 * <p><b>Optional</b></p>
	 * 
	 * <p>Any modifiers for this function.</p>
	 * 
	 * @see ClassFileConstants
	 */
	public int modifiers;
	
	/**
	 * <p><b>Optional</b></p>
	 * <p>{@link IType} containing this function.</p>
	 * 
	 * <p><b>NOTE:</b> any dependency on this field should be removed</p>
	 */
	protected IType declaringType;
	
	/**
	 * <p>When using this pattern to do a search <code>true</code> to
	 * find function declarations that match this pattern, <code>false</code> otherwise.</p>
	 */
	protected boolean findDeclarations;
	
	/**
	 * <p>When using this pattern to do a search <code>true</code> to
	 * find function references that match this pattern, <code>false</code> otherwise.</p>
	 */
	protected boolean findReferences;
	
	/**
	 * <p><code>true</code> if this pattern represents a function,
	 * <code>false</code> otherwise.</p>
	 * 
	 * <p><b>NOTE:</b> this whole concept should be removed, a funciton is a funciton is a function.</p>
	 */
	protected boolean isFunction;

	/**
	 * <p>Internal constructor for creating plank patterns</p>
	 *
	 * @param matchRule match rule used when comparing this pattern to search results
	 * @param isFunction <code>true</code> if this pattern represents a function,
	 * <code>false</code> otherwise
	 */
	MethodPattern(int matchRule, boolean isFunction) {
		super(METHOD_PATTERN, matchRule);
		this.isFunction=isFunction;
	}
	
	/**
	 * <p>Useful constructor when creating a pattern to search for index matches
	 * while doing content assist.</p>
	 *
	 * @param findDeclarations when using this pattern to do a search <code>true</code> to
	 * find function declarations that match this pattern, <code>false</code> otherwise.
	 * @param findReferences hen using this pattern to do a search <code>true</code> to
	 * find function references that match this pattern, <code>false</code> otherwise
	 * @param isFunction <code>true</code> if this pattern represents a function,
	 * <code>false</code> otherwise
	 * @param selector pattern for the name of the function
	 * @param selectorMatchRule match rule used when comparing this pattern to search results.
	 * This dictates what type of pattern is present, if any, in the specified <code>selector</code>
	 * 
	 * @see SearchPattern
	 */
	public MethodPattern(boolean findDeclarations,
			boolean findReferences,
			boolean isFunction,
			char[] selector,
			int selectorMatchRule) {
		
		this(findDeclarations, findReferences, isFunction, selector,
				null, null, null, null, null, null,
				selectorMatchRule);
		declaringQualification,
		declaringSimpleName,
		returnQualification,
		returnSimpleName,
		parameterQualifications,
		parameterSimpleNames,
		method.getDeclaringType(),
		matchRule);

	// Set flags
	try {
		this.varargs = (method.getFlags() & Flags.AccVarargs) != 0;
	} catch (JavaScriptModelException e) {
		// do nothing
	}
	
	/**
	 * <p>Useful constructor for finding index matches based on content assist pattern.</p>
	 *
	 * @param findDeclarations when using this pattern to do a search <code>true</code> to
	 * find function declarations that match this pattern, <code>false</code> otherwise.
	 * @param findReferences hen using this pattern to do a search <code>true</code> to
	 * find function references that match this pattern, <code>false</code> otherwise
	 * @param selector pattern for the name of the function
	 * @param declaringType optional declaring type that the given selector must be
	 * defined on to be a valid match, or <code>null</code> to specify the function is not
	 * defined on a type
	 * @param selectorMatchRule match rule used when comparing this pattern to search results.
	 * This dictates what type of pattern is present, if any, in the specified <code>selector</code>
	 */
	public MethodPattern(boolean findDeclarations, boolean findReferences,
			char[] selector, char[] declaringType,
			int selectorMatchRule){
		
		this(selectorMatchRule, true);
		
		this.findDeclarations = findDeclarations;
		this.findReferences = findReferences;
		this.selector = selector;
		this.parameterCount = -1;
		
		char[][] seperatedDeclaringType = TypeQulificationHelpers.seperateFullyQualifedName(declaringType);
		this.declaringQualification = seperatedDeclaringType[TypeQulificationHelpers.QULIFIERS_INDEX];
		this.declaringSimpleName = seperatedDeclaringType[TypeQulificationHelpers.SIMPLE_NAMES_INDEX];
	}
	
	/**
	 * 
	 * TODO: IAN: doc me!
	 *
	 * @param findDeclarations
	 * @param findReferences
	 * @param isFunction
	 * @param selector
	 * @param declaringQualification
	 * @param declaringSimpleName
	 * @param returnQualification
	 * @param returnSimpleName
	 * @param parameterQualifications
	 * @param parameterSimpleNames
	 * @param declaringType
	 * @param matchRule
	 */
	public MethodPattern(
			boolean findDeclarations,
			boolean findReferences,
			boolean isFunction,
			char[] selector,
			char[] declaringQualification,
			char[] declaringSimpleName,
			char[] returnQualification,
			char[] returnSimpleName,
			char[][] parameterQualifications,
			char[][] parameterSimpleNames,
			IType declaringType,
			int matchRule) {

		this(matchRule,isFunction);

		this.findDeclarations = findDeclarations;
		this.findReferences = findReferences;

		this.selector = (isCaseSensitive() || isCamelCase())  ? selector : CharOperation.toLowerCase(selector);
		this.declaringQualification = isCaseSensitive() ? declaringQualification : CharOperation.toLowerCase(declaringQualification);
		this.declaringSimpleName = isCaseSensitive() ? declaringSimpleName : CharOperation.toLowerCase(declaringSimpleName);
		this.returnQualification = isCaseSensitive() ? returnQualification : CharOperation.toLowerCase(returnQualification);
		this.returnSimpleName = isCaseSensitive() ? returnSimpleName : CharOperation.toLowerCase(returnSimpleName);
		if (parameterSimpleNames != null) {
			this.parameterCount = parameterSimpleNames.length;
			this.parameterQualifications = new char[this.parameterCount][];
			this.parameterSimpleNames = new char[this.parameterCount][];
			for (int i = 0; i < this.parameterCount; i++) {
				this.parameterQualifications[i] = isCaseSensitive() ? parameterQualifications[i] : CharOperation.toLowerCase(parameterQualifications[i]);
				this.parameterSimpleNames[i] = isCaseSensitive() ? parameterSimpleNames[i] : CharOperation.toLowerCase(parameterSimpleNames[i]);
			}
		} else {
			this.parameterCount = -1;
		}
		this.declaringType = declaringType;
		((InternalSearchPattern)this).mustResolve = false;
	}
	
	/**
	 * 
	 * TODO: IAN: doc me!
	 *
	 * @param findDeclarations
	 * @param findReferences
	 * @param isFunction
	 * @param selector
	 * @param declaringQualification
	 * @param declaringSimpleName
	 * @param returnQualification
	 * @param returnSimpleName
	 * @param parameterQualifications
	 * @param parameterSimpleNames
	 * @param method
	 * @param matchRule
	 */
	public MethodPattern(
		boolean findDeclarations,
		boolean findReferences,
		boolean isFunction,
		char[] selector,
		char[] declaringQualification,
		char[] declaringSimpleName,
		char[] returnQualification,
		char[] returnSimpleName,
		char[][] parameterQualifications,
		char[][] parameterSimpleNames,
		IFunction method,
		int matchRule) {

		this(findDeclarations,
			findReferences,
			isFunction,
			selector,
			declaringQualification,
			declaringSimpleName,
			returnQualification,
			returnSimpleName,
			parameterQualifications,
			parameterSimpleNames,
			method.getDeclaringType(),
			matchRule);
		
		if (declaringType!=null) {
			// Store type signature and arguments for declaring type
			storeTypeSignaturesAndArguments(declaringType);
		}
	}
	
	/**
	 * 
	 * TODO: IAN: doc me!
	 *
	 * @param findDeclarations
	 * @param findReferences
	 * @param isFunction
	 * @param selector
	 * @param declaringQualification
	 * @param declaringSimpleName
	 * @param returnQualification
	 * @param returnSimpleName
	 * @param parameterQualifications
	 * @param parameterSimpleNames
	 * @param matchRule
	 */
	public MethodPattern(
		boolean findDeclarations,
		boolean findReferences,
		boolean isFunction,
		char[] selector,
		char[] declaringQualification,
		char[] declaringSimpleName,
		char[] returnQualification,
		char[] returnSimpleName,
		char[][] parameterQualifications,
		char[][] parameterSimpleNames,
		int matchRule) {

		this(findDeclarations,
			findReferences,
			isFunction,
			selector,
			declaringQualification,
			declaringSimpleName,
			returnQualification,
			returnSimpleName,
			parameterQualifications,
			parameterSimpleNames,
			(IType)null,
			matchRule);
	}
	
	/**
	 * TODO: IAN: doc me
	 * 
	 * @see #createIndexKey(char[], int, char[][], char[][])
	 */
	public void decodeIndexKey(char[] key) {
		char[][] seperated = CharOperation.splitOn(SEPARATOR, key);
		
		//get the selector
		this.selector = seperated[0];
		
		//get the parameter count
		this.parameterCount = Integer.parseInt(new String(seperated[1]));
		
		//get parameter types
		char[][][] parameterTypes = TypeQulificationHelpers.seperateFullyQualifedNames(seperated[2], this.parameterCount);
		this.parameterQualifications = parameterTypes[TypeQulificationHelpers.QULIFIERS_INDEX];
		this.parameterSimpleNames = parameterTypes[TypeQulificationHelpers.SIMPLE_NAMES_INDEX];
		
		//get parameter names
		char[][] parameterNames = CharOperation.splitOn(PARAMETER_SEPARATOR, seperated[3]);
		if(parameterNames.length > 0) {
			this.parameterNames = parameterNames;
		} else {
			this.parameterNames = null;
		}
		
		//get the return type
		char[][] returnType = TypeQulificationHelpers.seperateFullyQualifedName(seperated[4]);
		this.returnQualification = returnType[TypeQulificationHelpers.QULIFIERS_INDEX];
		this.returnSimpleName = returnType[TypeQulificationHelpers.SIMPLE_NAMES_INDEX];
		
		//get the declaration type
		char[][] declaringType = TypeQulificationHelpers.seperateFullyQualifedName(seperated[5]);
		this.declaringQualification = declaringType[TypeQulificationHelpers.QULIFIERS_INDEX];
		this.declaringSimpleName = declaringType[TypeQulificationHelpers.SIMPLE_NAMES_INDEX];
		
		//get the modifiers
		this.modifiers = seperated[6][0] + seperated[6][1];
	}
	
	public SearchPattern getBlankPattern() {
		return new MethodPattern(R_EXACT_MATCH | R_CASE_SENSITIVE,isFunction);
	if (hasMethodArguments())  ((InternalSearchPattern)this).mustResolve = true;
}
/*
 * Instanciate a method pattern with signatures for generics search
 */
public MethodPattern(
	boolean findDeclarations,
	boolean findReferences,
	boolean isFunction,
	char[] selector,
	char[] declaringQualification,
	char[] declaringSimpleName,
	String declaringSignature,
	char[] returnQualification,
	char[] returnSimpleName,
	String returnSignature,
	char[][] parameterQualifications,
	char[][] parameterSimpleNames,
	String[] parameterSignatures,
	char[][] arguments,
	int matchRule) {

	this(findDeclarations,
		findReferences,
		isFunction,
		selector,
		declaringQualification,
		declaringSimpleName,
		returnQualification,
		returnSimpleName,
		parameterQualifications,
		parameterSimpleNames,
		null,
		matchRule);

	// Store type signature and arguments for declaring type
	if (declaringSignature != null) {
		typeSignatures = Util.splitTypeLevelsSignature(declaringSignature);
		setTypeArguments(Util.getAllTypeArguments(typeSignatures));
	}
	public char[][] getIndexCategories() {
		if (this.findReferences)
			return this.findDeclarations ?
					(isFunction ? FUNCTION_REF_AND_DECL_CATEGORIES : REF_AND_DECL_CATEGORIES)
					: REF_CATEGORIES;
		if (this.findDeclarations)
			return isFunction ? FUNCTION_DECL_CATEGORIES : DECL_CATEGORIES;
		return CharOperation.NO_CHAR_CHAR;
	}

	boolean hasMethodParameters() {
		return this.parameterCount > 0;
	}
	boolean isPolymorphicSearch() {
		return this.findReferences;
	}
	public boolean matchesDecodedKey(SearchPattern decodedPattern) {
		MethodPattern pattern = (MethodPattern) decodedPattern;
	
		return (this.parameterCount == pattern.parameterCount || this.parameterCount == -1)
			&& matchesName(this.selector, pattern.selector);
	}
	
	/**
	 * @see org.eclipse.wst.jsdt.internal.core.search.matching.InternalSearchPattern#queryIn(org.eclipse.wst.jsdt.internal.core.index.Index)
	 */
	EntryResult[] queryIn(Index index) throws IOException {
		char[] key = this.selector; // can be null
		int matchRule = getMatchRule();
	
		int matchRuleToUse = matchRule;
		switch(getMatchMode()) {
			case R_EXACT_MATCH :
				key = createSearchIndexKey(this.selector, this.parameterCount,
						this.parameterQualifications, this.parameterSimpleNames,
						this.parameterNames, this.returnQualification, this.returnSimpleName,
						this.declaringQualification, this.declaringSimpleName, this.modifiers);
				break;
			case R_PREFIX_MATCH :
				char[] selector = CharOperation.concat(this.selector, ONE_STAR);
				
				key = createSearchIndexKey(selector,
						this.declaringQualification, this.declaringSimpleName,
						this.modifiers);
				
				//the prefix match refers to the selector, but to do the actual match need to use a pattern
				matchRuleToUse = R_PATTERN_MATCH;
				break;
			case R_PATTERN_MATCH :
				key = createSearchIndexKey(this.selector,
						this.declaringQualification, this.declaringSimpleName,
						this.modifiers);
				break;
			case R_REGEXP_MATCH :
				// TODO implement regular expression match
				Logger.log(Logger.WARNING, "Regular expression matching is not yet implimented for MethodPattern");
				break;
		}
	
		return index.query(getIndexCategories(), key, matchRuleToUse); // match rule is irrelevant when the key is null
	}
	
	/**
	 * @see org.eclipse.wst.jsdt.internal.core.search.matching.JavaSearchPattern#print(java.lang.StringBuffer)
	 */
	protected StringBuffer print(StringBuffer output) {
		if (this.findDeclarations) {
			output.append(this.findReferences
				? "MethodCombinedPattern: " //$NON-NLS-1$
				: "MethodDeclarationPattern: "); //$NON-NLS-1$
		} else {
			output.append("MethodReferencePattern: "); //$NON-NLS-1$
		if (key[i] == SEPARATOR) {
			System.arraycopy(key, 0, this.selector = new char[i], 0, i);
			break;
		}
		if (declaringQualification != null)
			output.append(declaringQualification).append('.');
		if (declaringSimpleName != null)
			output.append(declaringSimpleName).append('.');
		else if (declaringQualification != null)
			output.append("*."); //$NON-NLS-1$

		if (selector != null)
			output.append(selector);
		else
			output.append("*"); //$NON-NLS-1$
		output.append('(');
		if (parameterSimpleNames == null) {
			output.append("..."); //$NON-NLS-1$
		} else {
			for (int i = 0, max = parameterSimpleNames.length; i < max; i++) {
				if (i > 0) output.append(", "); //$NON-NLS-1$
				if (parameterQualifications[i] != null) output.append(parameterQualifications[i]).append('.');
				if (parameterSimpleNames[i] == null) output.append('*'); else output.append(parameterSimpleNames[i]);
			}
		}
		output.append(')');
		if (returnQualification != null)
			output.append(" --> ").append(returnQualification).append('.'); //$NON-NLS-1$
		else if (returnSimpleName != null)
			output.append(" --> "); //$NON-NLS-1$
		if (returnSimpleName != null)
			output.append(returnSimpleName);
		else if (returnQualification != null)
			output.append("*"); //$NON-NLS-1$
		return super.print(output);
	}
	
	/**
	 * <p>Create an index key from a selector and a parameter count.</p>
	 * 
	 * <p><b>Note</b> Currently used to index function references, but the
	 * validity of this use is questionable.</p>
	 * 
	 * @param selector
	 * @param parameterCount
	 * 
	 * @return a function index key created from a selector and a parameter count
	 */
	public static char[] createIndexKey(char[] selector, int parameterCount) {
		return createIndexKey(selector, parameterCount, null, null, null, null, 0);
	}
	
	/**
	 * 
	 * TODO: IAN: doc me!
	 * 
	 * <p><b>Key Syntax</b>:
	 * <code>selector/parameterCount/parameterFullTypeNames/paramaterNames/returnFulLTypeName/declaringFullTypeName</code></p>
	 * 
	 * <p>
	 * <b>Examples:</b><ul>
	 * <li><code>myFunction/0////</code> - function with no parameters and no return type</li>
	 * <li><code>myFunction/0///String/</code> - function with no parameters with a return type</li>
	 * <li><code>myFunction/0////foo.bar.Type</code> - function on a type with no parameters and no return type</li>
	 * <li><code>myFunction/0///String/foo.bar.Type</code> - function on a type with no parameters with a return type </li>
	 * <li><code>myFunction/2//param1,param2//</code> - function with no parameter types, with parameter names with no return type</li>
	 * <li><code>myFunction/2//param1,param2/String/</code> - function with no parameter types, with parameter names with a return type</li>
	 * <li><code>myFunction/2//param1,param2//foo.bar.Type</code> - function on a type with no parameter types, with parameter  names with no return type</li>
	 * <li><code>myFunction/2//param1,param2/String/foo.bar.Type</code> - function on a type with no parameter types, with parameter names with a return type</li>
	 * <li><code>myFunction/2/String,Number/param1,param2//</code> - function with parameter types and names with no return type</li>
	 * <li><code>myFunction/2/String,Number/param1,param2/String/</code> - function with parameter types and names with a return type</li>
	 * <li><code>myFunction/2/String,Number/param1,param2//foo.bar.Type</code> - function on a type with parameter types and names with no return type</li>
	 * <li><code>myFunction/2/String,Number/param1,param2/String/foo.bar.Type</code> - function on a type with parameter types and names with a return type</li>
	 * <li><code>myFunction/2/,Number/param1,param2//</code> - function where only one of the parameters has a type</li>
	 * <li><code>myFunction/2/,Number/param1,param2/String/</code> - function where only one of the parameters has a type with a return type</li>
	 * <li><code>myFunction/2/,Number/param1,param2//foo.bar.Type</code> - function on a type where only one of the parameters has a type</li>
	 * <li><code>myFunction/2/,Number/param1,param2/String/foo.bar.Type</code> - function on a type where only one of the parameters has a type with a return type</li>
	 * </ul></p>
	 * 
	 * @param selector
	 * @param parameterCount
	 * @param declaringFullTypeName
	 * @param returnFullTypeName
	 * @param parameterFullTypeNames
	 * @param parameterNames
	 * @param modifiers
	 * 
	 * @return
	 */
	public static char[] createIndexKey(char[] selector, int parameterCount,
			char[][] parameterFullTypeNames,
			char[][] parameterNames,
			char[] declaringFullTypeName,
			char[] returnFullTypeName,
			int modifiers) {
		
		char[] indexKey = null;
		
		if(selector != null  && selector.length > 0) {
			char[] paramaterCountChars = null;
			char[] parameterTypesChars = CharOperation.NO_CHAR;
			char[] parameterNamesChars = CharOperation.NO_CHAR;
			
			
			//get param types
			if (parameterFullTypeNames != null) {
				parameterTypesChars = CharOperation.concatWith(parameterFullTypeNames, PARAMETER_SEPARATOR, false);
			}
			
			//get param names
			if (parameterNames != null) {
				parameterNamesChars = CharOperation.concatWith(parameterNames, PARAMETER_SEPARATOR);
			}
			
			//use pre-made char array for arg counts less then 10, else build a new one
			if(parameterCount >= 0) {
				paramaterCountChars = parameterCount < 10 ?
						COUNTS[parameterCount] : (SEPARATOR + String.valueOf(parameterCount)).toCharArray();
			} else {
				paramaterCountChars = CharOperation.concat(new char[] {SEPARATOR}, ONE_STAR);
			}
			
				
			//get lengths
			int parameterTypesLength = (parameterTypesChars == null ? 0 : parameterTypesChars.length);
			int parameterNamesLength = (parameterNamesChars == null ? 0 : parameterNamesChars.length);
			int returnTypeLength = (returnFullTypeName == null ? 0 : returnFullTypeName.length);
			int delaringTypeLength = declaringFullTypeName == null ? 0 : declaringFullTypeName.length;
			
			int resultLength = selector.length + paramaterCountChars.length
					+ 1 + parameterTypesLength
					+ 1 + parameterNamesLength
					+ 1 + returnTypeLength
					+ 1 + delaringTypeLength
					+ 3; //modifiers
			
			//create result char array
			indexKey = new char[resultLength];
			
			//add type name to result
			int pos = 0;
			System.arraycopy(selector, 0, indexKey, pos, selector.length);
			pos += selector.length;
			
			//add param count to result
			if (paramaterCountChars.length > 0) {
				System.arraycopy(paramaterCountChars, 0, indexKey, pos, paramaterCountChars.length);
				pos += paramaterCountChars.length;
			}
			
			//add param types
			indexKey[pos++] = SEPARATOR;
			if (parameterTypesLength > 0) {
				System.arraycopy(parameterTypesChars, 0, indexKey, pos, parameterTypesLength);
				pos += parameterTypesLength;
			}
			
			//add param names
			indexKey[pos++] = SEPARATOR;
			if (parameterNamesLength > 0) {
				System.arraycopy(parameterNamesChars, 0, indexKey, pos, parameterNamesLength);
				pos += parameterNamesLength;
			}
			
			//add return type
			indexKey[pos++] = SEPARATOR;
			if(returnTypeLength > 0) {
				System.arraycopy(returnFullTypeName, 0, indexKey, pos, returnTypeLength);
				pos += returnTypeLength;
			}
			
			//add declaring type
			indexKey[pos++] = SEPARATOR;
			if(delaringTypeLength > 0) {
				System.arraycopy(declaringFullTypeName, 0, indexKey, pos, delaringTypeLength);
				pos += delaringTypeLength;
			}
			
			//add modifiers
			indexKey[pos++] = SEPARATOR;
			indexKey[pos++] = (char) modifiers;
			indexKey[pos++] = (char) (modifiers>>16);
		}
			
		return indexKey;
	}
	
	/**
	 * <p>Create an index key for search the index for any function that matches the given selector
	 * pattern, on the optionally defined declaring type, with the given modifiers.</p>
	 * 
	 * @param selectorPattern
	 * @param declarationType
	 * @param modifiers
	 * 
	 * @return
	 */
	private static char[] createSearchIndexKey(char[] selectorPattern,
			char[] declaringQualification, char[] declaringSimpleName, int modifiers) {
		
		char[] declaringFullTypeName = null;
		if(declaringSimpleName != null) {
			declaringFullTypeName = TypeQulificationHelpers.createFullyQualifedTypeName(declaringQualification, declaringSimpleName);

	if (selector != null)
		output.append(selector);
	else
		output.append("*"); //$NON-NLS-1$
	output.append('(');
	if (parameterSimpleNames == null) {
		output.append("..."); //$NON-NLS-1$
	} else {
		for (int i = 0, max = parameterSimpleNames.length; i < max; i++) {
			if (i > 0) output.append(", "); //$NON-NLS-1$
			if (parameterQualifications[i] != null) output.append(parameterQualifications[i]).append('.');
			if (parameterSimpleNames[i] == null) output.append('*'); else output.append(parameterSimpleNames[i]);
		}
		
		return createIndexKey(selectorPattern, -1,
				ONE_STAR_CHAR,
				ONE_STAR_CHAR,
				declaringFullTypeName,
				ONE_STAR,
				modifiers);
	}
	
	/**
	 * <p>Used to create an index key to search for a specific function.</p>
	 * 
	 * @param selector
	 * @param parameterCount
	 * @param parameterQualifications
	 * @param parameterSimpleNames
	 * @param parameterNames
	 * @param returnQualification
	 * @param returnSimpleName
	 * @param declaringQualification
	 * @param declaringSimpleName
	 * @param modifiers
	 * @return
	 */
	private static char[] createSearchIndexKey(char[] selector, int parameterCount,
			char[][] parameterQualifications,
			char[][] parameterSimpleNames,
			char[][] parameterNames,
			char[] returnQualification,
			char[] returnSimpleName,
			char[] declaringQualification,
			char[] declaringSimpleName,
			int modifiers) {
		
		//create fully qualified type names
		char[] declaringFullTypeName = TypeQulificationHelpers.createFullyQualifedTypeName(declaringQualification, declaringSimpleName);
		char[] returnFullTypeName = TypeQulificationHelpers.createFullyQualifedTypeName(returnQualification, returnSimpleName);
		char[][] parameterFullTypeNames = TypeQulificationHelpers.createFullyQualifedTypeName(parameterQualifications, parameterSimpleNames);
		
		return createIndexKey(selector, parameterCount, parameterFullTypeNames,
				parameterNames, declaringFullTypeName, returnFullTypeName, modifiers);
	}
	output.append(')');
	if (returnQualification != null)
		output.append(" --> ").append(returnQualification).append('.'); //$NON-NLS-1$
	else if (returnSimpleName != null)
		output.append(" --> "); //$NON-NLS-1$
	if (returnSimpleName != null)
		output.append(returnSimpleName);
	else if (returnQualification != null)
		output.append("*"); //$NON-NLS-1$
	return super.print(output);
}
}




/*******************************************************************************
 * Copyright (c) 2011 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.internal.core.util;

import org.eclipse.wst.jsdt.core.compiler.CharOperation;
import org.eclipse.wst.jsdt.internal.core.search.indexing.IIndexConstants;

/**
 * <p>Methods for helping with qualified type names, both to separate them into
 * qualifier and simple name, as well as recombining qualifier with simple name.</p>
 */
public class TypeQulificationHelpers {
	
	/**
	 * TODO: IAN: doc me
	 * 
	 * @see #seperateFullyQualifedTypeNames(char[])
	 */
	public static final int QULIFIERS_INDEX = 0;
	
	/**
	 * TODO: IAN: doc me
	 * 
	 * @see #seperateFullyQualifedTypeNames(char[])
	 */
	public static final int SIMPLE_NAMES_INDEX = 1;
	
	/**
	 * 
	 * TODO: IAN: doc me!
	 * 
	 * @param typeQualification
	 * @param typeSimpleName
	 * @return
	 */
	public static char[] createFullyQualifedTypeName(char[] typeQualification, char[] typeSimpleName) {
		char[] fullTypeName = null;
		if(typeSimpleName != null && typeSimpleName.length > 0) {
			if(typeQualification != null && typeQualification.length > 0) {
				fullTypeName = CharOperation.concat(typeQualification, typeSimpleName, IIndexConstants.DOT);
			} else {
				fullTypeName = typeSimpleName;
			}
		}
		
		return fullTypeName;
	}
	
	/**
	 * 
	 * TODO: IAN: doc me!
	 * 
	 * @param typeQualifications
	 * @param typeSimpleNames
	 * @return
	 */
	public static char[][] createFullyQualifedTypeName(char[][] typeQualifications, char[][] typeSimpleNames) {
		char[][] fullTypeNames = null;
		
		if(typeSimpleNames != null) {
			fullTypeNames = new char[typeSimpleNames.length][];
			for(int i = 0; i < fullTypeNames.length; ++i) {
				if(typeQualifications != null && typeQualifications.length > i) {
					fullTypeNames[i] = createFullyQualifedTypeName(typeQualifications[i], typeSimpleNames[i]);
				} else {
					fullTypeNames[i] = typeSimpleNames[i];
				}
			}
		}
		
		return fullTypeNames;
	}
	
	/**
	 * 
	 * TODO: IAN: doc me!
	 * 
	 * @param fullyQualifiedTypeName
	 * @return
	 */
	public static char[][] seperateFullyQualifedName(char[] fullyQualifiedTypeName) {
		char[][] seperatedTypeName = new char[2][];
		
		if(fullyQualifiedTypeName != null && fullyQualifiedTypeName.length > 0) {
			int lastIndexOfDot = CharOperation.lastIndexOf(IIndexConstants.DOT, fullyQualifiedTypeName);
			if(lastIndexOfDot != -1) {
				seperatedTypeName[QULIFIERS_INDEX] = CharOperation.subarray(fullyQualifiedTypeName, 0, lastIndexOfDot);
				seperatedTypeName[SIMPLE_NAMES_INDEX] = CharOperation.subarray(fullyQualifiedTypeName, lastIndexOfDot+1, -1);
			} else {
				seperatedTypeName[QULIFIERS_INDEX] = null;
				seperatedTypeName[SIMPLE_NAMES_INDEX] = fullyQualifiedTypeName;
			}
		}
		
		return seperatedTypeName;
	}
	
	/**
	 * 
	 * TODO: IAN: doc me!
	 * 
	 * @param fullyQualifiedTypeNames
	 * @return
	 * 
	 * @see #QULIFIERS_INDEX
	 * @see #SIMPLE_NAMES_INDEX
	 */
	public static char[][][] seperateFullyQualifedNames(char[] fullyQualifiedTypeNames, int minLength) {
		/* 
		 * First index is 0 or 1 for the list of qualifiers qualifier and then the list of simple names respectively
		 * Second index is a list of the qualifiers and simple names
		 * Third index is the actual 'string' qualifier or simple name
		 */
		char[][][] seperatedTypeNames = new char[2][][];
		
		char[][] types = CharOperation.splitOn(IIndexConstants.PARAMETER_SEPARATOR, fullyQualifiedTypeNames);
		if(types.length > 0) {
			int length = minLength > types.length ? minLength :types.length;
			seperatedTypeNames[QULIFIERS_INDEX] = new char[length][];
			seperatedTypeNames[SIMPLE_NAMES_INDEX] = new char[length][];
			
			for(int i = 0; i < types.length; ++i) {
				char[][] seperatedTypeName = seperateFullyQualifedName(types[i]);
				seperatedTypeNames[QULIFIERS_INDEX][i] = seperatedTypeName[QULIFIERS_INDEX];
				seperatedTypeNames[SIMPLE_NAMES_INDEX][i] = seperatedTypeName[SIMPLE_NAMES_INDEX];
			}
			
		} else if (minLength > 0) {
			seperatedTypeNames[QULIFIERS_INDEX] = new char[minLength][];
			seperatedTypeNames[SIMPLE_NAMES_INDEX] = new char[minLength][];
		} else {
			seperatedTypeNames[QULIFIERS_INDEX] = null;
			seperatedTypeNames[SIMPLE_NAMES_INDEX] = null;
		}
		
		return seperatedTypeNames;
	}
}




import org.eclipse.wst.jsdt.core.tests.compiler.regression.UtilTest;
import org.eclipse.wst.jsdt.core.tests.compiler.util.ExclusionTests;
import org.eclipse.wst.jsdt.core.tests.interpret.BasicInterpretTest;
import org.eclipse.wst.jsdt.core.tests.search.SearchTests;

/**
 * Run all compiler regression tests

	// interpret tests
	standardTests.add(BasicInterpretTest.class);
	
	
	
	
//	standardTests.addAll(JavadocTest.allTestClasses);

//	standardTests.add(BasicErrorTests.class);

	//	// add all javadoc tests
//	for (int i=0, l=JavadocTest.ALL_CLASSES.size(); i<l; i++) {
//		standardTests.add(JavadocTest.ALL_CLASSES.get(i));
//	}
//
	TestSuite all = new TestSuite("JSDT 'Compiler' Tests");
	all.addTest(ExclusionTests.suite());
	
	
//	int possibleComplianceLevels = AbstractCompilerTest.getPossibleComplianceLevels();
//	if ((possibleComplianceLevels & AbstractCompilerTest.F_1_3) != 0) {
//		ArrayList tests_1_3 = (ArrayList)standardTests.clone();
//		tests_1_3.add(Compliance_1_3.class);
//		tests_1_3.add(JavadocTest_1_3.class);
//		// Reset forgotten subsets tests
//		TestCase.TESTS_PREFIX = null;
//		TestCase.TESTS_NAMES = null;
//		TestCase.TESTS_NUMBERS= null;
//		TestCase.TESTS_RANGE = null;
//		TestCase.RUN_ONLY_ID = null;
//		all.addTest(AbstractCompilerTest.buildComplianceTestSuite(AbstractCompilerTest.COMPLIANCE_1_3, tests_1_3));
//	}
//	if ((possibleComplianceLevels & AbstractCompilerTest.F_1_4) != 0) {
//		ArrayList tests_1_4 = (ArrayList)standardTests.clone();
//		tests_1_4.add(AssertionTest.class);
//		tests_1_4.add(Compliance_1_4.class);
//		tests_1_4.add(ClassFileReaderTest_1_4.class);
//		tests_1_4.add(JavadocTest_1_4.class);
//		// Reset forgotten subsets tests
//		TestCase.TESTS_PREFIX = null;
//		TestCase.TESTS_NAMES = null;
//		TestCase.TESTS_NUMBERS= null;
//		TestCase.TESTS_RANGE = null;
//		TestCase.RUN_ONLY_ID = null;
//		all.addTest(AbstractCompilerTest.buildComplianceTestSuite(AbstractCompilerTest.COMPLIANCE_1_4, tests_1_4));
//	}
//	if ((possibleComplianceLevels & AbstractCompilerTest.F_1_5) != 0) {
//		ArrayList tests_1_5 = (ArrayList)standardTests.clone();
//		tests_1_5.addAll(RunComparableTests.ALL_CLASSES);
//		tests_1_5.add(AssertionTest.class);
//		tests_1_5.add(ClassFileReaderTest_1_5.class);
//		tests_1_5.add(GenericTypeSignatureTest.class);
//		tests_1_5.add(InternalHexFloatTest.class);
//		tests_1_5.add(JavadocTest_1_5.class);
//		tests_1_5.add(BatchCompilerTest.class);
//		tests_1_5.add(ExternalizeStringLiterals15Test.class);
//		// Reset forgotten subsets tests
//		TestCase.TESTS_PREFIX = null;
//		TestCase.TESTS_NAMES = null;
//		TestCase.TESTS_NUMBERS= null;
//		TestCase.TESTS_RANGE = null;
//		TestCase.RUN_ONLY_ID = null;
//		all.addTest(AbstractCompilerTest.buildComplianceTestSuite(AbstractCompilerTest.COMPLIANCE_1_5, tests_1_5));
//	}
//	if ((possibleComplianceLevels & AbstractCompilerTest.F_1_6) != 0) {
//		ArrayList tests_1_6 = (ArrayList)standardTests.clone();
//		tests_1_6.addAll(RunComparableTests.ALL_CLASSES);
//		tests_1_6.add(AssertionTest.class);
//		tests_1_6.add(ClassFileReaderTest_1_5.class);
//		tests_1_6.add(GenericTypeSignatureTest.class);
//		tests_1_6.add(InternalHexFloatTest.class);
//		tests_1_6.add(JavadocTest_1_5.class);
//		tests_1_6.add(BatchCompilerTest.class);
//		tests_1_6.add(ExternalizeStringLiterals15Test.class);
//		tests_1_6.add(StackMapAttributeTest.class);
//		// Reset forgotten subsets tests
//		TestCase.TESTS_PREFIX = null;
//		TestCase.TESTS_NAMES = null;
//		TestCase.TESTS_NUMBERS= null;
//		TestCase.TESTS_RANGE = null;
//		TestCase.RUN_ONLY_ID = null;
//		all.addTest(AbstractCompilerTest.buildComplianceTestSuite(AbstractCompilerTest.COMPLIANCE_1_6, tests_1_6));
//	}
	for (Iterator iter = standardTests.iterator(); iter.hasNext();) {
		Class test = (Class) iter.next();
		all.addTestSuite(test); 
	}
	
	all.addTest(SearchTests.suite());
	return all;
} 
}




/*******************************************************************************
 * Copyright (c) 2011 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.search;

import junit.framework.Test;
import junit.framework.TestSuite;

/**
 * <p>Test suite for all JSDT Search Tests.<p>
 */
public class SearchTests extends TestSuite {
	/**
	 * <p>Default constructor</p>
	 */
	public SearchTests() {
		this("JavaScript Search Tests");
	}

	/**
	 * <p>Constructor with specified test name.</p>
	 *
	 * @param testName of this test suite
	 */
	public SearchTests(String testName) {
		super(testName);
	}
	
	public static Test suite() {
		TestSuite all = new TestSuite("JavaScript Search Tests");
		
		all.addTestSuite(TestMethodPattern.class);
		
		return all;
	}
}




/**
 * 
 */
package org.eclipse.wst.jsdt.core.tests.search;

import org.eclipse.wst.jsdt.core.compiler.CharOperation;
import org.eclipse.wst.jsdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.wst.jsdt.internal.core.search.indexing.IIndexConstants;
import org.eclipse.wst.jsdt.internal.core.search.matching.MethodPattern;

import junit.framework.TestCase;

/**
 * <p>Tests for MethodPattern.</p>
 * 
 * @see MethodPattern
 */
public class TestMethodPattern extends TestCase {
	
	public void testCreateIndexKey_0() {
		runCreateIndexKeyTest("myFunction/0/////", "myFunction".toCharArray(), 0, null, null, null, null, 0);
	}
	
	public void testCreateIndexKey_1() {
		runCreateIndexKeyTest("myFunction/1/////", "myFunction".toCharArray(), 1, null, null, null, null, 0);
	}
	
	public void testCreateIndexKey_2() {
		runCreateIndexKeyTest("myFunction/0///String//",
				"myFunction".toCharArray(), 0, null, null, null, "String".toCharArray(), 0);
	}
	
	public void testCreateIndexKey_3() {
		runCreateIndexKeyTest("myFunction/0////foo.bar.Type/",
				"myFunction".toCharArray(), 0, null, null, "foo.bar.Type".toCharArray(), null, ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_4() {
		runCreateIndexKeyTest("myFunction/0///String/foo.bar.Type/",
				"myFunction".toCharArray(), 0, null, null, "foo.bar.Type".toCharArray(), "String".toCharArray(), ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_5() {
		runCreateIndexKeyTest("myFunction/2//param1,param2///",
				"myFunction".toCharArray(), 2, null, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, null, 0);
	}
	
	public void testCreateIndexKey_6() {
		runCreateIndexKeyTest("myFunction/2//param1,param2/String//",
				"myFunction".toCharArray(), 2, null, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, "String".toCharArray(), 0);
	}
	
	public void testCreateIndexKey_7() {
		runCreateIndexKeyTest("myFunction/2//param1,param2//foo.bar.Type/",
				"myFunction".toCharArray(), 2, null, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), null, ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_8() {
		runCreateIndexKeyTest("myFunction/2//param1,param2/String/foo.bar.Type/",
				"myFunction".toCharArray(), 2, null, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), "String".toCharArray(), ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_9() {
		runCreateIndexKeyTest("myFunction/2/String,Number/param1,param2///",
				"myFunction".toCharArray(), 2, new char[][] { "String".toCharArray(), "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, null, 0);
	}
	
	public void testCreateIndexKey_10() {
		runCreateIndexKeyTest("myFunction/2/String,Number/param1,param2/String//",
				"myFunction".toCharArray(), 2, new char[][] { "String".toCharArray(), "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, "String".toCharArray(), 0);
	}
	
	public void testCreateIndexKey_11() {
		runCreateIndexKeyTest("myFunction/2/String,Number/param1,param2//foo.bar.Type/",
				"myFunction".toCharArray(), 2, new char[][] { "String".toCharArray(), "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), null, ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_12() {
		runCreateIndexKeyTest("myFunction/2/String,Number/param1,param2/String/foo.bar.Type/",
				"myFunction".toCharArray(), 2, new char[][] { "String".toCharArray(), "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), "String".toCharArray(), ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_13() {
		runCreateIndexKeyTest("myFunction/2/,Number/param1,param2///",
				"myFunction".toCharArray(), 2, new char[][] { null, "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, null, 0);
	}
	
	public void testCreateIndexKey_14() {
		runCreateIndexKeyTest("myFunction/2/,Number/param1,param2/String//",
				"myFunction".toCharArray(), 2, new char[][] { null, "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, "String".toCharArray(), 0);
	}
	
	public void testCreateIndexKey_15() {
		runCreateIndexKeyTest("myFunction/2/,Number/param1,param2//foo.bar.Type/",
				"myFunction".toCharArray(), 2, new char[][] { null, "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), null, ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_16() {
		runCreateIndexKeyTest("myFunction/2/,Number/param1,param2/String/foo.bar.Type/",
				"myFunction".toCharArray(), 2, new char[][] { null, "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), "String".toCharArray(), ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_17() {
		runCreateIndexKeyTest("myFunction/2/,Number/param1,param2///",
				"myFunction".toCharArray(), 2, new char[][] { new char[0], "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, null, 0);
	}
	
	public void testCreateIndexKey_18() {
		runCreateIndexKeyTest("myFunction/2/,Number/param1,param2/String//",
				"myFunction".toCharArray(), 2, new char[][] { new char[0], "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, "String".toCharArray(), 0);
	}
	
	public void testCreateIndexKey_19() {
		runCreateIndexKeyTest("myFunction/2/,Number/param1,param2//foo.bar.Type/",
				"myFunction".toCharArray(), 2, new char[][] { new char[0], "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), null, ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_20() {
		runCreateIndexKeyTest("myFunction/2/,Number/param1,param2/String/foo.bar.Type/",
				"myFunction".toCharArray(), 2, new char[][] { new char[0], "Number".toCharArray()}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), "String".toCharArray(), ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_21() {
		runCreateIndexKeyTest("myFunction/2/String,/param1,param2///",
				"myFunction".toCharArray(), 2, new char[][] {"String".toCharArray(), null}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, null, 0);
	}
	
	public void testCreateIndexKey_22() {
		runCreateIndexKeyTest("myFunction/2/String,/param1,param2/String//",
				"myFunction".toCharArray(), 2, new char[][] {"String".toCharArray(), null}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, "String".toCharArray(), 0);
	}
	
	public void testCreateIndexKey_23() {
		runCreateIndexKeyTest("myFunction/2/String,/param1,param2//foo.bar.Type/",
				"myFunction".toCharArray(), 2, new char[][] {"String".toCharArray(), null}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), null, ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_24() {
		runCreateIndexKeyTest("myFunction/2/String,/param1,param2/String/foo.bar.Type/",
				"myFunction".toCharArray(), 2, new char[][] {"String".toCharArray(), null}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), "String".toCharArray(), ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_25() {
		runCreateIndexKeyTest("myFunction/2/String,/param1,param2///",
				"myFunction".toCharArray(), 2, new char[][] {"String".toCharArray(), new char[0]}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, null, 0);
	}
	
	public void testCreateIndexKey_26() {
		runCreateIndexKeyTest("myFunction/2/String,/param1,param2/String//",
				"myFunction".toCharArray(), 2, new char[][] {"String".toCharArray(), new char[0]}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, null, "String".toCharArray(), 0);
	}
	
	public void testCreateIndexKey_27() {
		runCreateIndexKeyTest("myFunction/2/String,/param1,param2//foo.bar.Type/",
				"myFunction".toCharArray(), 2, new char[][] {"String".toCharArray(), new char[0]}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), null, ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_28() {
		runCreateIndexKeyTest("myFunction/2/String,/param1,param2/String/foo.bar.Type/", "myFunction".toCharArray(), 2, new char[][] {"String".toCharArray(), new char[0]}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), "String".toCharArray(), ClassFileConstants.AccStatic);
	}
	
	public void testCreateIndexKey_29() {
		char[] keyChars = MethodPattern.createIndexKey("".toCharArray(), 2, new char[][] {"String".toCharArray(), new char[0]}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), "String".toCharArray(), ClassFileConstants.AccStatic);
		
		String key = null;
		if(keyChars != null) {
			key = new String(keyChars);
		}
		
		assertNull("If selector is empty the key should be null.\nWAS:\n" + key, key);
	}
	
	public void testCreateIndexKey_30() {
		char[] keyChars = MethodPattern.createIndexKey(null, 2, new char[][] {"String".toCharArray(), new char[0]}, new char[][] { "param1".toCharArray(), "param2".toCharArray()}, "foo.bar.Type".toCharArray(), "String".toCharArray(), ClassFileConstants.AccStatic);
		
		String key = null;
		if(keyChars != null) {
			key = new String(keyChars);
		}
		
		assertNull("If selector is empty the key should be null.\nWAS:\n" + key, key);
	}
	
	public void testDecodeIndexKey_0() {
		runDecodeIndexKeyTest("myFunction/0////", "myFunction", 0, null, null, null,null, null, null, null, 0);
	}
	
	public void testDecodeIndexKey_2() {
		runDecodeIndexKeyTest("myFunction/0///String/", "myFunction", 0, null, null, null,null, "String", null, null, 0);
	}
	
	public void testDecodeIndexKey_3() {
		runDecodeIndexKeyTest("myFunction/0////foo.bar.Type", "myFunction", 0, null, null, null,null, null, "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_4() {
		runDecodeIndexKeyTest("myFunction/0///String/foo.bar.Type", "myFunction", 0, null, null, null,null, "String", "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_5() {
		runDecodeIndexKeyTest("myFunction/2//param1,param2//", "myFunction", 2, new String[2], new String[2], new String[] {"param1", "param2"},null, null, null, null, 0);
	}
	
	public void testDecodeIndexKey_6() {
		runDecodeIndexKeyTest("myFunction/2//param1,param2/String/", "myFunction", 2, new String[2], new String[2], new String[] {"param1", "param2"},null, "String", null, null, 0);
	}
	
	public void testDecodeIndexKey_7() {
		runDecodeIndexKeyTest("myFunction/2//param1,param2//foo.bar.Type", "myFunction", 2, new String[2], new String[2], new String[] {"param1", "param2"},null, null, "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_8() {
		runDecodeIndexKeyTest("myFunction/2//param1,param2/String/foo.bar.Type", "myFunction", 2, new String[2], new String[2], new String[] {"param1", "param2"},null, "String", "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_9() {
		runDecodeIndexKeyTest("myFunction/2/String,Number/param1,param2//", "myFunction", 2, new String[]{null, null}, new String[]{"String", "Number"}, new String[] {"param1", "param2"},null, null, null, null, 0);
	}
	
	public void testDecodeIndexKey_10() {
		runDecodeIndexKeyTest("myFunction/2/String,Number/param1,param2/String/", "myFunction", 2, new String[]{null, null}, new String[]{"String", "Number"}, new String[] {"param1", "param2"},null, "String", null, null, 0);
	}
	
	public void testDecodeIndexKey_11() {
		runDecodeIndexKeyTest("myFunction/2/String,Number/param1,param2//foo.bar.Type", "myFunction", 2, new String[]{null, null}, new String[]{"String", "Number"}, new String[] {"param1", "param2"},null, null, "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_12() {
		runDecodeIndexKeyTest("myFunction/2/String,Number/param1,param2/String/foo.bar.Type", "myFunction", 2, new String[]{null, null}, new String[]{"String", "Number"}, new String[] {"param1", "param2"},null, "String", "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_13() {
		runDecodeIndexKeyTest("myFunction/2/,Number/param1,param2//", "myFunction", 2, new String[]{null, null}, new String[]{null, "Number"}, new String[] {"param1", "param2"},null, null, null, null, 0);
	}
	
	public void testDecodeIndexKey_14() {
		runDecodeIndexKeyTest("myFunction/2/,Number/param1,param2/String/", "myFunction", 2, new String[]{null, null}, new String[]{null, "Number"}, new String[] {"param1", "param2"},null, "String", null, null, 0);
	}
	
	public void testDecodeIndexKey_15() {
		runDecodeIndexKeyTest("myFunction/2/,Number/param1,param2//foo.bar.Type", "myFunction", 2, new String[]{null, null}, new String[]{null, "Number"}, new String[] {"param1", "param2"},null, null, "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_16() {
		runDecodeIndexKeyTest("myFunction/2/,Number/param1,param2/String/foo.bar.Type", "myFunction", 2, new String[]{null, null}, new String[]{null, "Number"}, new String[] {"param1", "param2"},null, "String", "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_17() {
		runDecodeIndexKeyTest("myFunction/2/String,/param1,param2//", "myFunction", 2, new String[]{null, null}, new String[]{"String", null}, new String[] {"param1", "param2"},null, null, null, null, 0);
	}
	
	public void testDecodeIndexKey_18() {
		runDecodeIndexKeyTest("myFunction/2/String,/param1,param2/String/", "myFunction", 2, new String[]{null, null}, new String[]{"String", null}, new String[] {"param1", "param2"},null, "String", null, null, 0);
	}
	
	public void testDecodeIndexKey_19() {
		runDecodeIndexKeyTest("myFunction/2/String,/param1,param2//foo.bar.Type", "myFunction", 2, new String[]{null, null}, new String[]{"String", null}, new String[] {"param1", "param2"},null, null, "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_20() {
		runDecodeIndexKeyTest("myFunction/2/String,/param1,param2/String/foo.bar.Type", "myFunction", 2, new String[]{null, null}, new String[]{"String", null}, new String[] {"param1", "param2"},null, "String", "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_21() {
		runDecodeIndexKeyTest("myFunction/2/bar.foo.String,neto.crazy.Number/param1,param2//", "myFunction", 2, new String[]{"bar.foo", "neto.crazy"}, new String[]{"String", "Number"}, new String[] {"param1", "param2"},null, null, null, null, 0);
	}
	
	public void testDecodeIndexKey_22() {
		runDecodeIndexKeyTest("myFunction/2/bar.foo.String,neto.crazy.Number/param1,param2/String/", "myFunction", 2, new String[]{"bar.foo", "neto.crazy"}, new String[]{"String", "Number"}, new String[] {"param1", "param2"},null, "String", null, null, 0);
	}
	
	public void testDecodeIndexKey_23() {
		runDecodeIndexKeyTest("myFunction/2/bar.foo.String,neto.crazy.Number/param1,param2//foo.bar.Type", "myFunction", 2, new String[]{"bar.foo", "neto.crazy"}, new String[]{"String", "Number"}, new String[] {"param1", "param2"},null, null, "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_24() {
		runDecodeIndexKeyTest("myFunction/2/bar.foo.String,neto.crazy.Number/param1,param2/String/foo.bar.Type", "myFunction", 2, new String[]{"bar.foo", "neto.crazy"}, new String[]{"String", "Number"}, new String[] {"param1", "param2"},null, "String", "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_25() {
		runDecodeIndexKeyTest("myFunction/2/,neto.crazy.Number/param1,param2//", "myFunction", 2, new String[]{null, "neto.crazy"}, new String[]{null, "Number"}, new String[] {"param1", "param2"},null, null, null, null, 0);
	}
	
	public void testDecodeIndexKey_26() {
		runDecodeIndexKeyTest("myFunction/2/,neto.crazy.Number/param1,param2/String/", "myFunction", 2, new String[]{null, "neto.crazy"}, new String[]{null, "Number"}, new String[] {"param1", "param2"},null, "String", null, null, 0);
	}
	
	public void testDecodeIndexKey_27() {
		runDecodeIndexKeyTest("myFunction/2/,neto.crazy.Number/param1,param2//foo.bar.Type", "myFunction", 2, new String[]{null, "neto.crazy"}, new String[]{null, "Number"}, new String[] {"param1", "param2"},null, null, "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_28() {
		runDecodeIndexKeyTest("myFunction/2/,neto.crazy.Number/param1,param2/String/foo.bar.Type", "myFunction", 2, new String[]{null, "neto.crazy"}, new String[]{null, "Number"}, new String[] {"param1", "param2"},null, "String", "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_29() {
		runDecodeIndexKeyTest("myFunction/2/bar.foo.String,/param1,param2//", "myFunction", 2, new String[]{"bar.foo", null}, new String[]{"String", null}, new String[] {"param1", "param2"},null, null, null, null, 0);
	}
	
	public void testDecodeIndexKey_30() {
		runDecodeIndexKeyTest("myFunction/2/bar.foo.String,/param1,param2/String/", "myFunction", 2, new String[]{"bar.foo", null}, new String[]{"String", null}, new String[] {"param1", "param2"},null, "String", null, null, 0);
	}
	
	public void testDecodeIndexKey_31() {
		runDecodeIndexKeyTest("myFunction/2/bar.foo.String,/param1,param2//foo.bar.Type", "myFunction", 2, new String[]{"bar.foo", null}, new String[]{"String", null}, new String[] {"param1", "param2"},null, null, "foo.bar", "Type", 0);
	}
	
	public void testDecodeIndexKey_32() {
		runDecodeIndexKeyTest("myFunction/2/bar.foo.String,/param1,param2/String/foo.bar.Type", "myFunction", 2, new String[]{"bar.foo", null}, new String[]{"String", null}, new String[] {"param1", "param2"},null, "String", "foo.bar", "Type", 0);
	}
	
	/**
	 * <p>Runs the asserts for a single create index key test.</p>
	 * 
	 * @param expected
	 * @param selector
	 * @param parameterCount
	 * @param parameterFullTypeNames
	 * @param parameterNames
	 * @param declaringFullTypeName
	 * @param returnFullTypeName
	 * @param modifiers
	 */
	private static void runCreateIndexKeyTest(String expected,
			char[] selector,
			int parameterCount,
			char[][] parameterFullTypeNames,
			char[][] parameterNames,
			char[] declaringFullTypeName,
			char[] returnFullTypeName,
			int modifiers) {
		
		char[] indexKey = MethodPattern.createIndexKey(selector, parameterCount, parameterFullTypeNames, parameterNames, declaringFullTypeName, returnFullTypeName, modifiers);
		
		String expectedWithModifiers = expected + (char) modifiers + (char) (modifiers>>16);
		
		assertNotNull("The created index key should not be null.\nEXPECTED:\n" + expectedWithModifiers, indexKey);
		
		assertTrue("The expected index key does not match the generated index key.\nWAS:\n" + new String(indexKey) + "\nEXPECTED:\n" + expected,
				CharOperation.equals(indexKey, expectedWithModifiers.toCharArray()));
	}
	
	/**
	 * <p>Runs a single decode index key test</p>
	 * 
	 * @param key
	 * @param selector
	 * @param parameterCount
	 * @param parameterQualifications
	 * @param parameterSimpleNames
	 * @param parameterNames
	 * @param returnQualification
	 * @param returnSimpleName
	 * @param declaringQualification
	 * @param declaringSimpleName
	 * @param modifiers
	 */
	private static void runDecodeIndexKeyTest(String key,
			String selector,
			int parameterCount,
			String[] parameterQualifications,
			String[] parameterSimpleNames,
			String[] parameterNames,
			String returnQualification,
			String returnSimpleName,
			String declaringQualification,
			String declaringSimpleName,
			int modifiers) {
		
		char[] keyWithModifiers = new char[key.length() + 3];
		System.arraycopy(key.toCharArray(), 0, keyWithModifiers, 0, key.length());
		keyWithModifiers[keyWithModifiers.length-3] = '/';
		keyWithModifiers[keyWithModifiers.length-2] = (char) modifiers;
		keyWithModifiers[keyWithModifiers.length-1] = (char) (modifiers>>16);
		
		MethodPattern pattern = new MethodPattern(false, false, false, null, 0);
		pattern = (MethodPattern)pattern.getBlankPattern();
		pattern.decodeIndexKey(keyWithModifiers);
		
		assertEquals("Expected selector does not equal decoded selector.", selector, pattern.selector);
		assertEquals("Expected parameter count does not equal decoded parameter count.", parameterCount, pattern.parameterCount);
		assertEquals("Expected parameter qualifications does not equal decoded parameter qualifications.", parameterQualifications, pattern.parameterQualifications);
		assertEquals("Expected parameter simple names does not equal decoded parameter simple names.", parameterSimpleNames, pattern.parameterSimpleNames);
		assertEquals("Expected parameter names does not equal decoded parameter names.", parameterNames, pattern.parameterNames);
		assertEquals("Expected return qualification does not equal decoded return wualification.", returnQualification, pattern.returnQualification);
		assertEquals("Expected return simple name does not equal decoded return simple name.", returnSimpleName, pattern.returnSimpleName);
		assertEquals("Expected declaring qualification does not equal decoded declaring qualification.", declaringQualification, pattern.declaringQualification);
		assertEquals("Expected declaring simple name does not equal decoded declaring simple name.", declaringSimpleName, pattern.declaringSimpleName);
	}
	
	private static void assertEquals(String message, String expected, char[] chars) {
		String actual = null;
		if(chars != null) {
			actual = new String(chars);
		}
		
		assertEquals(message, expected, actual);
	}
	
	private static void assertEquals(String message, String[] expected, char[][] actual) {
		
		String expectedColappsed = null;
		String actualColappsed = null;
		if(actual != null) {
			char[] actualColappsedChars = CharOperation.concatWith(actual, IIndexConstants.PARAMETER_SEPARATOR, false);
			if(actualColappsedChars != null) {
				actualColappsed = new String(actualColappsedChars);
			}
		}
		
		if(expected != null) {
			expectedColappsed = "";
			for(int i = 0; i < expected.length; ++i) {
				if(i > 0) {
					expectedColappsed += ",";
				}
				
				if(expected[i] != null) {
					expectedColappsed += expected[i];
				}
			}
		}
		
		assertEquals(message, expectedColappsed, actualColappsed);
	}
}

Lines 1-4 Link Here

(-).settings/org.eclipse.core.resources.prefs (-1 / +2 lines)
1	#Mon Jan 28 15:47:49 CST 2008	1	#Thu Jul 14 08:12:53 EDT 2011
2	eclipse.preferences.version=1	2	eclipse.preferences.version=1
		3	encoding//src/org/eclipse/wst/jsdt/core/tests/model/JSDTModelTests.java=US-ASCII
3	encoding/<project>=ISO-8859-1	4	encoding/<project>=ISO-8859-1
4	instance/org.eclipse.core.net/org.eclipse.core.net.hasMigrated=true	5	instance/org.eclipse.core.net/org.eclipse.core.net.hasMigrated=true




/*******************************************************************************
 * Copyright (c) 2000, 2011 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.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;

import junit.framework.ComparisonFailure;
import junit.framework.Test;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.wst.jsdt.core.IAccessRule;
import org.eclipse.wst.jsdt.core.IIncludePathAttribute;
import org.eclipse.wst.jsdt.core.IIncludePathEntry;
import org.eclipse.wst.jsdt.core.IJavaScriptProject;
import org.eclipse.wst.jsdt.core.IJavaScriptUnit;
import org.eclipse.wst.jsdt.core.IJsGlobalScopeContainer;
import org.eclipse.wst.jsdt.core.JavaScriptCore;
import org.eclipse.wst.jsdt.internal.codeassist.RelevanceConstants;

public class CompletionTests2 extends ModifyingResourceTests implements RelevanceConstants {
	
	public static final String DEFUALT_JSDTSCOPE = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + 
												  "<classpath>\n" + 
												   "       <classpathentry kind=\"src\" path=\"\"/>\n" + 
												   "       <classpathentry kind=\"con\" path=\"org.eclipse.wst.jsdt.launching.JRE_CONTAINER\"/>\n"+
												   "       <classpathentry kind=\"output\" path=\"\"/>\n"+
												   "</classpath>";
	/* 
		.project = DEFAULT_PROJECT_LEFT + project name + DEFAULT_PROJECT_RIGHT;
	*/
	public static final String DEFAULT_PROJECT_LEFT = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + 
													  "<projectDescription>\n" + 
													  "     <name>";
		
		
	public static final String DEFAULT_PROJECT_RIGHT ="</name>\n" + 
													  "     <comment></comment>\n" +
													  "     <projects>\n" +
													  "     </projects>\n"+
													  "     <buildSpec>\n"+
													  "     	<buildCommand>\n"+
													  "            <name>org.eclipse.wst.jsdt.core.javascriptValidator</name>\n"+
													  "               <arguments>\n"+
													  "               </arguments>\n"+
													  "         </buildCommand>\n"+
													  "     </buildSpec>\n"+
													  "     <natures>\n"+
													  "       <nature>org.eclipse.wst.jsdt.core.jsNature</nature>\n"+
													  "     </natures>\n" +
													  "</projectDescription>";

	
		
		
		
	public static class CompletionContainerInitializer implements ContainerInitializer.ITestInitializer {
		
		public static class DefaultContainer implements IJsGlobalScopeContainer {
			char[][] libPaths;
			boolean[] areExported;
			String[] forbiddenReferences;
			public DefaultContainer(char[][] libPaths, boolean[] areExported, String[] forbiddenReferences) {
				this.libPaths = libPaths;
				this.areExported = areExported;
				this.forbiddenReferences = forbiddenReferences;
			}
			/**
			 * @deprecated Use {@link #getIncludepathEntries()} instead
			 */
			public IIncludePathEntry[] getClasspathEntries() {
				return getIncludepathEntries();
			}
			public IIncludePathEntry[] getIncludepathEntries() {
				int length = this.libPaths.length;
				IIncludePathEntry[] entries = new IIncludePathEntry[length];
				for (int j = 0; j < length; j++) {
				    IPath path = new Path(new String(this.libPaths[j]));
				    boolean isExported = this.areExported[j];
		
				    IAccessRule[] accessRules;
				    if(forbiddenReferences != null && forbiddenReferences[j]!= null && forbiddenReferences[j].length() != 0) {
					    StringTokenizer tokenizer = new StringTokenizer(forbiddenReferences[j], ";");
					    int count = tokenizer.countTokens();
					    accessRules = new IAccessRule[count];
					    String token = null;
					    for (int i = 0; i < count; i++) {
					    	token = tokenizer.nextToken();
							accessRules[i] = JavaScriptCore.newAccessRule(new Path(token), IAccessRule.K_NON_ACCESSIBLE);
						}
					} else {
						accessRules = new IAccessRule[0];
					}
				    if (path.segmentCount() == 1) {
				        entries[j] = JavaScriptCore.newProjectEntry(path, accessRules, true, new IIncludePathAttribute[0], isExported);
				    } else {
						entries[j] = JavaScriptCore.newLibraryEntry(path, null, null, accessRules, new IIncludePathAttribute[0], isExported);
				    }
				}
				return entries;
			}
			public String getDescription() {
				return "Test container";
			}
			public int getKind() {
				return IJsGlobalScopeContainer.K_APPLICATION;
			}
			public IPath getPath() {
				return new Path("org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER");
			}
			/* (non-Javadoc)
			 * @see org.eclipse.wst.jsdt.core.IJsGlobalScopeContainer#resolvedLibraryImport(java.lang.String)
			 */
			public String[] resolvedLibraryImport(String a) {
				return new String[] {a};
			}
		}
		
		Map containerValues;
		CoreException exception;
		
		public CompletionContainerInitializer(String projectName, String[] libPaths, boolean[] areExported) {
			this(projectName, libPaths, areExported, null);
		}
		public CompletionContainerInitializer(String projectName, String[] libPaths, boolean[] areExported, String[] forbiddenRefrences) {
			containerValues = new HashMap();
			
			int libPathsLength = libPaths.length;
			char[][] charLibPaths = new char[libPathsLength][];
			for (int i = 0; i < libPathsLength; i++) {
				charLibPaths[i] = libPaths[i].toCharArray();
			}
			containerValues.put(
				projectName, 
				newContainer(charLibPaths, areExported, forbiddenRefrences)
			);
		}
		protected DefaultContainer newContainer(final char[][] libPaths, final boolean[] areExperted, final String[] forbiddenRefrences) {
			return new DefaultContainer(libPaths, areExperted, forbiddenRefrences);
		}
		public boolean allowFailureContainer() {
			return true;
		}
		public void initialize(IPath containerPath, IJavaScriptProject project) throws CoreException {
			if (containerValues == null) return;
			try {
				JavaScriptCore.setJsGlobalScopeContainer(
					containerPath, 
					new IJavaScriptProject[] {project},
					new IJsGlobalScopeContainer[] {(IJsGlobalScopeContainer)containerValues.get(project.getElementName())}, 
					null);
			} catch (CoreException e) {
				this.exception = e;
				throw e;
			}
		}
	}
public CompletionTests2(String name) {
	super(name);
}
public void setUpSuite() throws Exception {
	super.setUpSuite();
	
	setUpJavaProject("Completion");
}
public void tearDownSuite() throws Exception {
	deleteProject("Completion");
	
	super.tearDownSuite();
}

protected static void assertResults(String expected, String actual) {
	try {
		assertEquals(expected, actual);
	} catch(ComparisonFailure c) {
		System.out.println(actual);
		System.out.println();
		throw c;
	}
}
static {
//	TESTS_NAMES = new String[] { "testBug96950" };
}
public static Test suite() {
	return buildModelTestSuite(CompletionTests2.class);
}

File createFile(File parent, String name, String content) throws IOException {
	File file = new File(parent, name);
	FileOutputStream out = new FileOutputStream(file);
	out.write(content.getBytes());
	out.close();
	return file;
}
File createDirectory(File parent, String name) {
	File dir = new File(parent, name);
	dir.mkdirs();
	return dir;
}
/**
 * Test for bug 29832
 */
public void testBug29832() throws Exception {
	try {
		// create variable
//		JavaScriptCore.setClasspathVariables(
//			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
//			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
//			null);

		// create P1
	//	IFile f = getFile("/Completion/lib.jar");
		IFile f = getFile("/Completion/ZZZ.js");
		
		
		IJavaScriptProject p = this.createJavaProject(
			"P1",
			new String[]{"/"},
			new String[]{});
		IFile libFile = this.createFile("/P1/ZZZ.js", f.getContents());
		this.addLibraryEntry(p, libFile.getLocation().toString(), true);
		
		// create P2
		this.createJavaProject(
			"P2",
			new String[]{"/"},
			new String[]{},
			new String[]{"/P1"});
		this.createFile(
			"/P2/X.js",
			"function testZZZClass {\n"+
			"  var z = new ZZZ();\n"+
			"  z;\n" +
			"}");
		
		waitUntilIndexesReady();
		
		// do completion
		CompletionTestsRequestor requestor = new CompletionTestsRequestor();
		IJavaScriptUnit cu= getCompilationUnit("P2", "", "", "X.js");
		
		String str = cu.getSource();
		String completeBehind = "z";
		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
		cu.codeComplete(cursorLocation, requestor);

//		assertEquals(
//			"element:ZZZ    completion:pz.ZZZ    relevance:"+(R_DEFAULT + R_INTERESTING + R_CASE + R_EXACT_NAME + R_NON_RESTRICTED),
//			requestor.getResults());
		assertEquals(
					"element:ZZZ    completion:ZZZ    relevance:" +(R_DEFAULT+R_RESOLVED+R_INTERESTING+R_NON_RESTRICTED) + "\n"+
					"element:ZZZ_FUNCTION    completion:ZZZ_FUNCTION()    relevance:11\n" +
					"element:ZZZ_FUNCTION    completion:ZZZ_FUNCTION()    relevance:11\n" +
					"element:z    completion:z    relevance:"+ (R_DEFAULT+R_RESOLVED+R_INTERESTING+R_CASE+R_EXACT_NAME+R_UNQUALIFIED+R_NON_RESTRICTED),
					requestor.getResults());
		
		// delete P1
		p.getProject().delete(true, false, null);
		
		// create P1
		File dest = getWorkspaceRoot().getLocation().toFile();
		File pro = this.createDirectory(dest, "P1");
		File proSet = this.createDirectory(pro,".settings");
		
		this.createFile(proSet, ".jsdtscope", DEFUALT_JSDTSCOPE);
					
					
//					"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
//			"<classpath>\n" +
//			"    <classpathentry kind=\"src\" path=\"\"/>\n" +
//			"    <classpathentry kind=\"var\" path=\"JCL_LIB\" sourcepath=\"JCL_SRC\" rootpath=\"JCL_SRCROOT\"/>\n" +
//			"    <classpathentry kind=\"output\" path=\"bin\"/>\n" +
//			"</classpath>");
			
		this.createFile(pro, ".project", DEFAULT_PROJECT_LEFT + "org.eclipse.wst.jsdt.core" + DEFAULT_PROJECT_RIGHT);
//			"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
//			"<projectDescription>\n" +
//			"	<name>org.eclipse.wst.jsdt.core</name>\n" +
//			"	<comment></comment>\n" +
//			"	<projects>\n" +
//			"	</projects>\n" +
//			"	<buildSpec>\n" +
//			"		<buildCommand>\n" +
//			"			<name>org.eclipse.wst.jsdt.core.javabuilder</name>\n" +
//			"			<arguments>\n" +
//			"			</arguments>\n" +
//			"		</buildCommand>\n" +
//			"	</buildSpec>\n" +
//			"	<natures>\n" +
//			"		<nature>org.eclipse.wst.jsdt.core.javanature</nature>\n" +
//			"	</natures>\n" +
//			"</projectDescription>");
		
		//File src = this.createDirectory(pro, "src");
		
		//File pz = this.createDirectory(src, "pz");

		this.createFile(pro,"ZZZ.js","function testZZZClass {\n"+
										"  var z = new ZZZ();\n"+
										"  z;\n" +
										"}");
		
		final IProject project = getWorkspaceRoot().getProject("P1");
		IWorkspaceRunnable populate = new IWorkspaceRunnable() {
			public void run(IProgressMonitor monitor) throws CoreException {
				project.create(null);
				project.open(null);
			}
		};
		getWorkspace().run(populate, null);
		JavaScriptCore.create(project);
		
		waitUntilIndexesReady();
		
		// do completion
		requestor = new CompletionTestsRequestor();
		cu.codeComplete(cursorLocation, requestor);

		assertEquals(
			"element:z    completion:z    relevance:"+ (R_DEFAULT+R_INTERESTING+R_CASE+R_EXACT_NAME+R_UNQUALIFIED+R_NON_RESTRICTED) + "\n" +		
			"element:z    completion:z    relevance:"+(R_DEFAULT+R_RESOLVED+R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED),
			requestor.getResults());
	} finally {
		this.deleteProject("P1");
		this.deleteProject("P2");
	}
}
/**
 * Test for bug 33560
 */
public void testBug33560() throws Exception {
	try {
		// create variable
//		JavaScriptCore.setClasspathVariables(
//			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
//			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
//			null);

		// create P1
		//IFile f = getFile("/Completion/lib.jar");
		IFile f = getFile("/Completion/ZZZ.js");
		IJavaScriptProject p = this.createJavaProject(
					"P1",
					new String[]{"/"},
					new String[]{});;
					 IFile libFile = this.createFile("/P1/ZZZ.js", f.getContents());
						this.addLibraryEntry(p, libFile.getLocation().toString(), true);
		
		// create P2
						this.createJavaProject(
									"P2",
									new String[]{"/"},
									new String[]{},
									new String[]{"/P1"});
					
		// create P3
						this.createJavaProject(
									"P3",
									new String[]{"/"},
									new String[]{},
									new String[]{"/P1"});
						this.createFile(
									"/P3/X.js",
									"function testZZZClass {\n"+
									"  var z = new ZZZ();\n"+
									"  z;\n" +
									"}");
		
		waitUntilIndexesReady();
		
		// do completion
		CompletionTestsRequestor requestor = new CompletionTestsRequestor();
		IJavaScriptUnit cu= getCompilationUnit("P3", "", "", "X.js");
		
		String str = cu.getSource();
		String completeBehind = "z";
		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
		cu.codeComplete(cursorLocation, requestor);
		assertEquals(
		"element:ZZZ    completion:ZZZ    relevance:" +(R_DEFAULT+R_RESOLVED+R_INTERESTING+R_NON_RESTRICTED ) + "\n"+
		"element:ZZZ_FUNCTION    completion:ZZZ_FUNCTION()    relevance:11\n" +
		"element:ZZZ_FUNCTION    completion:ZZZ_FUNCTION()    relevance:11\n" +
		"element:z    completion:z    relevance:"+ (R_DEFAULT+R_RESOLVED+R_INTERESTING+R_CASE+R_EXACT_NAME+R_UNQUALIFIED+R_NON_RESTRICTED),
		requestor.getResults());
		
		
		// delete P1
		p.getProject().delete(true, false, null);
		
		// create P1
		File dest = getWorkspaceRoot().getLocation().toFile();
		File pro = this.createDirectory(dest, "P1");
		File proSet = this.createDirectory(pro,".settings");
		
		this.createFile(proSet, ".jsdtscope", DEFUALT_JSDTSCOPE);
//		this.createFile(pro, ".classpath", "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
//			"<classpath>\n" +
//			"    <classpathentry kind=\"src\" path=\"src\"/>\n" +
//			"    <classpathentry kind=\"var\" path=\"JCL_LIB\" sourcepath=\"JCL_SRC\" rootpath=\"JCL_SRCROOT\"/>\n" +
//			"    <classpathentry kind=\"output\" path=\"bin\"/>\n" +
//			"</classpath>");
		this.createFile(pro, ".project", DEFAULT_PROJECT_LEFT + "org.eclipse.wst.jsdt.core" + DEFAULT_PROJECT_RIGHT);
//		this.createFile(pro, ".project", 
//			"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
//			"<projectDescription>\n" +
//			"	<name>org.eclipse.wst.jsdt.core</name>\n" +
//			"	<comment></comment>\n" +
//			"	<projects>\n" +
//			"	</projects>\n" +
//			"	<buildSpec>\n" +
//			"		<buildCommand>\n" +
//			"			<name>org.eclipse.wst.jsdt.core.javabuilder</name>\n" +
//			"			<arguments>\n" +
//			"			</arguments>\n" +
//			"		</buildCommand>\n" +
//			"	</buildSpec>\n" +
//			"	<natures>\n" +
//			"		<nature>org.eclipse.wst.jsdt.core.javanature</nature>\n" +
//			"	</natures>\n" +
//			"</projectDescription>");
//		
		File src = this.createDirectory(pro, "src");
		
		File pz = this.createDirectory(src, "pz");
		
		this.createFile(pro,"ZZZ.js","function testZZZClass {\n"+
					"  var z = new ZZZ();\n"+
					"  z;\n" +
					"}");
		
		final IProject project = getWorkspaceRoot().getProject("P1");
		IWorkspaceRunnable populate = new IWorkspaceRunnable() {
			public void run(IProgressMonitor monitor) throws CoreException {
				project.create(null);
				project.open(null);
			}
		};
		getWorkspace().run(populate, null);
		JavaScriptCore.create(project);
		
		waitUntilIndexesReady();
		
		// do completion
		requestor = new CompletionTestsRequestor();
		cu.codeComplete(cursorLocation, requestor);

		assertEquals(
					"element:z    completion:z    relevance:"+ (R_DEFAULT+R_INTERESTING+R_CASE+R_EXACT_NAME+R_UNQUALIFIED+R_NON_RESTRICTED) + "\n" +
					"element:z    completion:z    relevance:"+(R_DEFAULT+R_RESOLVED+R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED),
					requestor.getResults());
		} finally {
		this.deleteProject("P1");
		this.deleteProject("P2");
		this.deleteProject("P3");
	}
}
/*
 * 
 * This tests a project which includes functions and methods marked as "not exported" from another project.  This is N/A for JS.
 */

//public void testBug79288() throws Exception {
//	try {
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			new String[]{"/P1"},
//			"bin");
//		
//		this.createFolder("/P2/src/b");
//		this.createFile(
//				"/P2/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P3
//		this.createJavaProject(
//			"P3",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			new String[]{"/P2"},
//			"bin");
//		
//		this.createFile(
//				"/P3/src/YY.js",
//				"public class YY {\n"+
//				"  vois foo(){\n"+
//				"    XX\n"+
//				"  }\n"+
//				"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P3", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		this.deleteProject("P3");
//	}
//}




//public void testBug91772() throws Exception {
//	try {
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//		
//		// create P2
//		ContainerInitializer.setInitializer(new CompletionContainerInitializer("P2", new String[] {"/P1"}, new boolean[] {true}));
//		String[] classLib = new String[]{"JCL_LIB"};
//		int classLibLength = classLib.length;
//		String[] lib = new String[classLibLength + 1];
//		System.arraycopy(classLib, 0, lib, 0, classLibLength);
//		lib[classLibLength] = "org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER";
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			lib,
//			"bin");
//		
//		this.createFolder("/P2/src/b");
//		this.createFile(
//				"/P2/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P3
//		this.createJavaProject(
//			"P3",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			new String[]{"/P2"},
//			"bin");
//		
//		this.createFile(
//				"/P3/src/YY.js",
//				"public class YY {\n"+
//				"  vois foo(){\n"+
//				"    XX\n"+
//				"  }\n"+
//				"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P3", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX1[TYPE_REF]{a.XX1, a, La.XX1;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		this.deleteProject("P3");
//		
//		
//		// TODO the following code is not the correct way to remove the container
//		// Cleanup caches
//		JavaModelManager manager = JavaModelManager.getJavaModelManager();
//		manager.containers = new HashMap(5);
//		manager.variables = new HashMap(5);
//	}
//}
//public void testBug93891() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//		
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P2
//		ContainerInitializer.setInitializer(new CompletionContainerInitializer("P2", new String[] {"/P1"}, new boolean[] {true}, new String[]{"a/*"}));
//		String[] classLib = new String[]{"JCL_LIB"};
//		int classLibLength = classLib.length;
//		String[] lib = new String[classLibLength + 1];
//		System.arraycopy(classLib, 0, lib, 0, classLibLength);
//		lib[classLibLength] = "org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER";
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			lib,
//			"bin");
//		
//		this.createFolder("/P2/src/b");
//		this.createFile(
//				"/P2/src/YY.js",
//				"public class YY {\n"+
//				"  void foo() {\n"+
//				"    XX\n"+
//				"  }\n"+
//				"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		
//		// TODO the following code is not the correct way to remove the container
//		// Cleanup caches
//		JavaModelManager manager = JavaModelManager.getJavaModelManager();
//		manager.containers = new HashMap(5);
//		manager.variables = new HashMap(5);
//		
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction1() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.IGNORE);
//		options.put(JavaScriptCore.COMPILER_PB_DISCOURAGED_REFERENCE, JavaScriptCore.IGNORE);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			new String[]{"/P1"},
//			"bin");
//		this.createFile(
//			"/P2/src/YY.js",
//			"public class YY {\n"+
//			"  void foo() {\n"+
//			"    XX\n"+
//			"  }\n"+
//			"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX1[TYPE_REF]{a.XX1, a, La.XX1;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
// 			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//
//public void testAccessRestriction2() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.IGNORE);
//		options.put(JavaScriptCore.COMPILER_PB_DISCOURAGED_REFERENCE, JavaScriptCore.IGNORE);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"a/*"}},
//			new boolean[]{false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		this.createFile(
//			"/P2/src/YY.js",
//			"public class YY {\n"+
//			"  void foo() {\n"+
//			"    XX\n"+
//			"  }\n"+
//			"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX1[TYPE_REF]{a.XX1, a, La.XX1;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
// 			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction3() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"a/*"}},
//			new boolean[]{false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		this.createFile(
//			"/P2/src/YY.js",
//			"public class YY {\n"+
//			"  void foo() {\n"+
//			"    XX\n"+
//			"  }\n"+
//			"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX1[TYPE_REF]{a.XX1, a, La.XX1;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE) + "}\n" +
// 			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction4() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.IGNORE);
//		options.put(JavaScriptCore.COMPILER_PB_DISCOURAGED_REFERENCE, JavaScriptCore.IGNORE);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"a/*"}},
//			new boolean[]{false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		this.createFile(
//			"/P2/src/YY.js",
//			"public class YY {\n"+
//			"  void foo() {\n"+
//			"    XX\n"+
//			"  }\n"+
//			"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX1[TYPE_REF]{a.XX1, a, La.XX1;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
// 			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction5() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"a/*"}},
//			new boolean[]{false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		this.createFile(
//			"/P2/src/YY.js",
//			"public class YY {\n"+
//			"  void foo() {\n"+
//			"    XX\n"+
//			"  }\n"+
//			"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction6() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		this.createFolder("/P1/src/c");
//		this.createFile(
//				"/P1/src/c/XX3.js",
//				"package c;\n"+
//				"public class XX3 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"a/*"}},
//			new boolean[]{true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		// create P3
//		this.createJavaProject(
//			"P3",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P2"},
//			new String[][]{{}},
//			new String[][]{{"b/*"}},
//			new boolean[]{false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		this.createFile(
//			"/P3/src/YY.js",
//			"public class YY {\n"+
//			"  void foo() {\n"+
//			"    XX\n"+
//			"  }\n"+
//			"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P3", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX3[TYPE_REF]{c.XX3, c, Lc.XX3;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		this.deleteProject("P3");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction7() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1", "/P3"},
//			new String[][]{{}, {}},
//			new String[][]{{"a/*"}, {}},
//			new boolean[]{false, false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		this.createFile(
//				"/P2/src/YY.js",
//				"public class YY {\n"+
//				"  void foo() {\n"+
//				"    XX\n"+
//				"  }\n"+
//				"}");
//		
//		// create P3
//		this.createJavaProject(
//			"P3",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{}},
//			new boolean[]{true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		this.deleteProject("P3");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction8() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P3", "/P1"},
//			new String[][]{{}, {}},
//			new String[][]{{}, {"a/*"}},
//			new boolean[]{false, false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		this.createFile(
//				"/P2/src/YY.js",
//				"public class YY {\n"+
//				"  void foo() {\n"+
//				"    XX\n"+
//				"  }\n"+
//				"}");
//		
//		// create P3
//		this.createJavaProject(
//			"P3",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{}},
//			new boolean[]{true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX1[TYPE_REF]{a.XX1, a, La.XX1;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		this.deleteProject("P3");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction9() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/p11");
//		this.createFile(
//				"/P1/src/p11/XX11.js",
//				"package p11;\n"+
//				"public class XX11 {\n"+
//				"}");
//		
//		this.createFolder("/P1/src/p12");
//		this.createFile(
//				"/P1/src/p12/XX12.js",
//				"package p12;\n"+
//				"public class XX12 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1", "/P3"},
//			new String[][]{{}, {}},
//			new String[][]{{"p11/*"}, {"p31/*"}},
//			new boolean[]{true, true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		this.createFolder("/P2/src/p21");
//		this.createFile(
//				"/P2/src/p21/XX21.js",
//				"package p21;\n"+
//				"public class XX21 {\n"+
//				"}");
//		
//		this.createFolder("/P2/src/p22");
//		this.createFile(
//				"/P2/src/p22/XX22.js",
//				"package p22;\n"+
//				"public class XX22 {\n"+
//				"}");
//		
//		// create P3
//		this.createJavaProject(
//			"P3",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"p12/*"}},
//			new boolean[]{true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		this.createFolder("/P3/src/p31");
//		this.createFile(
//				"/P3/src/p31/XX31.js",
//				"package p31;\n"+
//				"public class XX31 {\n"+
//				"}");
//		
//		this.createFolder("/P3/src/p32");
//		this.createFile(
//				"/P3/src/p32/XX32.js",
//				"package p32;\n"+
//				"public class XX32 {\n"+
//				"}");
//		
//		// create PX
//		this.createJavaProject(
//				"PX",
//				new String[]{"src"},
//				new String[]{"JCL_LIB"},
//				null,
//				null,
//				new String[]{"/P2"},
//				null,
//				null,
//				new boolean[]{false},
//				"bin",
//				null,
//				null,
//				null,
//				"1.4");
//		
//		this.createFile(
//				"/PX/src/X.js",
//				"public class X {\n"+
//				"  void foo() {\n"+
//				"    XX\n"+
//				"  }\n"+
//				"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("PX", "src", "", "X.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX12[TYPE_REF]{p12.XX12, p12, Lp12.XX12;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX21[TYPE_REF]{p21.XX21, p21, Lp21.XX21;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX22[TYPE_REF]{p22.XX22, p22, Lp22.XX22;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX32[TYPE_REF]{p32.XX32, p32, Lp32.XX32;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		this.deleteProject("P3");
//		this.deleteProject("PX");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction10() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/p11");
//		this.createFile(
//				"/P1/src/p11/XX11.js",
//				"package p11;\n"+
//				"public class XX11 {\n"+
//				"}");
//		
//		this.createFolder("/P1/src/p12");
//		this.createFile(
//				"/P1/src/p12/XX12.js",
//				"package p12;\n"+
//				"public class XX12 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1", "/P3"},
//			new String[][]{{}, {}},
//			new String[][]{{"p11/*"}, {"p31/*"}},
//			new boolean[]{true, true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		this.createFolder("/P2/src/p21");
//		this.createFile(
//				"/P2/src/p21/XX21.js",
//				"package p21;\n"+
//				"public class XX21 {\n"+
//				"}");
//		
//		this.createFolder("/P2/src/p22");
//		this.createFile(
//				"/P2/src/p22/XX22.js",
//				"package p22;\n"+
//				"public class XX22 {\n"+
//				"}");
//		
//		// create P3
//		this.createJavaProject(
//			"P3",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"p12/*"}},
//			new boolean[]{true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		this.createFolder("/P3/src/p31");
//		this.createFile(
//				"/P3/src/p31/XX31.js",
//				"package p31;\n"+
//				"public class XX31 {\n"+
//				"}");
//		
//		this.createFolder("/P3/src/p32");
//		this.createFile(
//				"/P3/src/p32/XX32.js",
//				"package p32;\n"+
//				"public class XX32 {\n"+
//				"}");
//		
//		// create PX
//		this.createJavaProject(
//				"PX",
//				new String[]{"src"},
//				new String[]{"JCL_LIB"},
//				null,
//				null,
//				new String[]{"/P2"},
//				null,
//				null,
//				new boolean[]{false},
//				"bin",
//				null,
//				null,
//				null,
//				"1.4");
//		
//		this.createFile(
//				"/PX/src/X.js",
//				"public class X {\n"+
//				"  void foo() {\n"+
//				"    XX\n"+
//				"  }\n"+
//				"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("PX", "src", "", "X.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX11[TYPE_REF]{p11.XX11, p11, Lp11.XX11;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE) + "}\n" +
//			"XX31[TYPE_REF]{p31.XX31, p31, Lp31.XX31;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE) + "}\n" +
//			"XX12[TYPE_REF]{p12.XX12, p12, Lp12.XX12;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX21[TYPE_REF]{p21.XX21, p21, Lp21.XX21;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX22[TYPE_REF]{p22.XX22, p22, Lp22.XX22;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX32[TYPE_REF]{p32.XX32, p32, Lp32.XX32;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		this.deleteProject("P3");
//		this.deleteProject("PX");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction11() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/x/y/z/p11");
//		this.createFile(
//				"/P1/src/x/y/z/p11/XX11.js",
//				"package x.y.z.p11;\n"+
//				"public class XX11 {\n"+
//				"}");
//		
//		this.createFolder("/P1/src/x/y/z/p12");
//		this.createFile(
//				"/P1/src/x/y/z/p12/XX12.js",
//				"package x.y.z.p12;\n"+
//				"public class XX12 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P3", "/P1"},
//			new String[][]{{}, {}},
//			new String[][]{{"x/y/z/p31/*"}, {"x/y/z/p11/*"}},
//			new boolean[]{true, true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		this.createFolder("/P2/src/x/y/z/p21");
//		this.createFile(
//				"/P2/src/x/y/z/p21/XX21.js",
//				"package x.y.z.p21;\n"+
//				"public class XX21 {\n"+
//				"}");
//		
//		this.createFolder("/P2/src/x/y/z/p22");
//		this.createFile(
//				"/P2/src/x/y/z/p22/XX22.js",
//				"package x.y.z.p22;\n"+
//				"public class XX22 {\n"+
//				"}");
//		
//		// create P3
//		this.createJavaProject(
//			"P3",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"x/y/z/p12/*"}},
//			new boolean[]{true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		this.createFolder("/P3/src/x/y/z/p31");
//		this.createFile(
//				"/P3/src/x/y/z/p31/XX31.js",
//				"package x.y.z.p31;\n"+
//				"public class XX31 {\n"+
//				"}");
//		
//		this.createFolder("/P3/src/x/y/z/p32");
//		this.createFile(
//				"/P3/src/x/y/z/p32/XX32.js",
//				"package x.y.z.p32;\n"+
//				"public class XX32 {\n"+
//				"}");
//		
//		// create PX
//		this.createJavaProject(
//				"PX",
//				new String[]{"src"},
//				new String[]{"JCL_LIB"},
//				null,
//				null,
//				new String[]{"/P2"},
//				null,
//				null,
//				new boolean[]{false},
//				"bin",
//				null,
//				null,
//				null,
//				"1.4");
//		
//		this.createFile(
//				"/PX/src/X.js",
//				"public class X {\n"+
//				"  void foo() {\n"+
//				"    XX\n"+
//				"  }\n"+
//				"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("PX", "src", "", "X.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX11[TYPE_REF]{x.y.z.p11.XX11, x.y.z.p11, Lx.y.z.p11.XX11;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX21[TYPE_REF]{x.y.z.p21.XX21, x.y.z.p21, Lx.y.z.p21.XX21;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX22[TYPE_REF]{x.y.z.p22.XX22, x.y.z.p22, Lx.y.z.p22.XX22;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX32[TYPE_REF]{x.y.z.p32.XX32, x.y.z.p32, Lx.y.z.p32.XX32;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		this.deleteProject("P3");
//		this.deleteProject("PX");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction12() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/p11");
//		this.createFile(
//				"/P1/src/p11/XX11.js",
//				"package p11;\n"+
//				"public class XX11 {\n"+
//				"}");
//		
//		this.createFolder("/P1/src/p12");
//		this.createFile(
//				"/P1/src/p12/XX12.js",
//				"package p12;\n"+
//				"public class XX12 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P3", "/P1"},
//			new String[][]{{}, {}},
//			new String[][]{{"p31/*"}, {"p11/*"}},
//			new boolean[]{true, true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		this.createFolder("/P2/src/p21");
//		this.createFile(
//				"/P2/src/p21/XX21.js",
//				"package p21;\n"+
//				"public class XX21 {\n"+
//				"}");
//		
//		this.createFolder("/P2/src/p22");
//		this.createFile(
//				"/P2/src/p22/XX22.js",
//				"package p22;\n"+
//				"public class XX22 {\n"+
//				"}");
//		
//		// create P3
//		this.createJavaProject(
//			"P3",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"p12/*"}},
//			new boolean[]{true},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		
//		this.createFolder("/P3/src/p31");
//		this.createFile(
//				"/P3/src/p31/XX31.js",
//				"package p31;\n"+
//				"public class XX31 {\n"+
//				"}");
//		
//		this.createFolder("/P3/src/p32");
//		this.createFile(
//				"/P3/src/p32/XX32.js",
//				"package p32;\n"+
//				"public class XX32 {\n"+
//				"}");
//		
//		// create PX
//		this.createJavaProject(
//				"PX",
//				new String[]{"src"},
//				new String[]{"JCL_LIB"},
//				null,
//				null,
//				new String[]{"/P2"},
//				null,
//				null,
//				new boolean[]{false},
//				"bin",
//				null,
//				null,
//				null,
//				"1.4");
//		
//		this.createFile(
//				"/PX/src/X.js",
//				"public class X {\n"+
//				"  void foo() {\n"+
//				"    XX\n"+
//				"  }\n"+
//				"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("PX", "src", "", "X.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX12[TYPE_REF]{p12.XX12, p12, Lp12.XX12;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE) + "}\n" +
//			"XX31[TYPE_REF]{p31.XX31, p31, Lp31.XX31;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE) + "}\n" +
//			"XX11[TYPE_REF]{p11.XX11, p11, Lp11.XX11;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX21[TYPE_REF]{p21.XX21, p21, Lp21.XX21;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX22[TYPE_REF]{p22.XX22, p22, Lp22.XX22;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}\n" +
//			"XX32[TYPE_REF]{p32.XX32, p32, Lp32.XX32;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		this.deleteProject("P3");
//		this.deleteProject("PX");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction13() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.WARNING);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"a/*"}},
//			new boolean[]{false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		this.createFile(
//			"/P2/src/YY.js",
//			"public class YY {\n"+
//			"  void foo() {\n"+
//			"    XX\n"+
//			"  }\n"+
//			"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestriction14() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.WARNING);
//		options.put(JavaScriptCore.CODEASSIST_FORBIDDEN_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		options.put(JavaScriptCore.CODEASSIST_DISCOURAGED_REFERENCE_CHECK, JavaScriptCore.ENABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"}");
//
//		this.createFolder("/P1/src/b");
//		this.createFile(
//				"/P1/src/b/XX2.js",
//				"package b;\n"+
//				"public class XX2 {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"a/*"}},
//			new boolean[]{false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		this.createFile(
//			"/P2/src/YY.js",
//			"public class YY {\n"+
//			"  void foo() {\n"+
//			"    XX\n"+
//			"  }\n"+
//			"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "XX";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"XX2[TYPE_REF]{b.XX2, b, Lb.XX2;, null, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testAccessRestrictionX() throws Exception {
//	Hashtable oldOptions = JavaScriptCore.getOptions();
//	try {
//		Hashtable options = new Hashtable(oldOptions);
//		options.put(JavaScriptCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaScriptCore.ERROR);
//		options.put(JavaScriptCore.CODEASSIST_RESTRICTIONS_CHECK, JavaScriptCore.DISABLED);
//		JavaScriptCore.setOptions(options);
//		
//		// create variable
//		JavaScriptCore.setClasspathVariables(
//			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
//			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
//			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		
//		this.createFolder("/P1/src/a");
//		this.createFile(
//				"/P1/src/a/XX1.js",
//				"package a;\n"+
//				"public class XX1 {\n"+
//				"  public void foo() {\n"+
//				"  }\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"a/*"}},
//			new boolean[]{false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		this.createFile(
//			"/P2/src/YY.js",
//			"public class YY {\n"+
//			"  void foo() {\n"+
//			"    a.XX1 x;\n"+
//			"    x.fo\n"+
//			"  }\n"+
//			"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "YY.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "x.fo";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"foo[FUNCTION_REF]{foo(), La.XX1;, ()V, foo, "+(R_DEFAULT + R_INTERESTING + R_CASE + R_NON_STATIC) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//		JavaScriptCore.setOptions(oldOptions);
//	}
//}
//public void testBug96950() throws Exception {
//	try {
//		// create variable
////		JavaScriptCore.setClasspathVariables(
////			new String[] {"JCL_LIB", "JCL_SRC", "JCL_SRCROOT"},
////			new IPath[] {getExternalJCLPath(), getExternalJCLSourcePath(), getExternalJCLRootSourcePath()},
////			null);
//
//		// create P1
//		this.createJavaProject(
//			"P1",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			 "bin");
//		this.createFile(
//				"/P1/src/Taratata.js",
//				"public class Taratata {\n"+
//				"}");
//		
//		// create P2
//		this.createJavaProject(
//			"P2",
//			new String[]{"src"},
//			new String[]{"JCL_LIB"},
//			null,
//			null,
//			new String[]{"/P1"},
//			new String[][]{{}},
//			new String[][]{{"**/*"}},
//			new boolean[]{false},
//			"bin",
//			null,
//			null,
//			null,
//			"1.4");
//		this.createFile(
//				"/P2/src/BreakRules.js",
//				"public class BreakRules {\n"+
//				"	Tara\n"+
//				"}");
//		
//		waitUntilIndexesReady();
//		
//		// do completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit cu= getCompilationUnit("P2", "src", "", "BreakRules.js");
//		
//		String str = cu.getSource();
//		String completeBehind = "Tara";
//		int cursorLocation = str.lastIndexOf(completeBehind) + completeBehind.length();
//		cu.codeComplete(cursorLocation, requestor);
//		
//		assertResults(
//			"Tara[POTENTIAL_METHOD_DECLARATION]{Tara, LBreakRules;, ()V, Tara, "+(R_DEFAULT + R_INTERESTING + R_NON_RESTRICTED) + "}",
//			requestor.getResults());
//	} finally {
//		this.deleteProject("P1");
//		this.deleteProject("P2");
//	}
//}
/**
 * @bug 162621: [model][delta] Validation errors do not clear after replacing jar file
 * @test Ensures that changing an internal jar and refreshing takes the change into account
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=162621"
 */
//public void testChangeInternalJar() throws CoreException, IOException {
//	
//	
//	IJavaScriptProject p = this.createJavaProject(
//				"P1",
//				new String[]{"/"},
//				new String[]{},
//				 "");
//	
//	
//	
//	
//	try {
//		// Create jar file with a class with 2 methods doXXX
//		String[] pathAndContents = new String[] {
//			"pack/Util.js",
//			"package pack;\n" + 
//			"public class Util {\n" + 
//			"    public void doit2A(int x, int y) { }\n" + 
//			"    public void doit2B(int x) { }\n" + 
//			"}\n"
//		};
//		addLibrary(jarName, "b162621_src.zip", pathAndContents, JavaScriptCore.VERSION_1_4);
//
//		// Wait a little bit to be sure file system is aware of zip file creation
//		try {
//			Thread.sleep(1000);
//		}
//		catch (InterruptedException ie) {
//			// skip
//		}
//
//		// Create compilation unit in which completion occurs
//		String path = "/Completion/src/test/Test.js";
//		String source = "package test;\n" + 
//			"import pack.*;\n" + 
//			"public class Test {\n" + 
//			"	public void foo() {\n" + 
//			"		Util test = new Util();\n" + 
//			"		test.doit2A(1, 2);\n" + 
//			"	}\n" + 
//			"}\n";
//		createFolder("/Completion/src/test");
//		createFile(path, source);
//
//		// first completion
//		CompletionTestsRequestor2 requestor = new CompletionTestsRequestor2();
//		IJavaScriptUnit unit = getCompilationUnit(path);
//		String completeBehind = "test.do";
//		int cursorLocation = source.lastIndexOf(completeBehind) + completeBehind.length();
//		unit.codeComplete(cursorLocation, requestor);
//		assertResults(
//			"doit2A[FUNCTION_REF]{doit2A, Lpack.Util;, (II)V, doit2A, "+(R_DEFAULT + R_CASE + R_INTERESTING + R_NON_RESTRICTED + R_NON_STATIC) + "}\n" +
//			"doit2B[FUNCTION_REF]{doit2B, Lpack.Util;, (I)V, doit2B, "+(R_DEFAULT + R_CASE + R_INTERESTING + R_NON_RESTRICTED + R_NON_STATIC) + "}",
//			requestor.getResults());
//
//		// change class file to add a third doXXX method and refresh
//		String projectLocation = this.currentProject.getProject().getLocation().toOSString();
//		String jarPath = projectLocation + File.separator + jarName;
//		org.eclipse.wst.jsdt.core.tests.util.Util.createJar(new String[] {
//			"pack/Util.js",
//			"package pack;\n" + 
//			"public class Util {\n" + 
//			"    public void doit2A(int x, int y) { }\n" + 
//			"    public void doit2B(int x) { }\n" + 
//			"    public void doit2C(int x) { }\n" + 
//			"}\n"
//		}, jarPath, "1.4");
//		this.currentProject.getProject().refreshLocal(IResource.DEPTH_INFINITE, null);
//
//		try {
//			Thread.sleep(1000);
//		}
//		catch (InterruptedException ie) {
//			// skip
//		}
//
//		// second completion
//		requestor = new CompletionTestsRequestor2();
//		unit.codeComplete(cursorLocation, requestor);
//		assertResults(
//			"doit2A[FUNCTION_REF]{doit2A, Lpack.Util;, (II)V, doit2A, "+(R_DEFAULT + R_CASE + R_INTERESTING + R_NON_RESTRICTED + R_NON_STATIC) + "}\n" +
//			"doit2B[FUNCTION_REF]{doit2B, Lpack.Util;, (I)V, doit2B, "+(R_DEFAULT + R_CASE + R_INTERESTING + R_NON_RESTRICTED + R_NON_STATIC) + "}\n" +
//			"doit2C[FUNCTION_REF]{doit2C, Lpack.Util;, (I)V, doit2C, "+(R_DEFAULT + R_CASE + R_INTERESTING + R_NON_RESTRICTED + R_NON_STATIC) + "}",
//			requestor.getResults());
//	} finally {
//		removeLibraryEntry(this.currentProject, new Path(jarName));
//		deleteFile(new File(jarName));
//	}
//}
}




		// Binding key tests
		BindingKeyTests.class,

		// Working copy tests
//		CreateMembersTests.class,
//		
//		// Java Naming convention tests
//		JavaConventionTests.class,
//	
//		// Project & Root API unit tests
//		JavaProjectTests.class,
//	
//		// Compilation unit tests
//		CompilationUnitTests.class,
//	
//		// Source attachment tests
//		AttachSourceTests.class,
//		
//		// Attached javadoc tests
//		AttachedJavadocTests.class,
//	
//		// Java search tests
//		RunJavaSearchTests.class,
//			
//		// Working copy tests
		WorkingCopyTests.class,

//		HierarchyOnWorkingCopiesTests.class,
//		
//		// test IJavaScriptModel
//		JavaModelTests.class,
//	
//		// tests to check the encoding
//		EncodingTests.class,
//		
//		// test class name with special names like names containing '$'
//		ClassNameTests.class,
//		
		// IBuffer tests
		BufferTests.class,

//		// Name lookup tests
//		NameLookupTests2.class,
//	
//		// Classpath and output location tests
//		ClasspathTests.class,
//	
//		// Delta tests
//		JavaElementDeltaTests.class,
//		ExternalJarDeltaTests.class,
//	
//		// Java element existence tests
//		ExistenceTests.class,
//		
//		// Support for "open on" feature tests
//		ResolveTests.class,
//		ResolveTests_1_5.class,
//		SelectionJavadocModelTests.class,
//
//		// Support for completion tests
		RunCompletionModelTests.class,
//		
//		// Prefix and suffix tests
//		NamingConventionTests.class,
//		
//		// Code correction tests
//		CodeCorrectionTests.class,
//		
//		// Options tests
//		OptionTests.class,
//		
//		// Type hierarchy tests
//		TypeHierarchyTests.class,
//		TypeHierarchyNotificationTests.class,
//		TypeHierarchySerializationTests.class,
//		
//		// Resolve type tests
//		TypeResolveTests.class,
//	
//		// Reconciler tests
//		ReconcilerTests.class,
//		ReconcilerStatementsRecoveryTests.class,
//		
//		// Copy and move operation tests
//		CopyMoveElementsTests.class,
//		CopyMoveResourcesTests.class,
//	
//		// Rename tests
//		RenameTests.class,
//		
//		// Exclusion patterns tests
//		ExclusionPatternsTests.class,
//		
//		// Inclusion patterns tests
//		InclusionPatternsTests.class,
//		
//		// Access restrictions tests
//		AccessRestrictionsTests.class,
//		
//		// Signature tests
//		SignatureTests.class,
//		
//		// Variable initializers and container initializers tests
//		ClasspathInitializerTests.class,
//	
//		// Java Model Factory tests
//		FactoryTests.class,
//				
//		// Java Element persistence tests
//		MementoTests.class,
//		
//		// Java Element sorting tests
//		SortCompilationUnitElementsTests.class,
//	
//		// Package fragment root manipulation tests
//		RootManipulationsTests.class,
//		
//		// Owverflowing cache tests
//		OverflowingCacheTests.class,
//		
//		// Working copy owner tests
//		WorkingCopyOwnerTests.class,
//	
//		// Delete Java element tests
//		DeleteTests.class,
//		
//		// Local element tests
//		LocalElementTests.class,
//		
//		// Get source tests
//		GetSourceTests.class,
//			
//		// Create packages tests
//		CreatePackageTests.class,
//	
//		// Create compilation units tests
//		CreateCompilationUnitTests.class,
//		
//		// Create search participant tests
//		SearchParticipantTests.class,
//		
//		// Class file tests
//		ClassFileTests.class,
//		
		// Java-like extensions tests
		JavaScriptLikeExtensionsTests.class,
		




/*******************************************************************************
 * Copyright (c) 2000, 2008 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.lang.reflect.*;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.wst.jsdt.core.tests.junit.extension.TestCase;

import junit.framework.Test;
import junit.framework.TestSuite;

public class RunCompletionModelTests extends junit.framework.TestCase {

	protected static final boolean ONLY_JAVADOC = "true".equals(System.getProperty("onlyJavadoc", "false"));

	public final static List COMPLETION_SUITES = new ArrayList();
	static {
		if (!ONLY_JAVADOC) {
			if(false) COMPLETION_SUITES.add(CompletionTests.class);
			COMPLETION_SUITES.add(CompletionTests2.class);
			if(false) COMPLETION_SUITES.add(CompletionContextTests.class);
			if(false) COMPLETION_SUITES.add(CompletionWithMissingTypesTests.class);
			if(false) COMPLETION_SUITES.add(CompletionWithMissingTypesTests2.class);
			if(false) COMPLETION_SUITES.add(SnippetCompletionContextTests.class);
		}
		if(false) COMPLETION_SUITES.add(JavadocTypeCompletionModelTest.class);
		if(false) COMPLETION_SUITES.add(JavadocFieldCompletionModelTest.class);
		if(false) COMPLETION_SUITES.add(JavadocMethodCompletionModelTest.class);
		if(false) COMPLETION_SUITES.add(JavadocPackageCompletionModelTest.class);
		if(false) COMPLETION_SUITES.add(JavadocTextCompletionModelTest.class);
		if(false) COMPLETION_SUITES.add(JavadocBugsCompletionModelTest.class);
		if(false) COMPLETION_SUITES.add(JavadocCompletionContextTests.class);
	}

	public static Class[] getTestClasses() {
//		int size = COMPLETION_SUITES.size();
//		if (!ONLY_JAVADOC) {
//			Class[] testClasses = new Class[size+1];
//			COMPLETION_SUITES.toArray(testClasses);
//			testClasses[size] = CompletionTests2.class;
//			testClasses[size+1] = CompletionWithMissingTypesTests2.class;
//			if(false) testClasses[size+2] = SnippetCompletionTests.class;
//			if(false) testClasses[size+3] = SnippetCompletionTests_1_5.class;
//			return testClasses;
//		}
//		Class[] testClasses = new Class[size];
		return  (Class[])COMPLETION_SUITES.toArray(new Class[COMPLETION_SUITES.size()]);
		//return testClasses;
	}

	public RunCompletionModelTests(String name) {
		super(name);
	}

	public static Test suite() {
		TestSuite ts = new TestSuite(RunCompletionModelTests.class.getName());

		// Store test classes with same "Completion"project
		AbstractJavaModelCompletionTests.COMPLETION_SUITES = new ArrayList(COMPLETION_SUITES);

		// Get all classes
		Class[] allClasses = getTestClasses();

		// Reset forgotten subsets of tests
		TestCase.TESTS_PREFIX = null;
		TestCase.TESTS_NAMES = null;
		TestCase.TESTS_NUMBERS = null;
		TestCase.TESTS_RANGE = null;
		TestCase.RUN_ONLY_ID = null;

		// Add all tests suite of tests
		for (int i = 0, length = allClasses.length; i < length; i++) {
			Class testClass = allClasses[i];

			// call the suite() method and add the resulting suite to the suite
			try {
				Method suiteMethod = testClass.getDeclaredMethod("suite", new Class[0]); //$NON-NLS-1$
				Test suite = (Test) suiteMethod.invoke(null, new Object[0]);
				ts.addTest(suite);
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			} catch (InvocationTargetException e) {
				e.getTargetException().printStackTrace();
			} catch (NoSuchMethodException e) {
				e.printStackTrace();
			}
		}
		return ts;
	}
}

Lines 196-203 Link Here

(-)src/org/eclipse/wst/jsdt/internal/ui/text/java/JavaMethodCompletionProposal.java (-2 / +7 lines)
196	parameterCount= Signature.getParameterCount(fProposal.getSignature()) % 10; // we don't care about insane methods with >9 parameters	196	parameterCount= Signature.getParameterCount(fProposal.getSignature()) % 10; // we don't care about insane methods with >9 parameters
197	} else {	197	} else {
198	char[][] params = this.fProposal.getParamaterNames();	198	char[][] params = this.fProposal.getParamaterNames();
199	parameterList = CharOperation.concatWith(params, ',');	199	if(params != null) {
200	parameterCount = params.length % 10; // we don't care about insane methods with >9 parameters	200	parameterList = CharOperation.concatWith(params, ',');
		201	parameterCount = params.length % 10; // we don't care about insane methods with >9 parameters
		202	} else {
		203	parameterList = new char[0];
		204	parameterCount = 0;
		205	}
201	}	206	}
202		207
203	StringBuffer buf= new StringBuffer(name.length + 2 + parameterList.length);	208	StringBuffer buf= new StringBuffer(name.length + 2 + parameterList.length);




					buffer.append(',');
					buffer.append(' ');
				}
				if (parameterTypes[i] != null && parameterTypes[i].length > 0 &&  !Arrays.equals(Signature.ANY, parameterTypes[i])) {
					buffer.append(parameterTypes[i]);
					buffer.append(' ');
				}


		// return type
		if (!methodProposal.isConstructor()) {
			char[] returnType= methodProposal.getReturnType();
			if (returnType != null && returnType.length > 0 &&  !Arrays.equals(Signature.ANY,returnType)) {
			if (!Arrays.equals(Signature.ANY,returnType))
			{
				nameBuffer.append("  "); //$NON-NLS-1$
				//@GINO: Anonymous UI Label
				org.eclipse.wst.jsdt.internal.core.util.Util.insertTypeLabel( returnType, nameBuffer );

		}

		// declaring type
		nameBuffer.append(" - "); //$NON-NLS-1$
		String declaringType= extractDeclaringTypeFQN(methodProposal);
		if(declaringType != null) {
			nameBuffer.append(" - "); //$NON-NLS-1$
			org.eclipse.wst.jsdt.internal.core.util.Util.insertTypeLabel( declaringType, nameBuffer );
		}

		return nameBuffer.toString();
	}

	private String extractDeclaringTypeFQN(CompletionProposal methodProposal) {
		char[] declaringTypeSignature= methodProposal.getDeclarationSignature();
		char[] compUnit = methodProposal.getDeclarationTypeName();
		if(compUnit != null) {
			IJavaScriptProject project = methodProposal.getJavaProject();
			JsGlobalScopeContainerInitializer init = JSDScopeUtil.findLibraryInitializer(new Path(new String(compUnit)),project);
			if(init!=null) {
				String description = init.getDescription(new Path(new String(compUnit)),project);
				if( description!=null) return  "[" +  description + "]"; //$NON-NLS-1$ //$NON-NLS-2$
			}
		}
		
		String qualifedName = null;
		if(declaringTypeSignature != null ) {
			qualifedName = SignatureUtil.stripSignatureToFQN(String.valueOf(declaringTypeSignature));
		}
		
		return qualifedName;
		// TODO remove when bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=84690 gets fixed
		if (declaringTypeSignature == null)
			return "java.lang.Object"; //$NON-NLS-1$
		return SignatureUtil.stripSignatureToFQN(String.valueOf(declaringTypeSignature));
	}

	/**




		return new ContentAssistTestsSetup(ts);
	}
	
	public void testFindFunctions_OtherFile_BeforeOpen_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
			"funcFive(Number paramOne, String paramTwo)  String", "funcSix(paramOne, String paramTwo)  Number",
			"funcSeven(String paramOne, paramTwo)  Number", "funcEight(paramOne)  String", "funcNine(paramOne)  Number"}};
		runProposalTest("test0_1.js", 0, 1, expectedProposals);
	}
	
	public void testFindFunctions_OtherFile_BeforeOpen_ExpressionStarted_1() throws Exception {
		String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
			"funcFive(Number paramOne, String paramTwo)  String", "funcSix(paramOne, String paramTwo)  Number",
			"funcSeven(String paramOne, paramTwo)  Number", "funcEight(paramOne)  String", "funcNine(paramOne)  Number"}};
		runProposalTest("test0_1.js", 2, 4, expectedProposals);
	}
	
	public void testFindFunctions_OtherFile_BeforeOpen_ExpressionStarted_2() throws Exception {
		String[][] expectedProposals = new String[][] {{"funcTwo()", "funcThree(paramOne)"}};
		runProposalTest("test0_1.js", 4, 5, expectedProposals);
	}
	
	public void testFindFunctions_ThisFile_EmptyLine() throws Exception {
		String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)"}};
		runProposalTest("test0_0.js", 55, 0, expectedProposals);
	}
	
	public void testFindFunctions_ThisFile_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
			"funcFive(Number paramOne, String paramTwo)  String", "funcSix(paramOne, String paramTwo)  Number",
			"funcSeven(String paramOne, paramTwo)  Number"}};
		runProposalTest("test0_0.js", 57, 1, expectedProposals);
	}
	
	public void testFindFunctions_ThisFile_ExpressionStarted_1() throws Exception {
		String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
			"funcFive(Number paramOne, String paramTwo)  String", "funcSix(paramOne, String paramTwo)  Number",
			"funcSeven(String paramOne, paramTwo)  Number"}};
		runProposalTest("test0_0.js", 59, 4, expectedProposals);
	}
	
	public void testFindFunctions_ThisFile_ExpressionStarted_2() throws Exception {
		String[][] expectedProposals = new String[][] {{"funcTwo()", "funcThree(paramOne)"}};
		runProposalTest("test0_0.js", 61, 5, expectedProposals);
	}
	
	public void testFindFunctions_OtherFile_AftereOpen_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
			"funcFive(Number paramOne, String paramTwo)  String", "funcSix(paramOne, String paramTwo)  Number",
			"funcSeven(String paramOne, paramTwo)  Number", "funcEight(paramOne)  String", "funcNine(paramOne)  Number"}};
		runProposalTest("test0_1.js", 0, 1, expectedProposals);
	}
	
	public void testFindFunctions_OtherFile_AfterOpen_ExpressionStarted_1() throws Exception {
		String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
			"funcFive(Number paramOne, String paramTwo)  String", "funcSix(paramOne, String paramTwo)  Number",
			"funcSeven(String paramOne, paramTwo)  Number", "funcEight(paramOne)  String", "funcNine(paramOne)  Number"}};
		runProposalTest("test0_1.js", 2, 4, expectedProposals);
	}
	
	public void testFindFunctions_OtherFile_AfterOpen_ExpressionStarted_2() throws Exception {
		String[][] expectedProposals = new String[][] {{"funcTwo()", "funcThree(paramOne)"}};
		runProposalTest("test0_1.js", 4, 5, expectedProposals);
	}
	
	public void testFindAnonymousTypeField_0() throws Exception {

		runProposalTest("test8_1.js", 8, 13, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)"}};
		runProposalTest("test2_1.js", 0, 6, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_1() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_1.js", 2, 6, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_2() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)"}};
		runProposalTest("test2_1.js", 4, 9, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_3() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_1.js", 6, 10, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_4() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_1.js", 8, 13, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_5() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_1.js", 10, 5, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_6() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_1.js", 12, 9, expectedProposals);
	}
	
	public void testFindConstructors_ThisFile_JustNew() throws Exception {
		String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)", "bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_0.js", 17, 4, expectedProposals);
	}
	
	public void testFindConstructors_ThisFile_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)"}};
		runProposalTest("test2_0.js", 19, 6, expectedProposals);
	}
	
	public void testFindConstructors_ThisFile_ExpressionStarted_1() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_0.js", 21, 6, expectedProposals);
	}
	
	public void testFindConstructors_ThisFile_ExpressionStarted_2() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)"}};
		runProposalTest("test2_0.js", 23, 9, expectedProposals);
	}
	
	public void testFindConstructors_ThisFile_ExpressionStarted_3() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_0.js", 25, 10, expectedProposals);
	}
	
	public void testFindConstructors_ThisFile_ExpressionStarted_4() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_0.js", 27, 13, expectedProposals);
	}
	
	public void testFindConstructors_ThisFile_ExpressionStarted_5() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_0.js", 29, 5, expectedProposals);
	}
	
	public void testFindConstructors_ThisFile_ExpressionStarted_6() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_0.js", 31, 9, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)"}};
		runProposalTest("test2_1.js", 0, 6, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_1() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_1.js", 2, 6, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_2() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)"}};
		runProposalTest("test2_1.js", 4, 9, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_3() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_1.js", 6, 10, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_ExpressionStarted_4() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_1.js", 8, 13, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_5() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_1.js", 10, 5, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_6() throws Exception {
		String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		runProposalTest("test2_1.js", 12, 9, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_BeforeOpen_VarDeclaration_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"MyClass1(a)", "MyClass2()"}};
		runProposalTest("test6.js", 0, 8, expectedProposals);
	}
	
	public void testFindConstructors_ThisFile_VarDeclaration_ExpressionStarted_0() throws Exception {

		runProposalTest("test5.js", 7, 8, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_AfterOpen_VarDeclaration_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"MyClass1(a)", "MyClass2()"}};
		runProposalTest("test6.js", 0, 8, expectedProposals);
	}

		runProposalTest("test7.js", 10, 11, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_BeforeOpen_ArrayReferenceDeclaration_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"test.Foo(x, y, z)"}};
		runProposalTest("test9_1.js", 0, 7, expectedProposals);
	}
	
	public void testFindConstructors_ThisFile_ArrayReferenceDeclaration_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"test.Foo(x, y, z)"}};
		runProposalTest("test9_0.js", 7, 7, expectedProposals);
	}
	
	public void testFindConstructors_OtherFile_AfterOpen_ArrayReferenceDeclaration_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"test.Foo(x, y, z)"}};
		runProposalTest("test9_1.js", 0, 7, expectedProposals);
	}
	
	public void testFindFunctionOnType_OtherFile_ExpressionStarted_0() throws Exception {
		String[][] expectedProposals = new String[][] {{"myFunc1(Number param1)", "foo"}};
		runProposalTest("test10_1.js", 1, 4, expectedProposals);
	}
	
	/**
	 * <p>Run a proposal test by opening the given file and invoking content assist for
	 * each expected proposal count at the given line number and line character

Return to bug 352160

Lines 1089-1108 Link Here

(-)src/org/eclipse/wst/jsdt/core/compiler/CharOperation.java (-5 / +6 lines)
1089	int size = length - 1;	1089	int size = length - 1;
1090	int index = length;	1090	int index = length;
1091	while (--index >= 0) {	1091	while (--index >= 0) {
1092	if (array[index].length == 0 && ignoreEmptyElements)	1092	if ((array[index] == null \|\| array[index].length == 0) && ignoreEmptyElements) {
1093	size--;	1093	size--;
1094	else	1094	} else {
1095	size += array[index].length;	1095	size += array[index] != null ? array[index].length : 0;
		1096	}
1096	}	1097	}
1097	if (size <= 0)	1098	if (size <= 0)
1098	return CharOperation.NO_CHAR;	1099	return CharOperation.NO_CHAR;
1099	char[] result = new char[size];	1100	char[] result = new char[size];
1100	index = length;	1101	index = length;
1101	while (--index >= 0) {	1102	while (--index >= 0) {
1102	length = array[index].length;	1103	length = array[index] != null ? array[index].length : 0;
1103	if (length > 0 \|\| (length == 0 && !ignoreEmptyElements)) {	1104	if (length > 0 \|\| (length == 0 && !ignoreEmptyElements)) {
1104	System.arraycopy(	1105	System.arraycopy(
1105	array[index],	1106	array[index] != null ? array[index] : NO_CHAR,
1106	0,	1107	0,
1107	result,	1108	result,
1108	(size -= length),	1109	(size -= length),

Lines 41-48 Link Here

(-)src/org/eclipse/wst/jsdt/internal/codeassist/InternalCompletionProposal.java (-10 / +10 lines)
41		41
42	protected char[] declarationPackageName;	42	protected char[] declarationPackageName;
43	protected char[] declarationTypeName;	43	protected char[] declarationTypeName;
44	protected char[] packageName;	44	protected char[] returnQualification;
45	protected char[] typeName;	45	protected char[] returnSimpleName;
46	protected char[][] parameterPackageNames;	46	protected char[][] parameterPackageNames;
47	protected char[][] parameterTypeNames;	47	protected char[][] parameterTypeNames;
48		48
Lines 143-154 Link Here
143	return this.declarationTypeName;	143	return this.declarationTypeName;
144	}	144	}
145		145
146	protected char[] getPackageName() {	146	protected char[] getReturnQualification() {
147	return this.packageName;	147	return this.returnQualification;
148	}	148	}
149		149
150	protected char[] getTypeName() {	150	protected char[] getReturnSimpleName() {
151	return this.typeName;	151	return this.returnSimpleName;
152	}	152	}
153		153
154	protected char[][] getParameterPackageNames() {	154	protected char[][] getParameterPackageNames() {
Lines 168-179 Link Here
168	this.declarationTypeName = declarationTypeName;	168	this.declarationTypeName = declarationTypeName;
169	}	169	}
170		170
171	protected void setPackageName(char[] packageName) {	171	protected void setReturnQualification(char[] packageName) {
172	this.packageName = packageName;	172	this.returnQualification = packageName;
173	}	173	}
174		174
175	protected void setTypeName(char[] typeName) {	175	protected void setReturnSimpleName(char[] typeName) {
176	this.typeName = typeName;	176	this.returnSimpleName = typeName;
177	}	177	}
178		178
179	protected void setParameterPackageNames(char[][] parameterPackageNames) {	179	protected void setParameterPackageNames(char[][] parameterPackageNames) {

Lines 333-339 Link Here

(-)src/org/eclipse/wst/jsdt/internal/codeassist/MissingTypesGuesser.java (-1 / +13 lines)
333		333
334	//do nothing	334	//do nothing
335	}	335	}
336		336
		337	/**
		338	* @see org.eclipse.wst.jsdt.internal.codeassist.ISearchRequestor#acceptMethod(char[], int, char[][], char[][], char[][], char[], char[], char[], char[], int, java.lang.String)
		339	*/
		340	public void acceptMethod(char[] signature, int parameterCount,
		341	char[][] parameterQualifications,
		342	char[][] parameterSimpleNames, char[][] parameterNames,
		343	char[] returnQualification, char[] returnSimpleName,
		344	char[] declaringQualification, char[] declaringSimpleName,
		345	int modifiers, String path) {
		346
		347	//do nothing
		348	}
337	};	349	};
338	nameEnvironment.findExactTypes(missingSimpleName, true, IJavaScriptSearchConstants.TYPE, storage);	350	nameEnvironment.findExactTypes(missingSimpleName, true, IJavaScriptSearchConstants.TYPE, storage);
339	if(results.size() == 0) return null;	351	if(results.size() == 0) return null;

Lines 303-308 Link Here

(-)src/org/eclipse/wst/jsdt/internal/codeassist/SelectionEngine.java (-8 / +14 lines)
303		303
304	// do nothing	304	// do nothing
305	}	305	}
		306
		307	/**
		308	* @see org.eclipse.wst.jsdt.internal.codeassist.ISearchRequestor#acceptMethod(char[], int, char[][], char[][], char[][], char[], char[], char[], char[], int, java.lang.String)
		309	*/
		310	public void acceptMethod(char[] signature, int parameterCount,
		311	char[][] parameterQualifications,
		312	char[][] parameterSimpleNames, char[][] parameterNames,
		313	char[] returnQualification, char[] returnSimpleName,
		314	char[] declaringQualification, char[] declaringSimpleName,
		315	int modifiers, String path) {
		316
		317	//do nothing
		318	}
306		319
307	private void acceptQualifiedTypes() {	320	private void acceptQualifiedTypes() {
308	if(this.acceptedClasses != null){	321	if(this.acceptedClasses != null){
Lines 1287-1301 Link Here
1287	localParser.inferTypes(parsedUnit,this.compilerOptions);	1300	localParser.inferTypes(parsedUnit,this.compilerOptions);
1288	return parsedUnit;	1301	return parsedUnit;
1289	} catch (AbortCompilationUnit e) {	1302	} catch (AbortCompilationUnit e) {
1290	// // at this point, currentCompilationUnitResult may not be sourceUnit, but some other	1303	throw e; // want to abort enclosing request to compile
1291	// // one requested further along to resolve sourceUnit.
1292	// if (unitResult.compilationUnit == sourceUnit) { // only report once
1293	// requestor.acceptResult(unitResult.tagAsAccepted());
1294	// } else {
1295	throw e; // want to abort enclosing request to compile
1296	// }
1297	}	1304	}
1298		1305
1299	}	1306	}
1300
1301	}	1307	}

Lines 13-18 Link Here

(-)src/org/eclipse/wst/jsdt/core/CompletionProposal.java (-31 / +36 lines)
13	import org.eclipse.core.runtime.IProgressMonitor;	13	import org.eclipse.core.runtime.IProgressMonitor;
14	import org.eclipse.wst.jsdt.core.compiler.CharOperation;	14	import org.eclipse.wst.jsdt.core.compiler.CharOperation;
15	import org.eclipse.wst.jsdt.internal.codeassist.InternalCompletionProposal;	15	import org.eclipse.wst.jsdt.internal.codeassist.InternalCompletionProposal;
		16	import org.eclipse.wst.jsdt.internal.core.util.TypeQulificationHelpers;
16		17
17	/**	18	/**
18	* Completion proposal.	19	* Completion proposal.
Lines 1402-1438 Link Here
1402	// return this.declarationPackageName;	1403	// return this.declarationPackageName;
1403	// }	1404	// }
1404	//	1405	//
1405	// /**	1406	/**
1406	// * Returns the type name of the relevant	1407	* Returns the type name of the relevant
1407	// * declaration in the context without the package fragment,	1408	* declaration in the context without the package fragment,
1408	// * or <code>null</code> if none.	1409	* or <code>null</code> if none.
1409	// * <p>	1410	* <p>
1410	// * This field is available for the following kinds of	1411	* This field is available for the following kinds of
1411	// * completion proposals:	1412	* completion proposals:
1412	// * <ul>	1413	* <ul>
1413	// * <li><code>ANONYMOUS_CLASS_DECLARATION</code> - the dot-based type name	1414	* <li><code>ANONYMOUS_CLASS_DECLARATION</code> - the dot-based type name
1414	// * of the type that is being subclassed or implemented</li>	1415	* of the type that is being subclassed or implemented</li>
1415	// * <li><code>FIELD_REF</code> - the dot-based type name	1416	* <li><code>FIELD_REF</code> - the dot-based type name
1416	// * of the type that declares the field that is referenced	1417	* of the type that declares the field that is referenced
1417	// * or an anonymous type instantiation ("new X(){}") if it is an anonymous type</li>	1418	* or an anonymous type instantiation ("new X(){}") if it is an anonymous type</li>
1418	// * <li><code>FUNCTION_REF</code> - the dot-based type name	1419	* <li><code>FUNCTION_REF</code> - the dot-based type name
1419	// * of the type that declares the method that is referenced	1420	* of the type that declares the method that is referenced
1420	// * or an anonymous type instantiation ("new X(){}") if it is an anonymous type</li>	1421	* or an anonymous type instantiation ("new X(){}") if it is an anonymous type</li>
1421	// * <li><code>FUNCTION_DECLARATION</code> - the dot-based type name	1422	* <li><code>FUNCTION_DECLARATION</code> - the dot-based type name
1422	// * of the type that declares the method that is being	1423	* of the type that declares the method that is being
1423	// * implemented or overridden</li>	1424	* implemented or overridden</li>
1424	// * </ul>	1425	* </ul>
1425	// * For kinds of completion proposals, this method returns	1426	* For kinds of completion proposals, this method returns
1426	// * <code>null</code>. Clients must not modify the array	1427	* <code>null</code>. Clients must not modify the array
1427	// * returned.	1428	* returned.
1428	// * </p>	1429	* </p>
1429	// *	1430	*
1430	// * @return the dot-based package name, or	1431	* @return the dot-based package name, or
1431	// * <code>null</code> if none	1432	* <code>null</code> if none
1432	// * @see #getDeclarationSignature()	1433	* @see #getDeclarationSignature()
1433	// * @see #getSignature()	1434	* @see #getSignature()
1434	// *	1435	*
1435	// */	1436	*/
1436	public char[] getDeclarationTypeName() {	1437	public char[] getDeclarationTypeName() {
1437	return this.declarationTypeName;	1438	return this.declarationTypeName;
1438	}	1439	}
Lines 1861-1866 Link Here
1861	public char[][] getParameterTypeNames() {	1862	public char[][] getParameterTypeNames() {
1862	return this.parameterTypeNames;	1863	return this.parameterTypeNames;
1863	}	1864	}
		1865
		1866	public char[] getReturnType() {
		1867	return TypeQulificationHelpers.createFullyQualifedTypeName(this.getReturnQualification(), this.getReturnSimpleName());
		1868	}
1864		1869
1865	/**	1870	/**
1866	* Returns the accessibility of the proposal.	1871	* Returns the accessibility of the proposal.

Lines 983-996 Link Here

(-)src/org/eclipse/wst/jsdt/core/search/SearchPattern.java (-6 lines)
983	selectorChars,	983	selectorChars,
984	declaringTypeQualification,	984	declaringTypeQualification,
985	declaringTypeSimpleName,	985	declaringTypeSimpleName,
986	declaringTypeSignature,
987	returnTypeQualification,	986	returnTypeQualification,
988	returnTypeSimpleName,	987	returnTypeSimpleName,
989	returnTypeSignature,
990	parameterTypeQualifications,	988	parameterTypeQualifications,
991	parameterTypeSimpleNames,	989	parameterTypeSimpleNames,
992	parameterTypeSignatures,
993	typeArguments,
994	matchRule);	990	matchRule);
995	}	991	}
996	}	992	}
Lines 1479-1488 Link Here
1479	declaringSimpleName,	1475	declaringSimpleName,
1480	returnQualification,	1476	returnQualification,
1481	returnSimpleName,	1477	returnSimpleName,
1482	returnSignature,
1483	parameterQualifications,	1478	parameterQualifications,
1484	parameterSimpleNames,	1479	parameterSimpleNames,
1485	parameterSignatures,
1486	method,	1480	method,
1487	matchRule);	1481	matchRule);
1488	}	1482	}

Lines 64-67 Link Here

(-)src/org/eclipse/wst/jsdt/internal/codeassist/ISearchRequestor.java (+28 lines)
64	char[][] parameterNames,	64	char[][] parameterNames,
65	String path,	65	String path,
66	AccessRestriction access);	66	AccessRestriction access);
		67
		68	/**
		69	*
		70	* TODO: IAN: doc me!
		71	*
		72	* @param signature
		73	* @param parameterCount
		74	* @param parameterQualifications
		75	* @param parameterSimpleNames
		76	* @param parameterNames
		77	* @param returnQualification
		78	* @param returnSimpleName
		79	* @param declaringQualification
		80	* @param declaringSimpleName
		81	* @param modifiers
		82	* @param path
		83	*/
		84	public void acceptMethod(char[] signature,
		85	int parameterCount,
		86	char[][] parameterQualifications,
		87	char[][] parameterSimpleNames,
		88	char[][] parameterNames,
		89	char[] returnQualification,
		90	char[] returnSimpleName,
		91	char[] declaringQualification,
		92	char[] declaringSimpleName,
		93	int modifiers,
		94	String path);
67	}	95	}

Lines 632-656 Link Here

(-)src/org/eclipse/wst/jsdt/internal/compiler/lookup/CompilationUnitScope.java (-21 / +2 lines)
632	}	632	}
633		633
634	void connectTypeHierarchy(char[][] typeNames) {	634	void connectTypeHierarchy(char[][] typeNames) {
635	// if(superType!=null) {
636	// if(superType instanceof SourceTypeBinding) {
637	// ((SourceTypeBinding)superType).classScope.buildFieldsAndMethods();
638	// ((SourceTypeBinding)superType).classScope.connectTypeHierarchy();
639	//
640	// }
641	// ReferenceBinding[] memberTypes = superType.memberTypes();
642	// ReferenceBinding[] memberFields = superType.typeVariables();
643	// FunctionBinding[] memberMethods = superType.availableMethods();
644	// for(int i=0;i<memberTypes.length;i++) {
645	// recordReference(memberTypes[i], memberTypes[i].sourceName);
646	// }
647	// }
648
649	// if(superTypeName!=null) {
650	// ReferenceBinding binding = environment.askForType(new char[][]
651	// {superTypeName});
652	// this.recordSuperTypeReference(binding);
653	// }
654	if (classScope != null)	635	if (classScope != null)
655	classScope.connectTypeHierarchy();	636	classScope.connectTypeHierarchy();
656	nextType: for (int i = 0; i < referenceContext.numberInferredTypes; i++) {	637	nextType: for (int i = 0; i < referenceContext.numberInferredTypes; i++) {
Lines 667-675 Link Here
667	continue nextType;	648	continue nextType;
668		649
669	}	650	}
670	if (inferredType.binding != null)	651	if (inferredType.binding != null && inferredType.binding.classScope != null) {
671	inferredType.binding.classScope.connectTypeHierarchy();	652	inferredType.binding.classScope.connectTypeHierarchy();
672		653	}
673	}	654	}
674	}	655	}
675	void connectTypeHierarchy() {	656	void connectTypeHierarchy() {

Lines 37-42 Link Here

(-)src/org/eclipse/wst/jsdt/internal/core/SearchableEnvironment.java (-86 / +110 lines)
37	import org.eclipse.wst.jsdt.internal.compiler.impl.ITypeRequestor;	37	import org.eclipse.wst.jsdt.internal.compiler.impl.ITypeRequestor;
38	import org.eclipse.wst.jsdt.internal.core.search.BasicSearchEngine;	38	import org.eclipse.wst.jsdt.internal.core.search.BasicSearchEngine;
39	import org.eclipse.wst.jsdt.internal.core.search.IConstructorRequestor;	39	import org.eclipse.wst.jsdt.internal.core.search.IConstructorRequestor;
		40	import org.eclipse.wst.jsdt.internal.core.search.IMethodRequestor;
40	import org.eclipse.wst.jsdt.internal.core.search.IRestrictedAccessBindingRequestor;	41	import org.eclipse.wst.jsdt.internal.core.search.IRestrictedAccessBindingRequestor;
41	import org.eclipse.wst.jsdt.internal.core.search.IRestrictedAccessTypeRequestor;	42	import org.eclipse.wst.jsdt.internal.core.search.IRestrictedAccessTypeRequestor;
42		43
Lines 168-183 Link Here
168	for (int i = 0, index = 1; i < length; i++) {	169	for (int i = 0, index = 1; i < length; i++) {
169	ISourceType otherType = (ISourceType) ((JavaElement) types[i])	170	ISourceType otherType = (ISourceType) ((JavaElement) types[i])
170	.getElementInfo();	171	.getElementInfo();
171	if (!otherType.equals(topLevelType) && index < length) // check	172	//check that the index is in bounds (see Bug 62861)
172	// that	173	if (!otherType.equals(topLevelType) && index < length) {
173	// the
174	// index
175	// is
176	// in
177	// bounds
178	// (see
179	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=62861)
180	sourceTypes[index++] = otherType;	174	sourceTypes[index++] = otherType;
		175	}
181	}	176	}
182	return new NameEnvironmentAnswer(sourceTypes,	177	return new NameEnvironmentAnswer(sourceTypes,
183	answer.restriction);	178	answer.restriction);
Lines 231-238 Link Here
231	System.arraycopy(elements, 0, units, 0, elements.length);	226	System.arraycopy(elements, 0, units, 0, elements.length);
232	return new NameEnvironmentAnswer(units,answer.restriction);	227	return new NameEnvironmentAnswer(units,answer.restriction);
233	}	228	}
234	// return new NameEnvironmentAnswer((IBinaryType) ((BinaryType)
235	// answer.type).getElementInfo(), answer.restriction);
236	}	229	}
237	return null;	230	return null;
238	}	231	}
Lines 586-626 Link Here
586	}	579	}
587	}	580	}
588		581
589	IProgressMonitor progressMonitor = new IProgressMonitor() {	582	IProgressMonitor progressMonitor = new CancelableProgressMonitor();
590	boolean isCanceled = false;	583
591
592	public void beginTask(String name, int totalWork) {
593	// implements interface method
594	}
595
596	public void done() {
597	// implements interface method
598	}
599
600	public void internalWorked(double work) {
601	// implements interface method
602	}
603
604	public boolean isCanceled() {
605	return isCanceled;
606	}
607
608	public void setCanceled(boolean value) {
609	isCanceled = value;
610	}
611
612	public void setTaskName(String name) {
613	// implements interface method
614	}
615
616	public void subTask(String name) {
617	// implements interface method
618	}
619
620	public void worked(int work) {
621	// implements interface method
622	}
623	};
624	IRestrictedAccessBindingRequestor bindingRequestor = new IRestrictedAccessBindingRequestor() {	584	IRestrictedAccessBindingRequestor bindingRequestor = new IRestrictedAccessBindingRequestor() {
625	String exclude;	585	String exclude;
626	public boolean acceptBinding(int type,int modifiers, char[] packageName,	586	public boolean acceptBinding(int type,int modifiers, char[] packageName,
Lines 674-679 Link Here
674	findTypes(new String(prefix), storage, NameLookup.ACCEPT_ALL);	634	findTypes(new String(prefix), storage, NameLookup.ACCEPT_ALL);
675	}	635	}
676	}	636	}
		637
		638	/**
		639	*
		640	* TODO: IAN: doc me!
		641	*
		642	* @param selectorPrefix
		643	* @param declaringTypeName
		644	* @param storage
		645	*/
		646	public void findMethods(char[] selectorPrefix, String declaringTypeName, final ISearchRequestor storage) {
		647
		648	//calculate the exclude path
		649	final String excludePath;
		650	if (this.unitToSkip != null && this.unitToSkip instanceof IJavaScriptElement) {
		651	excludePath = ((IJavaScriptElement)this.unitToSkip).getPath().toString();
		652	} else {
		653	excludePath = null;
		654	}
		655
		656	//create the requester
		657	IMethodRequestor requestor = new IMethodRequestor() {
		658	public void acceptMethod(char[] signature,
		659	int parameterCount,
		660	char[][] parameterQualifications, char[][] parameterSimpleNames,
		661	char[][] parameterNames,
		662	char[] returnQualification, char[] returnSimpleName,
		663	char[] declaringQualification, char[] declaringSimpleName,
		664	int modifiers,
		665	String path) {
		666
		667	if (excludePath == null \|\| !excludePath.equals(path)) {
		668	storage.acceptMethod(signature, parameterCount, parameterQualifications, parameterSimpleNames, parameterNames,
		669	returnQualification, returnSimpleName, declaringQualification, declaringSimpleName, modifiers, path);
		670	}
		671	}
		672	};
		673
		674	/* if selector specified then search for any selector with the given selector as a prefix
		675	* else search for any selector
		676	*/
		677	char[] selectorPattern;
		678	int selectorPatternMatchRule;
		679	if(selectorPrefix != null) {
		680	selectorPattern = selectorPrefix;
		681	selectorPatternMatchRule = SearchPattern.R_PREFIX_MATCH;
		682	} else {
		683	selectorPattern = new char[] {'*'};
		684	selectorPatternMatchRule = SearchPattern.R_PATTERN_MATCH;
		685	}
		686
		687	/* if a declaring type name is specified then make it the pattern for matching
		688	* else find methods not on a type
		689	*/
		690	String declaringType;
		691	if(declaringTypeName != null) {
		692	declaringType = declaringTypeName;
		693	} else {
		694	declaringType = null;
		695	}
		696
		697	//do the search
		698	new BasicSearchEngine(this.workingCopies).searchAllMethods(
		699	requestor,
		700	selectorPattern,
701	declaringType,
702	selectorPatternMatchRule,
703	this.searchScope,
704	WAIT_UNTIL_READY_TO_SEARCH,
705	new CancelableProgressMonitor());
706	}
677		707
678	/**	708	/**
679	* <p>The progress monitor is used to be able to cancel completion operations</p>	709	* <p>The progress monitor is used to be able to cancel completion operations</p>
Lines 697-729 Link Here
697	excludePath = null;	727	excludePath = null;
698	}	728	}
699		729
700	IProgressMonitor progressMonitor = new IProgressMonitor() {	730	IProgressMonitor progressMonitor = new CancelableProgressMonitor();
701	boolean isCanceled = false;
702	public void beginTask(String name, int totalWork) {
703	// implements interface method
704	}
705	public void done() {
706	// implements interface method
707	}
708	public void internalWorked(double work) {
709	// implements interface method
710	}
711	public boolean isCanceled() {
712	return this.isCanceled;
713	}
714	public void setCanceled(boolean value) {
715	this.isCanceled = value;
716	}
717	public void setTaskName(String name) {
718	// implements interface method
719	}
720	public void subTask(String name) {
721	// implements interface method
722	}
723	public void worked(int work) {
724	// implements interface method
725	}
726	};
727		731
728	IConstructorRequestor constructorRequestor = new IConstructorRequestor() {	732	IConstructorRequestor constructorRequestor = new IConstructorRequestor() {
729	/**	733	/**
Lines 817-835 Link Here
817	this.nameLookup.seekBindings(prefix, bindingType,null, true, type, requestor);	821	this.nameLookup.seekBindings(prefix, bindingType,null, true, type, requestor);
818	} else {	822	} else {
819	throw new UnimplementedException("shouldnt get here"); //$NON-NLS-1$	823	throw new UnimplementedException("shouldnt get here"); //$NON-NLS-1$
820	// String packageName = prefix.substring(0, index);
821	// JavaElementRequestor elementRequestor = new JavaElementRequestor();
822	// this.nameLookup.seekPackageFragments(packageName, false,
823	// elementRequestor);
824	// IPackageFragment[] fragments = elementRequestor
825	// .getPackageFragments();
826	// if (fragments != null) {
827	// String className = prefix.substring(index + 1);
828	// for (int i = 0, length = fragments.length; i < length; i++)
829	// if (fragments[i] != null)
830	// this.nameLookup.seekTypes(className, fragments[i],
831	// true, type, requestor);
832	// }
833	}	824	}
834	}	825	}
835	/**	826	/**
Lines 877-880 Link Here
877	{	868	{
878	nameLookup.setScriptFile(file);	869	nameLookup.setScriptFile(file);
879	}	870	}
		871
		872	/**
		873	*
		874	* TODO: IAN: doc me!
		875	*
		876	*/
		877	private static class CancelableProgressMonitor implements IProgressMonitor {
		878	boolean isCanceled = false;
		879	public void beginTask(String name, int totalWork) {
		880	// implements interface method
		881	}
		882	public void done() {
		883	// implements interface method
		884	}
		885	public void internalWorked(double work) {
		886	// implements interface method
		887	}
		888	public boolean isCanceled() {
		889	return this.isCanceled;
		890	}
		891	public void setCanceled(boolean value) {
		892	this.isCanceled = value;
		893	}
		894	public void setTaskName(String name) {
		895	// implements interface method
		896	}
		897	public void subTask(String name) {
		898	// implements interface method
		899	}
		900	public void worked(int work) {
		901	// implements interface method
		902	}
		903	}
880	}	904	}

Lines 566-572 Link Here

(-)src/org/eclipse/wst/jsdt/internal/core/search/BasicSearchEngine.java (-32 / +68 lines)
566	true,false,true,	566	true,false,true,
567	bindingName,	567	bindingName,
568	null,null,null,null,	568	null,null,null,null,
569	null,null,null,	569	null,null,
570	matchRule);	570	matchRule);
571		571
572	}	572	}
Lines 578-585 Link Here
578	searchPattern = new MethodPattern(	578	searchPattern = new MethodPattern(
579	true,false,true,	579	true,false,true,
580	bindingName,	580	bindingName,
581	null,null,null,null,
582	null,null,null,
583	matchRule);	581	matchRule);
584		582
585	}	583	}
Lines 612-633 Link Here
612		610
613	// Get working copy path(s). Store in a single string in case of only one to optimize comparison in requestor	611	// Get working copy path(s). Store in a single string in case of only one to optimize comparison in requestor
614	final HashSet workingCopyPaths = new HashSet();	612	final HashSet workingCopyPaths = new HashSet();
615	String workingCopyPath = null;
616	IJavaScriptUnit[] copies = getWorkingCopies();	613	IJavaScriptUnit[] copies = getWorkingCopies();
617	final int copiesLength = copies == null ? 0 : copies.length;	614	final int copiesLength = copies == null ? 0 : copies.length;
618	if (copies != null) {	615	if (copies != null) {
619	if (copiesLength == 1) {	616	for (int i = 0; i < copiesLength; i++) {
620	workingCopyPath = copies[0].getPath().toString();	617	IJavaScriptUnit workingCopy = copies[i];
621	} else {	618	workingCopyPaths.add(workingCopy.getPath().toString());
622	for (int i = 0; i < copiesLength; i++) {
623	IJavaScriptUnit workingCopy = copies[i];
624	workingCopyPaths.add(workingCopy.getPath().toString());
625	}
626	}	619	}
627	}	620	}
628	final String singleWkcpPath = workingCopyPath;
629		621
630	// Index requestor	622	// Index requester
631	IndexQueryRequestor searchRequestor = new IndexQueryRequestor(){	623	IndexQueryRequestor searchRequestor = new IndexQueryRequestor(){
632	public boolean acceptIndexMatch(String documentPath, SearchPattern indexRecord, SearchParticipant participant, AccessRuleSet access) {	624	public boolean acceptIndexMatch(String documentPath, SearchPattern indexRecord, SearchParticipant participant, AccessRuleSet access) {
633	// Filter unexpected types	625	// Filter unexpected types
Lines 799-822 Link Here
799	}	791	}
800	return true;	792	return true;
801	}	793	}
802	// public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope classScope) {
803	// if (match(typeSuffix, packageName, bindingName, matchRule, TypeDeclaration.kind(memberTypeDeclaration.modifiers), packageDeclaration, memberTypeDeclaration.name)) {
804	// // compute encloising type names
805	// TypeDeclaration enclosing = memberTypeDeclaration.enclosingType;
806	// char[][] enclosingTypeNames = CharOperation.NO_CHAR_CHAR;
807	// while (enclosing != null) {
808	// enclosingTypeNames = CharOperation.arrayConcat(new char[][] {enclosing.name}, enclosingTypeNames);
809	// if ((enclosing.bits & ASTNode.IsMemberType) != 0) {
810	// enclosing = enclosing.enclosingType;
811	// } else {
812	// enclosing = null;
813	// }
814	// }
815	// // report
816	// nameRequestor.acceptType(memberTypeDeclaration.modifiers, packageDeclaration, memberTypeDeclaration.name, enclosingTypeNames, path, null);
817	// }
818	// return true;
819	// }
820	public boolean visit(InferredType inferredType, BlockScope scope) {	794	public boolean visit(InferredType inferredType, BlockScope scope) {
821	if (bindingType==Binding.TYPE &&	795	if (bindingType==Binding.TYPE &&
822	match(typeSuffix, packageName, bindingName, matchRule, TypeDeclaration.kind(0), packageDeclaration, inferredType.getName())) {	796	match(typeSuffix, packageName, bindingName, matchRule, TypeDeclaration.kind(0), packageDeclaration, inferredType.getName())) {
Lines 1610-1616 Link Here
1610	record.modifiers,	1584	record.modifiers,
1611	record.declaringSimpleName,	1585	record.declaringSimpleName,
1612	record.parameterCount,	1586	record.parameterCount,
1613	record.parameterTypes,	1587	record.parameterTypeNames,
1614	record.parameterNames,	1588	record.parameterNames,
1615	documentPath,	1589	documentPath,
1616	accessRestriction);	1590	accessRestriction);
Lines 1637-1640 Link Here
1637	}	1611	}
1638	}	1612	}
1639	}	1613	}
		1614
		1615	/**
		1616	*
		1617	* TODO: IAN: doc me!
		1618	*
		1619	* @param selectorPattern
		1620	* @param declaringType
		1621	* @param selectorPatternMatchRule
		1622	* @param declaringTypepatternMatchRule
		1623	*/
		1624	public void searchAllMethods(final IMethodRequestor methodRequestor,
		1625	char[] selectorPattern, String declaringType, int selectorPatternMatchRule,
		1626	IJavaScriptSearchScope scope,
		1627	int waitingPolicy, IProgressMonitor progressMonitor) {
		1628
		1629	char[] declaringTypePatternChars = null;
		1630	if(declaringType != null && declaringType.trim().length() > 0) {
		1631	declaringTypePatternChars = declaringType.toCharArray();
		1632	}
		1633
		1634	MethodPattern pattern = new MethodPattern(true, false,
		1635	selectorPattern, declaringTypePatternChars, selectorPatternMatchRule);
		1636
		1637	IndexQueryRequestor queryRequestor = new IndexQueryRequestor() {
		1638
		1639	/**
		1640	* @see org.eclipse.wst.jsdt.internal.core.search.IndexQueryRequestor#acceptIndexMatch(java.lang.String, org.eclipse.wst.jsdt.core.search.SearchPattern, org.eclipse.wst.jsdt.core.search.SearchParticipant, org.eclipse.wst.jsdt.internal.compiler.env.AccessRuleSet)
		1641	*/
		1642	public boolean acceptIndexMatch(String documentPath,
		1643	SearchPattern indexRecord, SearchParticipant participant,
		1644	AccessRuleSet access) {
		1645
		1646	MethodPattern record = (MethodPattern)indexRecord;
		1647	methodRequestor.acceptMethod(record.selector, record.parameterCount, record.parameterQualifications, record.parameterSimpleNames,
		1648	record.parameterNames, record.returnQualification, record.returnSimpleName,
		1649	record.declaringQualification, record.declaringSimpleName, record.modifiers,
		1650	documentPath);
		1651
		1652	return true;
		1653	}
		1654	};
		1655
		1656	IndexManager indexManager = JavaModelManager.getJavaModelManager().getIndexManager();
		1657	try {
		1658	if (progressMonitor != null) {
		1659	progressMonitor.beginTask(Messages.engine_searching, 1000);
		1660	}
		1661	// Find constructor declarations from index
		1662	indexManager.performConcurrentJob(
		1663	new PatternSearchJob(
		1664	pattern,
		1665	getDefaultSearchParticipant(), // JavaScript search only
		1666	scope,
		1667	queryRequestor),
		1668	waitingPolicy,
		1669	progressMonitor == null ? null : new SubProgressMonitor(progressMonitor, 1000));
		1670	} finally {
		1671	if (progressMonitor != null) {
		1672	progressMonitor.done();
		1673	}
		1674	}
		1675	}
1640	}	1676	}

Added Link Here

(-)src/org/eclipse/wst/jsdt/internal/core/search/IMethodRequestor.java (+47 lines)
1	/*******************************************************************************
2	* Copyright (c) 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.wst.jsdt.internal.core.search;
12
13	/**
14	* TODO: IAN: doc me!
15	*
16	*/
17	public interface IMethodRequestor {
18
19	/**
20	*
21	* TODO: IAN: doc me!
22	*
23	* @param signature
24	* @param parameterCount
25	* @param parameterQualifications
26	* @param parameterSimpleNames
27	* @param parameterNames
28	* @param returnQualification
29	* @param returnSimpleName
30	* @param declaringQualification
31	* @param declaringSimpleName
32	* @param modifiers
33	* @param path
34	*/
35	public void acceptMethod(
36	char[] signature,
37	int parameterCount,
38	char[][] parameterQualifications,
39	char[][] parameterSimpleNames,
40	char[][] parameterNames,
41	char[] returnQualification,
42	char[] returnSimpleName,
43	char[] declaringQualification,
44	char[] declaringSimpleName,
45	int modifiers,
46	String path);
47	}

Lines 14-56 Link Here

(-)src/org/eclipse/wst/jsdt/internal/core/search/indexing/IIndexConstants.java (-32 / +33 lines)
14	public interface IIndexConstants {	14	public interface IIndexConstants {
15		15
16	/* index encoding */	16	/* index encoding */
17	char[] REF= "ref".toCharArray(); //$NON-NLS-1$	17	final char[] REF= "ref".toCharArray(); //$NON-NLS-1$
18	char[] METHOD_REF= "methodRef".toCharArray(); //$NON-NLS-1$	18	final char[] METHOD_REF= "methodRef".toCharArray(); //$NON-NLS-1$
19	char[] CONSTRUCTOR_REF= "constructorRef".toCharArray(); //$NON-NLS-1$	19	final char[] CONSTRUCTOR_REF= "constructorRef".toCharArray(); //$NON-NLS-1$
20	char[] SUPER_REF = "superRef".toCharArray(); //$NON-NLS-1$	20	final char[] SUPER_REF = "superRef".toCharArray(); //$NON-NLS-1$
21	char[] TYPE_DECL = "typeDecl".toCharArray(); //$NON-NLS-1$	21	final char[] TYPE_DECL = "typeDecl".toCharArray(); //$NON-NLS-1$
22	char[] METHOD_DECL= "methodDecl".toCharArray(); //$NON-NLS-1$	22	final char[] METHOD_DECL= "methodDecl".toCharArray(); //$NON-NLS-1$
23	char[] FUNCTION_DECL= "functionDecl".toCharArray(); //$NON-NLS-1$	23	final char[] FUNCTION_DECL= "functionDecl".toCharArray(); //$NON-NLS-1$
24	char[] CONSTRUCTOR_DECL= "constructorDecl".toCharArray(); //$NON-NLS-1$	24	final char[] CONSTRUCTOR_DECL= "constructorDecl".toCharArray(); //$NON-NLS-1$
25	char[] FIELD_DECL= "fieldDecl".toCharArray(); //$NON-NLS-1$	25	final char[] FIELD_DECL= "fieldDecl".toCharArray(); //$NON-NLS-1$
26	char[] VAR_DECL= "varDecl".toCharArray(); //$NON-NLS-1$	26	final char[] VAR_DECL= "varDecl".toCharArray(); //$NON-NLS-1$
27	char[] OBJECT = "Object".toCharArray(); //$NON-NLS-1$	27	final char[] OBJECT = "Object".toCharArray(); //$NON-NLS-1$
28	char[][] COUNTS=	28	final char[][] COUNTS=
29	new char[][] { new char[] {'/', '0'}, new char[] {'/', '1'}, new char[] {'/', '2'}, new char[] {'/', '3'}, new char[] {'/', '4'},	29	new char[][] { new char[] {'/', '0'}, new char[] {'/', '1'}, new char[] {'/', '2'}, new char[] {'/', '3'}, new char[] {'/', '4'},
30	new char[] {'/', '5'}, new char[] {'/', '6'}, new char[] {'/', '7'}, new char[] {'/', '8'}, new char[] {'/', '9'}	30	new char[] {'/', '5'}, new char[] {'/', '6'}, new char[] {'/', '7'}, new char[] {'/', '8'}, new char[] {'/', '9'}
31	};	31	};
32	char CLASS_SUFFIX = 'C';	32	final char CLASS_SUFFIX = 'C';
33	char TYPE_SUFFIX = 0;	33	final char TYPE_SUFFIX = 0;
34	char SEPARATOR= '/';	34	final char SEPARATOR= '/';
35	char PARAMETER_SEPARATOR= ',';	35	final char PARAMETER_SEPARATOR= ',';
36	char SECONDARY_SUFFIX = 'S';	36	final char SECONDARY_SUFFIX = 'S';
		37	final char DOT = '.';
37		38
38	char[] ONE_STAR = new char[] {'*'};	39	final char[] ONE_STAR = new char[] {'*'};
39	char[][] ONE_STAR_CHAR = new char[][] {ONE_STAR};	40	final char[][] ONE_STAR_CHAR = new char[][] {ONE_STAR};
40		41
41	// used as special marker for enclosing type name of local and anonymous classes	42	// used as special marker for enclosing type name of local and anonymous classes
42	char ZERO_CHAR = '0';	43	final char ZERO_CHAR = '0';
43	char[] ONE_ZERO = new char[] { ZERO_CHAR };	44	final char[] ONE_ZERO = new char[] { ZERO_CHAR };
44	char[][] ONE_ZERO_CHAR = new char[][] {ONE_ZERO};	45	final char[][] ONE_ZERO_CHAR = new char[][] {ONE_ZERO};
45		46
46	int PKG_REF_PATTERN = 0x0001;	47	final int PKG_REF_PATTERN = 0x0001;
47	int PKG_DECL_PATTERN = 0x0002;	48	final int PKG_DECL_PATTERN = 0x0002;
48	int TYPE_REF_PATTERN = 0x0004;	49	final int TYPE_REF_PATTERN = 0x0004;
49	int TYPE_DECL_PATTERN = 0x0008;	50	final int TYPE_DECL_PATTERN = 0x0008;
50	int SUPER_REF_PATTERN = 0x0010;	51	final int SUPER_REF_PATTERN = 0x0010;
51	int CONSTRUCTOR_PATTERN = 0x0020;	52	final int CONSTRUCTOR_PATTERN = 0x0020;
52	int FIELD_PATTERN = 0x0040;	53	final int FIELD_PATTERN = 0x0040;
53	int METHOD_PATTERN = 0x0080;	54	final int METHOD_PATTERN = 0x0080;
54	int OR_PATTERN = 0x0100;	55	final int OR_PATTERN = 0x0100;
55	int LOCAL_VAR_PATTERN = 0x0200;	56	final int LOCAL_VAR_PATTERN = 0x0200;
56	}	57	}

Lines 24-30 Link Here

(-)src/org/eclipse/wst/jsdt/internal/core/search/matching/MethodLocator.java (-29 / +2 lines)
24	import org.eclipse.wst.jsdt.core.infer.InferredMethod;	24	import org.eclipse.wst.jsdt.core.infer.InferredMethod;
25	import org.eclipse.wst.jsdt.core.search.MethodDeclarationMatch;	25	import org.eclipse.wst.jsdt.core.search.MethodDeclarationMatch;
26	import org.eclipse.wst.jsdt.core.search.SearchMatch;	26	import org.eclipse.wst.jsdt.core.search.SearchMatch;
27	import org.eclipse.wst.jsdt.core.search.SearchPattern;
28	import org.eclipse.wst.jsdt.internal.compiler.ast.ASTNode;	27	import org.eclipse.wst.jsdt.internal.compiler.ast.ASTNode;
29	import org.eclipse.wst.jsdt.internal.compiler.ast.AbstractMethodDeclaration;	28	import org.eclipse.wst.jsdt.internal.compiler.ast.AbstractMethodDeclaration;
30	import org.eclipse.wst.jsdt.internal.compiler.ast.Argument;	29	import org.eclipse.wst.jsdt.internal.compiler.ast.Argument;
Lines 146-156 Link Here
146	}	145	}
147	}	146	}
148		147
149	// Verify type arguments (do not reject if pattern has no argument as it can be an erasure match)
150	if (this.pattern.hasMethodArguments()) {
151	return IMPOSSIBLE_MATCH;
152	}
153
154	// Method declaration may match pattern	148	// Method declaration may match pattern
155	return nodeSet.addMatch(node, resolve ? POSSIBLE_MATCH : ACCURATE_MATCH);	149	return nodeSet.addMatch(node, resolve ? POSSIBLE_MATCH : ACCURATE_MATCH);
156	}	150	}
Lines 158-164 Link Here
158	if (!this.pattern.findReferences) return IMPOSSIBLE_MATCH;	152	if (!this.pattern.findReferences) return IMPOSSIBLE_MATCH;
159		153
160	if (!matchesName(this.pattern.selector, node.selector)) return IMPOSSIBLE_MATCH;	154	if (!matchesName(this.pattern.selector, node.selector)) return IMPOSSIBLE_MATCH;
161	if (this.pattern.parameterSimpleNames != null && (!this.pattern.varargs \|\| ((node.bits & ASTNode.InsideJavadoc) != 0))) {	155	if (this.pattern.parameterSimpleNames != null && ((node.bits & ASTNode.InsideJavadoc) != 0)) {
162	int length = this.pattern.parameterSimpleNames.length;	156	int length = this.pattern.parameterSimpleNames.length;
163	ASTNode[] args = node.arguments;	157	ASTNode[] args = node.arguments;
164	int argsLength = args == null ? 0 : args.length;	158	int argsLength = args == null ? 0 : args.length;
Lines 295-305 Link Here
295	}	289	}
296	}	290	}
297	void matchReportReference(MessageSend messageSend, MatchLocator locator, MethodBinding methodBinding) throws CoreException {	291	void matchReportReference(MessageSend messageSend, MatchLocator locator, MethodBinding methodBinding) throws CoreException {
298
299	if (this.pattern.hasMethodArguments()) { // binding has no type params, compatible erasure if pattern does
300	match.setRule(SearchPattern.R_ERASURE_MATCH);
301	}
302
303	// See whether it is necessary to report or not	292	// See whether it is necessary to report or not
304	if (match.getRule() == 0) return; // impossible match	293	if (match.getRule() == 0) return; // impossible match
305	boolean report = (this.isErasureMatch && match.isErasure()) \|\| (this.isEquivalentMatch && match.isEquivalent()) \|\| match.isExact();	294	boolean report = (this.isErasureMatch && match.isErasure()) \|\| (this.isEquivalentMatch && match.isEquivalent()) \|\| match.isExact();
Lines 311-333 Link Here
311	match.setLength(messageSend.sourceEnd - offset + 1);	300	match.setLength(messageSend.sourceEnd - offset + 1);
312	locator.report(match);	301	locator.report(match);
313	}	302	}
314	/*
315	* Return whether method parameters are equals to pattern ones.
316	*/
317	private boolean methodParametersEqualsPattern(MethodBinding method) {
318	TypeBinding[] methodParameters = method.parameters;
319
320	int length = methodParameters.length;
321	if (length != this.pattern.parameterSimpleNames.length) return false;
322		303
323	for (int i = 0; i < length; i++) {
324	char[] paramQualifiedName = qualifiedPattern(this.pattern.parameterSimpleNames[i], this.pattern.parameterQualifications[i]);
325	if (!CharOperation.match(paramQualifiedName, methodParameters[i].readableName(), this.isCaseSensitive)) {
326	return false;
327	}
328	}
329	return true;
330	}
331	public SearchMatch newDeclarationMatch(ASTNode reference, IJavaScriptElement element, Binding elementBinding, int accuracy, int length, MatchLocator locator) {	304	public SearchMatch newDeclarationMatch(ASTNode reference, IJavaScriptElement element, Binding elementBinding, int accuracy, int length, MatchLocator locator) {
332	if (elementBinding != null) {	305	if (elementBinding != null) {
333	MethodBinding methodBinding = (MethodBinding) elementBinding;	306	MethodBinding methodBinding = (MethodBinding) elementBinding;
Lines 615-621 Link Here
615	nodeSet.mustResolve = true;	588	nodeSet.mustResolve = true;
616	resolve = true;	589	resolve = true;
617	}	590	}
618	this.methodDeclarationsWithInvalidParam.put((AbstractMethodDeclaration)inferredMethod.getFunctionDeclaration(), null);	591	this.methodDeclarationsWithInvalidParam.put(inferredMethod.getFunctionDeclaration(), null);
619	} else {	592	} else {
620	return IMPOSSIBLE_MATCH;	593	return IMPOSSIBLE_MATCH;
621	}	594	}

Lines 26-31 Link Here

(-)src/org/eclipse/wst/jsdt/core/tests/compiler/JSDTCompilerTests.java (-76 / +3 lines)
26	import org.eclipse.wst.jsdt.core.tests.compiler.regression.UtilTest;	26	import org.eclipse.wst.jsdt.core.tests.compiler.regression.UtilTest;
27	import org.eclipse.wst.jsdt.core.tests.compiler.util.ExclusionTests;	27	import org.eclipse.wst.jsdt.core.tests.compiler.util.ExclusionTests;
28	import org.eclipse.wst.jsdt.core.tests.interpret.BasicInterpretTest;	28	import org.eclipse.wst.jsdt.core.tests.interpret.BasicInterpretTest;
		29	import org.eclipse.wst.jsdt.core.tests.search.SearchTests;
29		30
30	/**	31	/**
31	* Run all compiler regression tests	32	* Run all compiler regression tests
Lines 61-150 Link Here
61	// interpret tests	62	// interpret tests
62	standardTests.add(BasicInterpretTest.class);	63	standardTests.add(BasicInterpretTest.class);
63		64
64
65
66
67	// standardTests.addAll(JavadocTest.allTestClasses);
68		65
69	// standardTests.add(BasicErrorTests.class);
70
71	// // add all javadoc tests
72	// for (int i=0, l=JavadocTest.ALL_CLASSES.size(); i<l; i++) {
73	// standardTests.add(JavadocTest.ALL_CLASSES.get(i));
74	// }
75	//
76	TestSuite all = new TestSuite("JSDT 'Compiler' Tests");	66	TestSuite all = new TestSuite("JSDT 'Compiler' Tests");
77	all.addTest(ExclusionTests.suite());	67	all.addTest(ExclusionTests.suite());
78		68
79
80	// int possibleComplianceLevels = AbstractCompilerTest.getPossibleComplianceLevels();
81	// if ((possibleComplianceLevels & AbstractCompilerTest.F_1_3) != 0) {
82	// ArrayList tests_1_3 = (ArrayList)standardTests.clone();
83	// tests_1_3.add(Compliance_1_3.class);
84	// tests_1_3.add(JavadocTest_1_3.class);
85	// // Reset forgotten subsets tests
86	// TestCase.TESTS_PREFIX = null;
87	// TestCase.TESTS_NAMES = null;
88	// TestCase.TESTS_NUMBERS= null;
89	// TestCase.TESTS_RANGE = null;
90	// TestCase.RUN_ONLY_ID = null;
91	// all.addTest(AbstractCompilerTest.buildComplianceTestSuite(AbstractCompilerTest.COMPLIANCE_1_3, tests_1_3));
92	// }
93	// if ((possibleComplianceLevels & AbstractCompilerTest.F_1_4) != 0) {
94	// ArrayList tests_1_4 = (ArrayList)standardTests.clone();
95	// tests_1_4.add(AssertionTest.class);
96	// tests_1_4.add(Compliance_1_4.class);
97	// tests_1_4.add(ClassFileReaderTest_1_4.class);
98	// tests_1_4.add(JavadocTest_1_4.class);
99	// // Reset forgotten subsets tests
100	// TestCase.TESTS_PREFIX = null;
101	// TestCase.TESTS_NAMES = null;
102	// TestCase.TESTS_NUMBERS= null;
103	// TestCase.TESTS_RANGE = null;
104	// TestCase.RUN_ONLY_ID = null;
105	// all.addTest(AbstractCompilerTest.buildComplianceTestSuite(AbstractCompilerTest.COMPLIANCE_1_4, tests_1_4));
106	// }
107	// if ((possibleComplianceLevels & AbstractCompilerTest.F_1_5) != 0) {
108	// ArrayList tests_1_5 = (ArrayList)standardTests.clone();
109	// tests_1_5.addAll(RunComparableTests.ALL_CLASSES);
110	// tests_1_5.add(AssertionTest.class);
111	// tests_1_5.add(ClassFileReaderTest_1_5.class);
112	// tests_1_5.add(GenericTypeSignatureTest.class);
113	// tests_1_5.add(InternalHexFloatTest.class);
114	// tests_1_5.add(JavadocTest_1_5.class);
115	// tests_1_5.add(BatchCompilerTest.class);
116	// tests_1_5.add(ExternalizeStringLiterals15Test.class);
117	// // Reset forgotten subsets tests
118	// TestCase.TESTS_PREFIX = null;
119	// TestCase.TESTS_NAMES = null;
120	// TestCase.TESTS_NUMBERS= null;
121	// TestCase.TESTS_RANGE = null;
122	// TestCase.RUN_ONLY_ID = null;
123	// all.addTest(AbstractCompilerTest.buildComplianceTestSuite(AbstractCompilerTest.COMPLIANCE_1_5, tests_1_5));
124	// }
125	// if ((possibleComplianceLevels & AbstractCompilerTest.F_1_6) != 0) {
126	// ArrayList tests_1_6 = (ArrayList)standardTests.clone();
127	// tests_1_6.addAll(RunComparableTests.ALL_CLASSES);
128	// tests_1_6.add(AssertionTest.class);
129	// tests_1_6.add(ClassFileReaderTest_1_5.class);
130	// tests_1_6.add(GenericTypeSignatureTest.class);
131	// tests_1_6.add(InternalHexFloatTest.class);
132	// tests_1_6.add(JavadocTest_1_5.class);
133	// tests_1_6.add(BatchCompilerTest.class);
134	// tests_1_6.add(ExternalizeStringLiterals15Test.class);
135	// tests_1_6.add(StackMapAttributeTest.class);
136	// // Reset forgotten subsets tests
137	// TestCase.TESTS_PREFIX = null;
138	// TestCase.TESTS_NAMES = null;
139	// TestCase.TESTS_NUMBERS= null;
140	// TestCase.TESTS_RANGE = null;
141	// TestCase.RUN_ONLY_ID = null;
142	// all.addTest(AbstractCompilerTest.buildComplianceTestSuite(AbstractCompilerTest.COMPLIANCE_1_6, tests_1_6));
143	// }
144	for (Iterator iter = standardTests.iterator(); iter.hasNext();) {	69	for (Iterator iter = standardTests.iterator(); iter.hasNext();) {
145	Class test = (Class) iter.next();	70	Class test = (Class) iter.next();
146	all.addTestSuite(test);	71	all.addTestSuite(test);
147	}	72	}
		73
		74	all.addTest(SearchTests.suite());
148	return all;	75	return all;
149	}	76	}
150	}	77	}

Added Link Here

(-)src/org/eclipse/wst/jsdt/core/tests/search/SearchTests.java (+43 lines)
1	/*******************************************************************************
2	* Copyright (c) 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.wst.jsdt.core.tests.search;
12
13	import junit.framework.Test;
14	import junit.framework.TestSuite;
15
16	/**
17	* <p>Test suite for all JSDT Search Tests.<p>
18	*/
19	public class SearchTests extends TestSuite {
20	/**
21	* <p>Default constructor</p>
22	*/
23	public SearchTests() {
24	this("JavaScript Search Tests");
25	}
26
27	/**
28	* <p>Constructor with specified test name.</p>
29	*
30	* @param testName of this test suite
31	*/
32	public SearchTests(String testName) {
33	super(testName);
34	}
35
36	public static Test suite() {
37	TestSuite all = new TestSuite("JavaScript Search Tests");
38
39	all.addTestSuite(TestMethodPattern.class);
40
41	return all;
42	}
43	}

Lines 47-193 Link Here

(-)src/org/eclipse/wst/jsdt/core/tests/model/JSDTModelTests.java (-138 / +3 lines)
47	// Binding key tests	47	// Binding key tests
48	BindingKeyTests.class,	48	BindingKeyTests.class,
49		49
50	// // creation of method	50	// Working copy tests
51	// CreateMembersTests.class,
52	//
53	// // Java Naming convention tests
54	// JavaConventionTests.class,
55	//
56	// // Project & Root API unit tests
57	// JavaProjectTests.class,
58	//
59	// // Compilation unit tests
60	// CompilationUnitTests.class,
61	//
62	// // Source attachment tests
63	// AttachSourceTests.class,
64	//
65	// // Attached javadoc tests
66	// AttachedJavadocTests.class,
67	//
68	// // Java search tests
69	// RunJavaSearchTests.class,
70	//
71	// // Working copy tests
72	WorkingCopyTests.class,	51	WorkingCopyTests.class,
73	// WorkingCopyNotInClasspathTests.class,	52
74	// HierarchyOnWorkingCopiesTests.class,
75	//
76	// // test IJavaScriptModel
77	// JavaModelTests.class,
78	//
79	// // tests to check the encoding
80	// EncodingTests.class,
81	//
82	// // test class name with special names like names containing '$'
83	// ClassNameTests.class,
84	//
85	// IBuffer tests	53	// IBuffer tests
86	BufferTests.class,	54	BufferTests.class,
87	//	55
88	// // Name lookup tests
89	// NameLookupTests2.class,
90	//
91	// // Classpath and output location tests
92	// ClasspathTests.class,
93	//
94	// // Delta tests
95	// JavaElementDeltaTests.class,
96	// ExternalJarDeltaTests.class,
97	//
98	// // Java element existence tests
99	// ExistenceTests.class,
100	//
101	// // Support for "open on" feature tests
102	// ResolveTests.class,
103	// ResolveTests_1_5.class,
104	// SelectionJavadocModelTests.class,
105	//
106	// // Support for completion tests
107	RunCompletionModelTests.class,
108	//
109	// // Prefix and suffix tests
110	// NamingConventionTests.class,
111	//
112	// // Code correction tests
113	// CodeCorrectionTests.class,
114	//
115	// // Options tests
116	// OptionTests.class,
117	//
118	// // Type hierarchy tests
119	// TypeHierarchyTests.class,
120	// TypeHierarchyNotificationTests.class,
121	// TypeHierarchySerializationTests.class,
122	//
123	// // Resolve type tests
124	// TypeResolveTests.class,
125	//
126	// // Reconciler tests
127	// ReconcilerTests.class,
128	// ReconcilerStatementsRecoveryTests.class,
129	//
130	// // Copy and move operation tests
131	// CopyMoveElementsTests.class,
132	// CopyMoveResourcesTests.class,
133	//
134	// // Rename tests
135	// RenameTests.class,
136	//
137	// // Exclusion patterns tests
138	// ExclusionPatternsTests.class,
139	//
140	// // Inclusion patterns tests
141	// InclusionPatternsTests.class,
142	//
143	// // Access restrictions tests
144	// AccessRestrictionsTests.class,
145	//
146	// // Signature tests
147	// SignatureTests.class,
148	//
149	// // Variable initializers and container initializers tests
150	// ClasspathInitializerTests.class,
151	//
152	// // Java Model Factory tests
153	// FactoryTests.class,
154	//
155	// // Java Element persistence tests
156	// MementoTests.class,
157	//
158	// // Java Element sorting tests
159	// SortCompilationUnitElementsTests.class,
160	//
161	// // Package fragment root manipulation tests
162	// RootManipulationsTests.class,
163	//
164	// // Owverflowing cache tests
165	// OverflowingCacheTests.class,
166	//
167	// // Working copy owner tests
168	// WorkingCopyOwnerTests.class,
169	//
170	// // Delete Java element tests
171	// DeleteTests.class,
172	//
173	// // Local element tests
174	// LocalElementTests.class,
175	//
176	// // Get source tests
177	// GetSourceTests.class,
178	//
179	// // Create packages tests
180	// CreatePackageTests.class,
181	//
182	// // Create compilation units tests
183	// CreateCompilationUnitTests.class,
184	//
185	// // Create search participant tests
186	// SearchParticipantTests.class,
187	//
188	// // Class file tests
189	// ClassFileTests.class,
190	//
191	// Java-like extensions tests	56	// Java-like extensions tests
192	JavaScriptLikeExtensionsTests.class,	57	JavaScriptLikeExtensionsTests.class,
193		58

Removed Link Here

(-)src/org/eclipse/wst/jsdt/core/tests/model/RunCompletionModelTests.java (-100 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.wst.jsdt.core.tests.model;
12
13	import java.lang.reflect.*;
14	import java.util.ArrayList;
15	import java.util.List;
16
17	import org.eclipse.wst.jsdt.core.tests.junit.extension.TestCase;
18
19	import junit.framework.Test;
20	import junit.framework.TestSuite;
21
22	public class RunCompletionModelTests extends junit.framework.TestCase {
23
24	protected static final boolean ONLY_JAVADOC = "true".equals(System.getProperty("onlyJavadoc", "false"));
25
26	public final static List COMPLETION_SUITES = new ArrayList();
27	static {
28	if (!ONLY_JAVADOC) {
29	if(false) COMPLETION_SUITES.add(CompletionTests.class);
30	COMPLETION_SUITES.add(CompletionTests2.class);
31	if(false) COMPLETION_SUITES.add(CompletionContextTests.class);
32	if(false) COMPLETION_SUITES.add(CompletionWithMissingTypesTests.class);
33	if(false) COMPLETION_SUITES.add(CompletionWithMissingTypesTests2.class);
34	if(false) COMPLETION_SUITES.add(SnippetCompletionContextTests.class);
35	}
36	if(false) COMPLETION_SUITES.add(JavadocTypeCompletionModelTest.class);
37	if(false) COMPLETION_SUITES.add(JavadocFieldCompletionModelTest.class);
38	if(false) COMPLETION_SUITES.add(JavadocMethodCompletionModelTest.class);
39	if(false) COMPLETION_SUITES.add(JavadocPackageCompletionModelTest.class);
40	if(false) COMPLETION_SUITES.add(JavadocTextCompletionModelTest.class);
41	if(false) COMPLETION_SUITES.add(JavadocBugsCompletionModelTest.class);
42	if(false) COMPLETION_SUITES.add(JavadocCompletionContextTests.class);
43	}
44
45	public static Class[] getTestClasses() {
46	// int size = COMPLETION_SUITES.size();
47	// if (!ONLY_JAVADOC) {
48	// Class[] testClasses = new Class[size+1];
49	// COMPLETION_SUITES.toArray(testClasses);
50	// testClasses[size] = CompletionTests2.class;
51	// testClasses[size+1] = CompletionWithMissingTypesTests2.class;
52	// if(false) testClasses[size+2] = SnippetCompletionTests.class;
53	// if(false) testClasses[size+3] = SnippetCompletionTests_1_5.class;
54	// return testClasses;
55	// }
56	// Class[] testClasses = new Class[size];
57	return (Class[])COMPLETION_SUITES.toArray(new Class[COMPLETION_SUITES.size()]);
58	//return testClasses;
59	}
60
61	public RunCompletionModelTests(String name) {
62	super(name);
63	}
64
65	public static Test suite() {
66	TestSuite ts = new TestSuite(RunCompletionModelTests.class.getName());
67
68	// Store test classes with same "Completion"project
69	AbstractJavaModelCompletionTests.COMPLETION_SUITES = new ArrayList(COMPLETION_SUITES);
70
71	// Get all classes
72	Class[] allClasses = getTestClasses();
73
74	// Reset forgotten subsets of tests
75	TestCase.TESTS_PREFIX = null;
76	TestCase.TESTS_NAMES = null;
77	TestCase.TESTS_NUMBERS = null;
78	TestCase.TESTS_RANGE = null;
79	TestCase.RUN_ONLY_ID = null;
80
81	// Add all tests suite of tests
82	for (int i = 0, length = allClasses.length; i < length; i++) {
83	Class testClass = allClasses[i];
84
85	// call the suite() method and add the resulting suite to the suite
86	try {
87	Method suiteMethod = testClass.getDeclaredMethod("suite", new Class[0]); //$NON-NLS-1$
88	Test suite = (Test) suiteMethod.invoke(null, new Object[0]);
89	ts.addTest(suite);
90	} catch (IllegalAccessException e) {
91	e.printStackTrace();
92	} catch (InvocationTargetException e) {
93	e.getTargetException().printStackTrace();
94	} catch (NoSuchMethodException e) {
95	e.printStackTrace();
96	}
97	}
98	return ts;
99	}
100	}

Lines 203-209 Link Here

(-)src/org/eclipse/wst/jsdt/ui/text/java/CompletionProposalLabelProvider.java (-20 / +20 lines)
203	buffer.append(',');	203	buffer.append(',');
204	buffer.append(' ');	204	buffer.append(' ');
205	}	205	}
206	if (parameterTypes[i].length > 0 & !Arrays.equals(Signature.ANY, parameterTypes[i])) {	206	if (parameterTypes[i] != null && parameterTypes[i].length > 0 && !Arrays.equals(Signature.ANY, parameterTypes[i])) {
207	buffer.append(parameterTypes[i]);	207	buffer.append(parameterTypes[i]);
208	buffer.append(' ');	208	buffer.append(' ');
209	}	209	}
Lines 249-258 Link Here
249		249
250	// return type	250	// return type
251	if (!methodProposal.isConstructor()) {	251	if (!methodProposal.isConstructor()) {
252	// TODO remove SignatureUtil.fix83600 call when bugs are fixed	252	char[] returnType= methodProposal.getReturnType();
253	char[] returnType= createTypeDisplayName(Signature.getReturnType(methodProposal.getSignature()));	253	if (returnType != null && returnType.length > 0 && !Arrays.equals(Signature.ANY,returnType)) {
254	if (!Arrays.equals(Signature.ANY,returnType))
255	{
256	nameBuffer.append(" "); //$NON-NLS-1$	254	nameBuffer.append(" "); //$NON-NLS-1$
257	//@GINO: Anonymous UI Label	255	//@GINO: Anonymous UI Label
258	org.eclipse.wst.jsdt.internal.core.util.Util.insertTypeLabel( returnType, nameBuffer );	256	org.eclipse.wst.jsdt.internal.core.util.Util.insertTypeLabel( returnType, nameBuffer );
Lines 260-270 Link Here
260	}	258	}
261		259
262	// declaring type	260	// declaring type
263	nameBuffer.append(" - "); //$NON-NLS-1$
264	String declaringType= extractDeclaringTypeFQN(methodProposal);	261	String declaringType= extractDeclaringTypeFQN(methodProposal);
265		262	if(declaringType != null) {
266	//@GINO: Anonymous UI Label	263	nameBuffer.append(" - "); //$NON-NLS-1$
267	org.eclipse.wst.jsdt.internal.core.util.Util.insertTypeLabel( declaringType, nameBuffer );	264	org.eclipse.wst.jsdt.internal.core.util.Util.insertTypeLabel( declaringType, nameBuffer );
		265	}
268		266
269	return nameBuffer.toString();	267	return nameBuffer.toString();
270	}	268	}
Lines 338-356 Link Here
338	private String extractDeclaringTypeFQN(CompletionProposal methodProposal) {	336	private String extractDeclaringTypeFQN(CompletionProposal methodProposal) {
339	char[] declaringTypeSignature= methodProposal.getDeclarationSignature();	337	char[] declaringTypeSignature= methodProposal.getDeclarationSignature();
340	char[] compUnit = methodProposal.getDeclarationTypeName();	338	char[] compUnit = methodProposal.getDeclarationTypeName();
341	IJavaScriptProject project = methodProposal.getJavaProject();	339	if(compUnit != null) {
342	JsGlobalScopeContainerInitializer init = JSDScopeUtil.findLibraryInitializer(new Path(new String(compUnit)),project);	340	IJavaScriptProject project = methodProposal.getJavaProject();
343	if(init!=null) {	341	JsGlobalScopeContainerInitializer init = JSDScopeUtil.findLibraryInitializer(new Path(new String(compUnit)),project);
344	String description = init.getDescription(new Path(new String(compUnit)),project);	342	if(init!=null) {
345	if( description!=null) return "[" + description + "]"; //$NON-NLS-1$ //$NON-NLS-2$	343	String description = init.getDescription(new Path(new String(compUnit)),project);
346		344	if( description!=null) return "[" + description + "]"; //$NON-NLS-1$ //$NON-NLS-2$
		345	}
		346	}
		347
		348	String qualifedName = null;
		349	if(declaringTypeSignature != null ) {
		350	qualifedName = SignatureUtil.stripSignatureToFQN(String.valueOf(declaringTypeSignature));
347	}	351	}
348		352
349	// special methods may not have a declaring type: methods defined on arrays etc.	353	return qualifedName;
350	// TODO remove when bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=84690 gets fixed
351	if (declaringTypeSignature == null)
352	return "java.lang.Object"; //$NON-NLS-1$
353	return SignatureUtil.stripSignatureToFQN(String.valueOf(declaringTypeSignature));
354	}	354	}
355		355
356	/**	356	/**

Lines 103-131 Link Here

(-)src/org/eclipse/wst/jsdt/ui/tests/contentassist/ContentAssistTests.java (-32 / +119 lines)
103	return new ContentAssistTestsSetup(ts);	103	return new ContentAssistTestsSetup(ts);
104	}	104	}
105		105
		106	public void testFindFunctions_OtherFile_BeforeOpen_ExpressionStarted_0() throws Exception {
		107	String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
		108	"funcFive(Number paramOne, String paramTwo) String", "funcSix(paramOne, String paramTwo) Number",
		109	"funcSeven(String paramOne, paramTwo) Number", "funcEight(paramOne) String", "funcNine(paramOne) Number"}};
		110	runProposalTest("test0_1.js", 0, 1, expectedProposals);
		111	}
		112
		113	public void testFindFunctions_OtherFile_BeforeOpen_ExpressionStarted_1() throws Exception {
		114	String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
		115	"funcFive(Number paramOne, String paramTwo) String", "funcSix(paramOne, String paramTwo) Number",
		116	"funcSeven(String paramOne, paramTwo) Number", "funcEight(paramOne) String", "funcNine(paramOne) Number"}};
		117	runProposalTest("test0_1.js", 2, 4, expectedProposals);
		118	}
		119
		120	public void testFindFunctions_OtherFile_BeforeOpen_ExpressionStarted_2() throws Exception {
		121	String[][] expectedProposals = new String[][] {{"funcTwo()", "funcThree(paramOne)"}};
		122	runProposalTest("test0_1.js", 4, 5, expectedProposals);
		123	}
		124
106	public void testFindFunctions_ThisFile_EmptyLine() throws Exception {	125	public void testFindFunctions_ThisFile_EmptyLine() throws Exception {
107	String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)"}};	126	String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)"}};
108	runProposalTest("test1.js", 16, 0, expectedProposals);	127	runProposalTest("test0_0.js", 55, 0, expectedProposals);
109	}	128	}
110		129
111	public void testFindFunctions_ThisFile_ExpressionStarted_0() throws Exception {	130	public void testFindFunctions_ThisFile_ExpressionStarted_0() throws Exception {
112	String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)"}};	131	String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
113	runProposalTest("test1.js", 18, 3, expectedProposals);	132	"funcFive(Number paramOne, String paramTwo) String", "funcSix(paramOne, String paramTwo) Number",
		133	"funcSeven(String paramOne, paramTwo) Number"}};
		134	runProposalTest("test0_0.js", 57, 1, expectedProposals);
114	}	135	}
115		136
116	public void testFindFunctions_ThisFile_ExpressionStarted_1() throws Exception {	137	public void testFindFunctions_ThisFile_ExpressionStarted_1() throws Exception {
		138	String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
		139	"funcFive(Number paramOne, String paramTwo) String", "funcSix(paramOne, String paramTwo) Number",
		140	"funcSeven(String paramOne, paramTwo) Number"}};
		141	runProposalTest("test0_0.js", 59, 4, expectedProposals);
		142	}
		143
		144	public void testFindFunctions_ThisFile_ExpressionStarted_2() throws Exception {
117	String[][] expectedProposals = new String[][] {{"funcTwo()", "funcThree(paramOne)"}};	145	String[][] expectedProposals = new String[][] {{"funcTwo()", "funcThree(paramOne)"}};
118	runProposalTest("test1.js", 20, 5, expectedProposals);	146	runProposalTest("test0_0.js", 61, 5, expectedProposals);
119	}	147	}
120		148
121	public void testFindFunctions_OtherFile_ExpressionStarted_0() throws Exception {	149	public void testFindFunctions_OtherFile_AftereOpen_ExpressionStarted_0() throws Exception {
122	String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)"}};	150	String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
123	runProposalTest("test2.js", 0, 1, expectedProposals);	151	"funcFive(Number paramOne, String paramTwo) String", "funcSix(paramOne, String paramTwo) Number",
		152	"funcSeven(String paramOne, paramTwo) Number", "funcEight(paramOne) String", "funcNine(paramOne) Number"}};
		153	runProposalTest("test0_1.js", 0, 1, expectedProposals);
124	}	154	}
125		155
126	public void testFindFunctions_OtherFile_ExpressionStarted_1() throws Exception {	156	public void testFindFunctions_OtherFile_AfterOpen_ExpressionStarted_1() throws Exception {
		157	String[][] expectedProposals = new String[][] {{"funcOne()", "funcTwo()", "funcThree(paramOne)", "funcFour(paramOne, paramTwo)",
		158	"funcFive(Number paramOne, String paramTwo) String", "funcSix(paramOne, String paramTwo) Number",
		159	"funcSeven(String paramOne, paramTwo) Number", "funcEight(paramOne) String", "funcNine(paramOne) Number"}};
		160	runProposalTest("test0_1.js", 2, 4, expectedProposals);
		161	}
		162
		163	public void testFindFunctions_OtherFile_AfterOpen_ExpressionStarted_2() throws Exception {
127	String[][] expectedProposals = new String[][] {{"funcTwo()", "funcThree(paramOne)"}};	164	String[][] expectedProposals = new String[][] {{"funcTwo()", "funcThree(paramOne)"}};
128	runProposalTest("test2.js", 2, 5, expectedProposals);	165	runProposalTest("test0_1.js", 4, 5, expectedProposals);
129	}	166	}
130		167
131	public void testFindAnonymousTypeField_0() throws Exception {	168	public void testFindAnonymousTypeField_0() throws Exception {
Lines 148-226 Link Here
148	runProposalTest("test8_1.js", 8, 13, expectedProposals);	185	runProposalTest("test8_1.js", 8, 13, expectedProposals);
149	}	186	}
150		187
		188	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_0() throws Exception {
		189	String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)"}};
		190	runProposalTest("test2_1.js", 0, 6, expectedProposals);
		191	}
		192
		193	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_1() throws Exception {
		194	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		195	runProposalTest("test2_1.js", 2, 6, expectedProposals);
		196	}
		197
		198	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_2() throws Exception {
		199	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)"}};
		200	runProposalTest("test2_1.js", 4, 9, expectedProposals);
		201	}
		202
		203	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_3() throws Exception {
		204	String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
		205	runProposalTest("test2_1.js", 6, 10, expectedProposals);
		206	}
		207
		208	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_4() throws Exception {
		209	String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
		210	runProposalTest("test2_1.js", 8, 13, expectedProposals);
		211	}
		212
		213	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_5() throws Exception {
		214	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		215	runProposalTest("test2_1.js", 10, 5, expectedProposals);
		216	}
		217
		218	public void testFindConstructors_OtherFile_BeforeOpen_ExpressionStarted_6() throws Exception {
		219	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
		220	runProposalTest("test2_1.js", 12, 9, expectedProposals);
		221	}
		222
151	public void testFindConstructors_ThisFile_JustNew() throws Exception {	223	public void testFindConstructors_ThisFile_JustNew() throws Exception {
152	String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)", "bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};	224	String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)", "bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
153	runProposalTest("test3.js", 17, 4, expectedProposals);	225	runProposalTest("test2_0.js", 17, 4, expectedProposals);
154	}	226	}
155		227
156	public void testFindConstructors_ThisFile_ExpressionStarted_0() throws Exception {	228	public void testFindConstructors_ThisFile_ExpressionStarted_0() throws Exception {
157	String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)"}};	229	String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)"}};
158	runProposalTest("test3.js", 19, 6, expectedProposals);	230	runProposalTest("test2_0.js", 19, 6, expectedProposals);
159	}	231	}
160		232
161	public void testFindConstructors_ThisFile_ExpressionStarted_1() throws Exception {	233	public void testFindConstructors_ThisFile_ExpressionStarted_1() throws Exception {
162	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};	234	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
163	runProposalTest("test3.js", 21, 6, expectedProposals);	235	runProposalTest("test2_0.js", 21, 6, expectedProposals);
164	}	236	}
165		237
166	public void testFindConstructors_ThisFile_ExpressionStarted_2() throws Exception {	238	public void testFindConstructors_ThisFile_ExpressionStarted_2() throws Exception {
167	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)"}};	239	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)"}};
168	runProposalTest("test3.js", 23, 9, expectedProposals);	240	runProposalTest("test2_0.js", 23, 9, expectedProposals);
169	}	241	}
170		242
171	public void testFindConstructors_ThisFile_ExpressionStarted_3() throws Exception {	243	public void testFindConstructors_ThisFile_ExpressionStarted_3() throws Exception {
172	String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};	244	String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
173	runProposalTest("test3.js", 25, 10, expectedProposals);	245	runProposalTest("test2_0.js", 25, 10, expectedProposals);
174	}	246	}
175		247
176	public void testFindConstructors_ThisFile_ExpressionStarted_4() throws Exception {	248	public void testFindConstructors_ThisFile_ExpressionStarted_4() throws Exception {
177	String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};	249	String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
178	runProposalTest("test3.js", 27, 13, expectedProposals);	250	runProposalTest("test2_0.js", 27, 13, expectedProposals);
179	}	251	}
180		252
181	public void testFindConstructors_ThisFile_ExpressionStarted_5() throws Exception {	253	public void testFindConstructors_ThisFile_ExpressionStarted_5() throws Exception {
182	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};	254	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
183	runProposalTest("test3.js", 29, 5, expectedProposals);	255	runProposalTest("test2_0.js", 29, 5, expectedProposals);
184	}	256	}
185		257
186	public void testFindConstructors_ThisFile_ExpressionStarted_6() throws Exception {	258	public void testFindConstructors_ThisFile_ExpressionStarted_6() throws Exception {
187	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};	259	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
188	runProposalTest("test3.js", 31, 9, expectedProposals);	260	runProposalTest("test2_0.js", 31, 9, expectedProposals);
189	}	261	}
190		262
191	public void testFindConstructors_OtherFile_ExpressionStarted_0() throws Exception {	263	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_0() throws Exception {
192	String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)"}};	264	String[][] expectedProposals = new String[][] {{"Awesome(param1, param2)"}};
193	runProposalTest("test4.js", 0, 6, expectedProposals);	265	runProposalTest("test2_1.js", 0, 6, expectedProposals);
194	}	266	}
195		267
196	public void testFindConstructors_OtherFile_ExpressionStarted_1() throws Exception {	268	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_1() throws Exception {
197	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};	269	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
198	runProposalTest("test4.js", 2, 6, expectedProposals);	270	runProposalTest("test2_1.js", 2, 6, expectedProposals);
199	}	271	}
200		272
201	public void testFindConstructors_OtherFile_ExpressionStarted_2() throws Exception {	273	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_2() throws Exception {
202	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)"}};	274	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)"}};
203	runProposalTest("test4.js", 4, 9, expectedProposals);	275	runProposalTest("test2_1.js", 4, 9, expectedProposals);
204	}	276	}
205		277
206	public void testFindConstructors_OtherFile_ExpressionStarted_3() throws Exception {	278	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_3() throws Exception {
207	String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};	279	String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
208	runProposalTest("test4.js", 6, 10, expectedProposals);	280	runProposalTest("test2_1.js", 6, 10, expectedProposals);
209	}	281	}
210		282
211	public void testFindConstructors_OtherFile_ExpressionStarted_4() throws Exception {	283	public void testFindConstructors_OtherFile_ExpressionStarted_4() throws Exception {
212	String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};	284	String[][] expectedProposals = new String[][] {{"bar.foo.Class3(param1, param2, param3, param4)"}};
213	runProposalTest("test4.js", 8, 13, expectedProposals);	285	runProposalTest("test2_1.js", 8, 13, expectedProposals);
214	}	286	}
215		287
216	public void testFindConstructors_OtherFile_ExpressionStarted_5() throws Exception {	288	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_5() throws Exception {
217	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};	289	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
218	runProposalTest("test4.js", 10, 5, expectedProposals);	290	runProposalTest("test2_1.js", 10, 5, expectedProposals);
219	}	291	}
220		292
221	public void testFindConstructors_OtherFile_ExpressionStarted_6() throws Exception {	293	public void testFindConstructors_OtherFile_AfterOpen_ExpressionStarted_6() throws Exception {
222	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};	294	String[][] expectedProposals = new String[][] {{"bar.Class1(a, b)", "bar.Class2(c, d, e)", "bar.foo.Class3(param1, param2, param3, param4)"}};
223	runProposalTest("test4.js", 12, 9, expectedProposals);	295	runProposalTest("test2_1.js", 12, 9, expectedProposals);
		296	}
		297
		298	public void testFindConstructors_OtherFile_BeforeOpen_VarDeclaration_ExpressionStarted_0() throws Exception {
		299	String[][] expectedProposals = new String[][] {{"MyClass1(a)", "MyClass2()"}};
		300	runProposalTest("test6.js", 0, 8, expectedProposals);
224	}	301	}
225		302
226	public void testFindConstructors_ThisFile_VarDeclaration_ExpressionStarted_0() throws Exception {	303	public void testFindConstructors_ThisFile_VarDeclaration_ExpressionStarted_0() throws Exception {
Lines 228-234 Link Here
228	runProposalTest("test5.js", 7, 8, expectedProposals);	305	runProposalTest("test5.js", 7, 8, expectedProposals);
229	}	306	}
230		307
231	public void testFindConstructors_OtherFile_VarDeclaration_ExpressionStarted_0() throws Exception {	308	public void testFindConstructors_OtherFile_AfterOpen_VarDeclaration_ExpressionStarted_0() throws Exception {
232	String[][] expectedProposals = new String[][] {{"MyClass1(a)", "MyClass2()"}};	309	String[][] expectedProposals = new String[][] {{"MyClass1(a)", "MyClass2()"}};
233	runProposalTest("test6.js", 0, 8, expectedProposals);	310	runProposalTest("test6.js", 0, 8, expectedProposals);
234	}	311	}
Lines 243-258 Link Here
243	runProposalTest("test7.js", 10, 11, expectedProposals);	320	runProposalTest("test7.js", 10, 11, expectedProposals);
244	}	321	}
245		322
		323	public void testFindConstructors_OtherFile_BeforeOpen_ArrayReferenceDeclaration_ExpressionStarted_0() throws Exception {
		324	String[][] expectedProposals = new String[][] {{"test.Foo(x, y, z)"}};
		325	runProposalTest("test9_1.js", 0, 7, expectedProposals);
		326	}
		327
246	public void testFindConstructors_ThisFile_ArrayReferenceDeclaration_ExpressionStarted_0() throws Exception {	328	public void testFindConstructors_ThisFile_ArrayReferenceDeclaration_ExpressionStarted_0() throws Exception {
247	String[][] expectedProposals = new String[][] {{"test.Foo(x, y, z)"}};	329	String[][] expectedProposals = new String[][] {{"test.Foo(x, y, z)"}};
248	runProposalTest("test9_0.js", 7, 7, expectedProposals);	330	runProposalTest("test9_0.js", 7, 7, expectedProposals);
249	}	331	}
250		332
251	public void testFindConstructors_OtherFile_ArrayReferenceDeclaration_ExpressionStarted_0() throws Exception {	333	public void testFindConstructors_OtherFile_AfterOpen_ArrayReferenceDeclaration_ExpressionStarted_0() throws Exception {
252	String[][] expectedProposals = new String[][] {{"test.Foo(x, y, z)"}};	334	String[][] expectedProposals = new String[][] {{"test.Foo(x, y, z)"}};
253	runProposalTest("test9_1.js", 0, 7, expectedProposals);	335	runProposalTest("test9_1.js", 0, 7, expectedProposals);
254	}	336	}
255		337
		338	public void testFindFunctionOnType_OtherFile_ExpressionStarted_0() throws Exception {
		339	String[][] expectedProposals = new String[][] {{"myFunc1(Number param1)", "foo"}};
		340	runProposalTest("test10_1.js", 1, 4, expectedProposals);
		341	}
		342
256	/**	343	/**
257	* <p>Run a proposal test by opening the given file and invoking content assist for	344	* <p>Run a proposal test by opening the given file and invoking content assist for
258	* each expected proposal count at the given line number and line character	345	* each expected proposal count at the given line number and line character