Attachment #79464 for bug #201426




		((InternalSearchPattern)this).mustResolve = true; // always resolve (in case of a simple name reference being a potential match)
	}
	/*
	 * Instantiate a type reference pattern with additional information for generics search
	 */
	public TypeReferencePattern(char[] qualification, char[] simpleName, String typeSignature, int matchRule) {
		this(qualification, simpleName,matchRule);

		}
	}
	/*
	 * Instantiate a type reference pattern with additional information for generics search
	 */
	public TypeReferencePattern(char[] qualification, char[] simpleName, IType type, int matchRule) {
		this(qualification, simpleName,matchRule);

		if (this.simpleName != null)
			return this.simpleName;
	
		// Optimization, e.g. type reference is 'org.eclipse.jdt.core.*'
		if (this.currentSegment >= 0) 
			return this.segments[this.currentSegment];
		return null;

	protected boolean hasNextQuery() {
		if (this.segments == null) return false;
	
		// Optimization, e.g. type reference is 'org.eclipse.jdt.core.*'
		// if package has at least 4 segments, don't look at the first 2 since they are mostly
		// redundant (e.g. in 'org.eclipse.jdt.core.*' 'org.eclipse' is used all the time)
		return --this.currentSegment >= (this.segments.length >= 4 ? 2 : 0);
	}






	switch(getMatchMode()) {
		case R_EXACT_MATCH :
			if (this.isCamelCase) break;
			if (this.declaringSimpleName != null && this.parameterCount >= 0 && !this.varargs)
				key = createIndexKey(this.declaringSimpleName, this.parameterCount);
			else { // do a prefix query with the declaringSimpleName

		case R_REGEXP_MATCH :
			// TODO (frederic) implement regular expression match
			break;
		case R_CAMELCASE_MATCH:
		case R_CAMELCASE_SAME_PART_COUNT_MATCH:
			// do a prefix query with the declaringSimpleName
			break;
	}

	return index.query(getIndexCategories(), key, matchRule); // match rule is irrelevant when the key is null





	this(matchRule);

	if (this.isCaseSensitive || qualifications == null) {
		this.qualifications = qualifications;
	} else {
		int length = qualifications.length;

				// do a prefix query with the simpleName
				break;
			case R_EXACT_MATCH :
				// do a prefix query with the simpleName
				matchRule &= ~R_EXACT_MATCH;
				matchRule |= R_PREFIX_MATCH;
				key = CharOperation.append(key, SEPARATOR);
					key = CharOperation.append(key, SEPARATOR);
				}
				break;
			case R_PATTERN_MATCH :
				if (key[key.length - 1] != '*')

			case R_REGEXP_MATCH :
				// TODO (frederic) implement regular expression match
				break;
			case R_CAMELCASE_MATCH:
			case R_CAMELCASE_SAME_PART_COUNT_MATCH:
				// do a prefix query with the simpleName
				break;
		}

		EntryResult[] entries = index.query(getIndexCategories(), key, matchRule); // match rule is irrelevant when the key is null





	switch(getMatchMode()) {
		case R_EXACT_MATCH :
			if (this.isCamelCase) break;
			if (this.selector != null && this.parameterCount >= 0 && !this.varargs)
				key = createIndexKey(this.selector, this.parameterCount);
			else { // do a prefix query with the selector

		case R_REGEXP_MATCH :
			// TODO (frederic) implement regular expression match
			break;
		case R_CAMELCASE_MATCH:
		case R_CAMELCASE_SAME_PART_COUNT_MATCH:
			// do a prefix query with the selector
			break;
	}

	return index.query(getIndexCategories(), key, matchRule); // match rule is irrelevant when the key is null




			return IMPOSSIBLE_MATCH;
		}
		boolean matchFirstChar = !this.isCaseSensitive || (qualifiedPattern[0] == qualifiedTypeName[0]);
		if (this.isCamelCase) {
			if (matchFirstChar && CharOperation.camelCaseMatch(qualifiedPattern, qualifiedTypeName, (this.matchMode & SearchPattern.R_PREFIX_MATCH) != 0)) {
				return POSSIBLE_MATCH;
			}
			if (this.isCaseSensitive) return IMPOSSIBLE_MATCH;
		}
		switch (this.matchMode) {
			case SearchPattern.R_EXACT_MATCH:
			case SearchPattern.R_PREFIX_MATCH:

			case SearchPattern.R_REGEXP_MATCH :
				// TODO (frederic) implement regular expression match
				break;
			case SearchPattern.R_CAMELCASE_MATCH:
				if (matchFirstChar && CharOperation.camelCaseMatch(qualifiedPattern, qualifiedTypeName, false)) {
					return POSSIBLE_MATCH;
				}
				// if camel case does not match then try a insensitive prefix match if allowed
				if (!this.isCaseSensitive && CharOperation.prefixEquals(qualifiedPattern, qualifiedTypeName, false)) {
					return POSSIBLE_MATCH;
				}
				break;
			case SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH:
				if (matchFirstChar && CharOperation.camelCaseMatch(qualifiedPattern, qualifiedTypeName, true)) {
					return POSSIBLE_MATCH;
				}
				break;
		}
	}
	return IMPOSSIBLE_MATCH;




	// cannot include the superQualification since it may not exist in the index
	switch(getMatchMode()) {
		case R_EXACT_MATCH :
			if (this.isCamelCase) break;
			// do a prefix query with the superSimpleName
			matchRule &= ~R_EXACT_MATCH;
			matchRule |= R_PREFIX_MATCH;

		case R_REGEXP_MATCH :
			// TODO (frederic) implement regular expression match
			break;
		case R_CAMELCASE_MATCH:
		case R_CAMELCASE_SAME_PART_COUNT_MATCH:
			// do a prefix query with the superSimpleName
			break;
	}

	return index.query(getIndexCategories(), key, matchRule); // match rule is irrelevant when the key is null

Lines 29-35 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/JavaSearchPattern.java (-7 / +15 lines)
29	* Whether this pattern is case sensitive.	29	* Whether this pattern is case sensitive.
30	*/	30	*/
31	boolean isCaseSensitive;	31	boolean isCaseSensitive;
32
33	/*	32	/*
34	* Whether this pattern is camel case.	33	* Whether this pattern is camel case.
35	*/	34	*/
Lines 42-48 Link Here
42	* <li>{@link #R_PREFIX_MATCH}</li>	41	* <li>{@link #R_PREFIX_MATCH}</li>
43	* <li>{@link #R_PATTERN_MATCH}</li>	42	* <li>{@link #R_PATTERN_MATCH}</li>
44	* <li>{@link #R_REGEXP_MATCH}</li>	43	* <li>{@link #R_REGEXP_MATCH}</li>
45	* <li>{@link #R_CAMEL_CASE_MATCH}</li>	44	* <li>{@link #R_CAMELCASE_MATCH}</li>
		45	* <li>{@link #R_CAMELCASE_SAME_PART_COUNT_MATCH}</li>
46	* </ul>	46	* </ul>
47	*/	47	*/
48	int matchMode;	48	int matchMode;
Lines 55-61 Link Here
55	/**	55	/**
56	* Mask used on match rule for match mode.	56	* Mask used on match rule for match mode.
57	*/	57	*/
58	public static final int MATCH_MODE_MASK = R_EXACT_MATCH \| R_PREFIX_MATCH \| R_PATTERN_MATCH \| R_REGEXP_MATCH;	58	public static final int MATCH_MODE_MASK = R_EXACT_MATCH
		59	\| R_PREFIX_MATCH
		60	\| R_PATTERN_MATCH
		61	\| R_REGEXP_MATCH
		62	\| R_CAMELCASE_MATCH
		63	\| R_CAMELCASE_SAME_PART_COUNT_MATCH;
59		64
60	/**	65	/**
61	* Mask used on match rule for generic relevance.	66	* Mask used on match rule for generic relevance.
Lines 75-81 Link Here
75	// see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=81377	80	// see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=81377
76	int rule = getMatchRule();	81	int rule = getMatchRule();
77	this.isCaseSensitive = (rule & R_CASE_SENSITIVE) != 0;	82	this.isCaseSensitive = (rule & R_CASE_SENSITIVE) != 0;
78	this.isCamelCase = (rule & R_CAMEL_CASE_MATCH) != 0;	83	this.isCamelCase = (rule & (R_CAMELCASE_MATCH \| R_CAMELCASE_SAME_PART_COUNT_MATCH)) != 0;
79	this.matchCompatibility = rule & MATCH_COMPATIBILITY_MASK;	84	this.matchCompatibility = rule & MATCH_COMPATIBILITY_MASK;
80	this.matchMode = rule & MATCH_MODE_MASK;	85	this.matchMode = rule & MATCH_MODE_MASK;
81	}	86	}
Lines 252-260 Link Here
252	output.append(this.typeSignatures[0]);	257	output.append(this.typeSignatures[0]);
253	output.append("\", "); //$NON-NLS-1$	258	output.append("\", "); //$NON-NLS-1$
254	}	259	}
255	if (this.isCamelCase) {
256	output.append("camel case + "); //$NON-NLS-1$
257	}
258	switch(getMatchMode()) {	260	switch(getMatchMode()) {
259	case R_EXACT_MATCH :	261	case R_EXACT_MATCH :
260	output.append("exact match,"); //$NON-NLS-1$	262	output.append("exact match,"); //$NON-NLS-1$
Lines 268-273 Link Here
268	case R_REGEXP_MATCH :	270	case R_REGEXP_MATCH :
269	output.append("regexp match, "); //$NON-NLS-1$	271	output.append("regexp match, "); //$NON-NLS-1$
270	break;	272	break;
		273	case R_CAMELCASE_MATCH :
		274	output.append("camel case match, "); //$NON-NLS-1$
		275	break;
		276	case R_CAMELCASE_SAME_PART_COUNT_MATCH:
		277	output.append("camel case same part count match, "); //$NON-NLS-1$
		278	break;
271	}	279	}
272	if (isCaseSensitive())	280	if (isCaseSensitive())
273	output.append(" case sensitive"); //$NON-NLS-1$	281	output.append(" case sensitive"); //$NON-NLS-1$




protected int matchLevelForTokens(char[][] tokens) {
	if (this.pattern.pkgName == null) return ACCURATE_MATCH;

	char[] packageName = null;
	if (this.isCamelCase) {
		packageName = CharOperation.concatWith(tokens, '.');
		if (CharOperation.camelCaseMatch(this.pattern.pkgName, packageName, (this.matchMode & SearchPattern.R_PREFIX_MATCH) != 0)) {
			return POSSIBLE_MATCH;
		}
		if (this.isCaseSensitive) return IMPOSSIBLE_MATCH;
	}
	switch (this.matchMode) {
		case SearchPattern.R_EXACT_MATCH:
		case SearchPattern.R_PREFIX_MATCH:
			if (CharOperation.prefixEquals(this.pattern.pkgName, CharOperation.concatWith(tokens, '.'), this.isCaseSensitive)) {
			if (CharOperation.prefixEquals(this.pattern.pkgName, packageName, this.isCaseSensitive)) {
				return POSSIBLE_MATCH;
			}
			break;

		case SearchPattern.R_PATTERN_MATCH:
			char[] patternName = this.pattern.pkgName[this.pattern.pkgName.length - 1] == '*'
				? this.pattern.pkgName
				: CharOperation.concat(this.pattern.pkgName, ".*".toCharArray()); //$NON-NLS-1$
			if (CharOperation.match(patternName, CharOperation.concatWith(tokens, '.'), this.isCaseSensitive)) {
			if (CharOperation.match(patternName, packageName, this.isCaseSensitive)) {
				return POSSIBLE_MATCH;
			}
			break;

		case SearchPattern.R_REGEXP_MATCH :
			// TODO (frederic) implement regular expression match
			break;

		case SearchPattern.R_CAMELCASE_MATCH:
			char[] packageName = CharOperation.concatWith(tokens, '.');
			if (CharOperation.camelCaseMatch(this.pattern.pkgName, packageName, false)) {
				return POSSIBLE_MATCH;
			}
			// if camel case does not match then try a insensitive prefix match if allowed
			if (!this.isCaseSensitive && CharOperation.prefixEquals(this.pattern.pkgName, packageName, false)) {
				return POSSIBLE_MATCH;
			}
			break;

		case SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH:
			packageName = CharOperation.concatWith(tokens, '.');
			if (CharOperation.camelCaseMatch(this.pattern.pkgName, CharOperation.concatWith(tokens, '.'), true)) {
				return POSSIBLE_MATCH;
			}
			break;
	}
	return IMPOSSIBLE_MATCH;
}




			// do a prefix query with the simpleName
			break;
		case R_EXACT_MATCH :
			if (this.isCamelCase) break;
			matchRule &= ~R_EXACT_MATCH;
			if (this.simpleName != null) {
				matchRule |= R_PREFIX_MATCH;

		case R_REGEXP_MATCH :
			// TODO (frederic) implement regular expression match
			break;
		case R_CAMELCASE_MATCH:
		case R_CAMELCASE_SAME_PART_COUNT_MATCH:
			// do a prefix query with the simpleName
			break;
	}

	return index.query(getIndexCategories(), key, matchRule); // match rule is irrelevant when the key is null




// store pattern info
protected int matchMode;
protected boolean isCaseSensitive;
protected boolean isCamelCase;
protected boolean isEquivalentMatch;
protected boolean isErasureMatch;
protected boolean mustResolve;

public PatternLocator(SearchPattern pattern) {
	int matchRule = pattern.getMatchRule();
	this.isCaseSensitive = (matchRule & SearchPattern.R_CASE_SENSITIVE) != 0;
	this.isCamelCase = (matchRule & SearchPattern.R_CAMEL_CASE_MATCH) != 0;
	this.isErasureMatch = (matchRule & SearchPattern.R_ERASURE_MATCH) != 0;
	this.isEquivalentMatch = (matchRule & SearchPattern.R_EQUIVALENT_MATCH) != 0;
	this.matchMode = matchRule & JavaSearchPattern.MATCH_MODE_MASK;

	boolean matchFirstChar = !this.isCaseSensitive || pattern[0] == name[0];
	boolean sameLength = pattern.length == name.length;
	boolean canBePrefix = name.length >= pattern.length;
	if (this.isCamelCase) {
		if (matchFirstChar && CharOperation.camelCaseMatch(pattern, name, (this.matchMode & SearchPattern.R_PREFIX_MATCH) != 0)) {
			return POSSIBLE_MATCH;
		}
		if (this.isCaseSensitive) return IMPOSSIBLE_MATCH;
	}
	switch (this.matchMode) {
		case SearchPattern.R_EXACT_MATCH:
			if (sameLength && matchFirstChar && CharOperation.equals(pattern, name, this.isCaseSensitive)) {
				return POSSIBLE_MATCH | EXACT_FLAVOR;
			}
			break;

		case SearchPattern.R_PREFIX_MATCH:
			if (canBePrefix && matchFirstChar && CharOperation.prefixEquals(pattern, name, this.isCaseSensitive)) {
				return POSSIBLE_MATCH;
			}
			break;

		case SearchPattern.R_PATTERN_MATCH:
			// TODO_PERFS (frederic) Not sure this lowercase is necessary
			if (!this.isCaseSensitive) {

				return POSSIBLE_MATCH;
			}
			break;

		case SearchPattern.R_REGEXP_MATCH :
			// TODO (frederic) implement regular expression match
			break;

		case SearchPattern.R_CAMELCASE_MATCH:
			if (CharOperation.camelCaseMatch(pattern, name, false)) {
				return POSSIBLE_MATCH;
			}
			// if camel case does not match then try a insensitive prefix match if allowed
			if (!this.isCaseSensitive && CharOperation.prefixEquals(pattern, name, false)) {
				return POSSIBLE_MATCH;
			}
			break;

		case SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH:
			if (CharOperation.camelCaseMatch(pattern, name, true)) {
				return POSSIBLE_MATCH;
			}
			break;
	}
	return IMPOSSIBLE_MATCH;
}

		sourceName =  getQualifiedSourceName(binding);
	}
	if (sourceName == null) return IMPOSSIBLE_MATCH;
	switch (this.matchMode) {
		case SearchPattern.R_PREFIX_MATCH:
			if (CharOperation.prefixEquals(qualifiedPattern, sourceName, this.isCaseSensitive)) {
				return ACCURATE_MATCH;
			}
			break;
		case SearchPattern.R_CAMELCASE_MATCH:
			if ((qualifiedPattern.length>0 && sourceName.length>0 && qualifiedPattern[0] == sourceName[0])) {
				if (CharOperation.camelCaseMatch(qualifiedPattern, sourceName, false)) {
					return ACCURATE_MATCH;
				}
			}
			if (!this.isCaseSensitive && CharOperation.prefixEquals(qualifiedPattern, sourceName, false)) {
				return ACCURATE_MATCH;
			}
			break;
		case SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH:
			if ((qualifiedPattern.length>0 && sourceName.length>0 && qualifiedPattern[0] == sourceName[0])) {
				if (CharOperation.camelCaseMatch(qualifiedPattern, sourceName, true)) {
					return ACCURATE_MATCH;
				}
			}
			break;
		default:
			if (CharOperation.match(qualifiedPattern, sourceName, this.isCaseSensitive)) {
				return ACCURATE_MATCH;
			}
		}
		if (!this.isCaseSensitive && this.matchMode == SearchPattern.R_EXACT_MATCH) {
			boolean matchPattern = CharOperation.equals(qualifiedPattern, sourceName, false);
			return matchPattern ? ACCURATE_MATCH : IMPOSSIBLE_MATCH;
		}
	}
	return IMPOSSIBLE_MATCH;
	return matchPattern ? ACCURATE_MATCH : IMPOSSIBLE_MATCH;

}

/**

Lines 31-37 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/AndPattern.java (-1 / +1 lines)
31	return (combined & (R_EXACT_MATCH \| R_PREFIX_MATCH \| R_PATTERN_MATCH \| R_REGEXP_MATCH))	31	return (combined & (R_EXACT_MATCH \| R_PREFIX_MATCH \| R_PATTERN_MATCH \| R_REGEXP_MATCH))
32	\| (combined & R_CASE_SENSITIVE)	32	\| (combined & R_CASE_SENSITIVE)
33	\| compatibility	33	\| compatibility
34	\| (combined & R_CAMEL_CASE_MATCH);	34	\| (combined & (R_CAMELCASE_MATCH \| R_CAMELCASE_SAME_PART_COUNT_MATCH));
35	}	35	}
36		36
37	public AndPattern(SearchPattern leftPattern, SearchPattern rightPattern) {	37	public AndPattern(SearchPattern leftPattern, SearchPattern rightPattern) {




<ul>
<li>Added API <code>IJavaElementDelta#F_RESOLVED_CLASSPATH_CHANGED</code>. This flag is set when the resolved classpath of a Java project changes.
     This is independent from <code>IJavaElementDelta#F_CLASSPATH_CHANGED</code> which indicates that the raw classpath has changed.</li>
<li>Added API <code>SearchPattern#R_CAMELCASE_SAME_PART_COUNT_MATCH</code>.<br>
This constant tells Search Engine to report matches which have <b>exactly</b>
the same count of parts (i.e. uppercase characters) than the Camel Case pattern 
(see <a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=201426">bug 201426</a>):
<pre>
/**
 * Match rule: The search pattern contains a Camel Case expression with
 * a strict expected number of parts.
 *
 * Examples:
 * 	. 'HM' type string pattern will match 'HashMap' and 'HtmlMapper' types,
 * 	  but not 'HashMapEntry'
 * 	. 'HMap' type string pattern will still match previous 'HashMap' and
 * 	  'HtmlMapper' types, but not 'HighMagnitude'
 *
 * This rule is not intended to be combined with any other match rule. In case
 * of other match rule flags are combined with this one, then match rule validation
 * will return a modified rule in order to perform a better appropriate search request
 * (see {@link #validateMatchRule(String, int)} for more details).
 *
 * @see CharOperation#camelCaseMatch(char[], char[], boolean) for a detailed
 * explanation of Camel Case matching.
 *
 * @since 3.4
 */
public static final int R_CAMELCASE_SAME_PART_COUNT_MATCH = 0x0100;
</pre>
Note that this constant replace previous one <code>R_CAMEL_CASE_MATCH</code>
added while fixing <a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=124624">bug 124624</a>.<br>
Also note that <code>R_CAMELCASE_MATCH</code> is no longer deprecated as, finally,
Camel Case match rule flags are not supposed to be combined with other ones (e.g.
<code>R_PREFIX_MATCH</code> or <code>R_PATTERN_MATCH</code>).
</li>
<li><code>CharOperation</code> and <code>SearchPattern</code> Camel Case API methods
added while fixing <a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=124624">bug 124624</a>)
have been modified to clarify the behavior of the additional boolean parameter.<br>
This parameter now indicates whether the pattern and the name should have the same
count of parts (i.e. uppercase characters) or not:
<pre>
/**
 *...
 * CamelCase can be restricted to match only the same count of parts. When this
 * restriction is specified the given pattern and the given name must have <b>exactly</b>
 * the same number of parts (i.e. the same number of uppercase characters).
 * For instance, 'HM' , 'HaMa' and  'HMap' patterns will match 'HashMap' and
 * 'HatMapper' <b>but not</b> 'HashMapEntry'.
 *...
 * . pattern = "HM".toCharArray()
 * name = "HashMapEntry".toCharArray()
 * result => (samePartCount == false)
 *...
 * @param samePartCount flag telling whether the pattern and the name should
 * 	have the same count of parts or not.
 * 	&nbsp;&nbsp;For example:
 * 		. 'HM' type string pattern will match 'HashMap' and 'HtmlMapper' types,
 * 				but not 'HashMapEntry'
 * 		. 'HMap' type string pattern will still match previous 'HashMap' and
 * 				'HtmlMapper' types, but not 'HighMagnitude'
 * @return true if the pattern matches the given name, false otherwise
 * @since 3.4
 */
public static final boolean camelCaseMatch(char[] pattern, char[] name, boolean samePartCount) {
...
}

/**
 *...
 * CamelCase can be restricted to match only the same count of parts. When this
 * restriction is specified the given pattern and the given name must have <b>exactly</b>
 * the same number of parts (i.e. the same number of uppercase characters).
 * For instance, 'HM' , 'HaMa' and  'HMap' patterns will match 'HashMap' and
 * 'HatMapper' <b>but not</b> 'HashMapEntry'.
 *...
 * . pattern = "HM".toCharArray()
 * patternStart = 0
 * patternEnd = 2
 * name = "HashMapEntry".toCharArray()
 * nameStart = 0
 * nameEnd = 12
 * result => (samePartCount == false)
 *...
 * @param samePartCount flag telling whether the pattern and the name should
 * 	have the same count of parts or not.
 * 	&nbsp;&nbsp;For example:
 * 		. 'HM' type string pattern will match 'HashMap' and 'HtmlMapper' types,
 * 				but not 'HashMapEntry'
 * 		. 'HMap' type string pattern will still match previous 'HashMap' and
 * 				'HtmlMapper' types, but not 'HighMagnitude'
 * @return true if a sub-pattern matches the sub-part of the given name, false otherwise
 * @since 3.4
 */
public static final boolean camelCaseMatch(char[] pattern, int patternStart, int patternEnd, char[] name, int nameStart, int nameEnd, boolean prefixMatch) {
...
}
</pre>
Note that similar modifications have been done on <code>SearchPattern</code>
corresponding methods:
<pre>
public static final boolean camelCaseMatch(String pattern, String name, boolean samePartCount) {
...
}
public static final boolean camelCaseMatch(String pattern, int patternStart, int patternEnd, String name, int nameStart, int nameEnd, boolean samePartCount) {
...
}
</li>
</ul>

<h3>Problem Reports Fixed</h3>
<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=201426">201426</a>
[search] New SearchPattern constant R_CAMEL_CASE_MATCH name may be misleading for users
<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=204339">204339</a>
[compiler] Invalid length for missing package declaration in empty package-info.java file
<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=203587">203587</a>
Improve messages consistency in case of generic methods having same erasure




 * but are not always considered as leading character. For instance, both
 * 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
 * <p>
 * Using this method allows matching names to have more parts than the specified
 * pattern (see {@link #camelCaseMatch(char[], char[], boolean)}).<br>
 * For instance, 'HM' , 'HaMa' and  'HMap' patterns will match 'HashMap',
 * 'HatMapper' <b>and also</b> 'HashMapEntry'.
 * <p>
 * <pre>
 * Examples:<ol>
 * <li> pattern = "NPE".toCharArray()
 * name = "NullPointerException".toCharArray()
 * result => true</li>
 * <li> pattern = "NPE".toCharArray()
 * name = "NoPermissionException".toCharArray()
 * result => true</li>
 * <li> pattern = "NuPoEx".toCharArray()
 * name = "NullPointerException".toCharArray()
 * result => true</li>
 * <li> pattern = "NuPoEx".toCharArray()
 * name = "NoPermissionException".toCharArray()
 * result => false</li>
 * <li> pattern = "npe".toCharArray()
 * name = "NullPointerException".toCharArray()
 * result => false</li>
 * <li> pattern = "IPL3".toCharArray()
 * name = "IPerspectiveListener3".toCharArray()
 * result => true</li>
 * <li> pattern = "HM".toCharArray()
 * name = "HashMapEntry".toCharArray()
 * result => true</li>
 * <li>pattern = { 'H', M', 'a', 'p' }
 * name = { 'H', 'a', 't', 'M', 'a', 'p', 'p', 'e', 'r' }
 * result => true</li>
 * </ol></pre>
 * 

	if (name == null)
		return false; // null name cannot match

	return camelCaseMatch(pattern, 0, pattern.length, name, 0, name.length, false/*not the same count of parts*/);
}

/**

 * but are not always considered as leading character. For instance, both
 * 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
 * <p>
 * CamelCase can be restricted to match only the same count of parts. When this
 * restriction is specified the given pattern and the given name must have <b>exactly</b>
 * the same number of parts (i.e. the same number of uppercase characters).<br>
 * For instance, 'HM' , 'HaMa' and  'HMap' patterns will match 'HashMap' and
 * 'HatMapper' <b>but not</b> 'HashMapEntry'.
 * Reversely, if the prefix match parameter is <code>false</code>, then pattern
 * and name must have <b>exactly</b> the same number of parts, and their last
 * parts must be identical if they contain lowercase characters.
 * For instance, 'HMap' and 'HaMap' patterns will match 'HashMap' but neither
 * 'HashMapEntry' nor 'HatMapper'. Note that when the last part does not contain
 * lowercase characters, then the name may end with lowercase characters.
 * So, 'HM' pattern will match both 'HashMap' <b>and</b> 'HatMapper' but will not
 * match 'HashMapEntry'.
 * <p>
 * <pre>
 * Examples:<ol>
 * <li> pattern = "NPE".toCharArray()
 * name = "NullPointerException".toCharArray()
 * result => true</li>
 * <li> pattern = "NPE".toCharArray()
 * name = "NoPermissionException".toCharArray()
 * result => true</li>
 * <li> pattern = "NuPoEx".toCharArray()
 * name = "NullPointerException".toCharArray()
 * result => true</li>
 * <li> pattern = "NuPoEx".toCharArray()
 * name = "NoPermissionException".toCharArray()
 * result => false</li>
 * <li> pattern = "npe".toCharArray()
 * name = "NullPointerException".toCharArray()
 * result => false</li>
 * <li> pattern = "IPL3".toCharArray()
 * name = "IPerspectiveListener3".toCharArray()
 * result => true</li>
 * <li> pattern = "HM".toCharArray()
 * name = "HashMapEntry".toCharArray()
 * result => (samePartCount == false)</li>
 * <li> pattern = { 'H', M', 'a', 'p' }
 * name = { 'H', 'a', 't', 'M', 'a', 'p', 'p', 'e', 'r' }
 * result => (prefixMatch == true)</li>
 * </ol></pre>
 * 
 * @param pattern the given pattern
 * @param name the given name
 * @param samePartCount flag telling whether the pattern and the name should
 * 	have the same count of parts or not.<br>
 * 	&nbsp;&nbsp;For example:
 * 	<ul>
 * 		<li>'HM' type string pattern will match 'HashMap' and 'HtmlMapper' types,
 * 				but not 'HashMapEntry'</li>
 * 		<li>'HMap' type string pattern will still match previous 'HashMap' and
 * 				'HtmlMapper' types, but not 'HighMagnitude'</li>
 * 		</li>
 * 		<li>and, when it's <code>false</code>:<br>
 * 			- 'HM' type string pattern will match both   'HashMap' and 'HtmlMapper'
 * 			  and 'HashMapEntry'<br>
 * 			- 'HMap' type string pattern will match both 'HashMap' and 'HtmlMapper'
 * 			  types.
 * 		</li>
 * 	</ul>
 * @return true if the pattern matches the given name, false otherwise
 * @since 3.4
 */
public static final boolean camelCaseMatch(char[] pattern, char[] name, boolean samePartCount) {
	if (pattern == null)
		return true; // null pattern is equivalent to '*'
	if (name == null)
		return false; // null name cannot match

	return camelCaseMatch(pattern, 0, pattern.length, name, 0, name.length, samePartCount);
}

/**

 * but are not always considered as leading character. For instance, both
 * 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
 * <p>
 * Using this method allows matching names to have more parts than the specified
 * pattern (see {@link #camelCaseMatch(char[], int, int, char[], int, int, boolean)}).<br>
 * For instance, 'HM' , 'HaMa' and  'HMap' patterns will match 'HashMap',
 * 'HatMapper' <b>and also</b> 'HashMapEntry'.
 * <p>
 * Examples:
 * <ol>
 * <li> pattern = "NPE".toCharArray()
 * patternStart = 0
 * patternEnd = 3
 * name = "NullPointerException".toCharArray()
 * nameStart = 0
 * nameEnd = 20
 * result => true</li>
 * <li> pattern = "NPE".toCharArray()
 * patternStart = 0
 * patternEnd = 3
 * name = "NoPermissionException".toCharArray()
 * nameStart = 0
 * nameEnd = 21
 * result => true</li>
 * <li> pattern = "NuPoEx".toCharArray()
 * patternStart = 0
 * patternEnd = 6
 * name = "NullPointerException".toCharArray()
 * nameStart = 0
 * nameEnd = 20
 * result => true</li>
 * <li> pattern = "NuPoEx".toCharArray()
 * patternStart = 0
 * patternEnd = 6
 * name = "NoPermissionException".toCharArray()
 * nameStart = 0
 * nameEnd = 21
 * result => false</li>
 * <li> pattern = "npe".toCharArray()
 * patternStart = 0
 * patternEnd = 3
 * name = "NullPointerException".toCharArray()
 * nameStart = 0
 * nameEnd = 20
 * result => false</li>
 * <li> pattern = "IPL3".toCharArray()
 * patternStart = 0
 * patternEnd = 4
 * name = "IPerspectiveListener3".toCharArray()
 * nameStart = 0
 * nameEnd = 21
 * result => true</li>
 * <li> pattern = "HM".toCharArray()
 * patternStart = 0
 * patternEnd = 2
 * name = "HashMapEntry".toCharArray()
 * nameStart = 0
 * nameEnd = 12
 * result => true</li>
 * </li>
 * <li><pre>
 *    pattern = { 'I', 'P', 'L', '3' }
 *    patternStart = 0
 *    patternEnd = 4
 *    name = { 'I', 'P', 'e', 'r', 's', 'p', 'e', 'c', 't', 'i', 'v', 'e', 'L', 'i', 's', 't', 'e', 'n', 'e', 'r', '3' }
 *    nameStart = 0
 *    nameEnd = 21
 *    result => true
 * </pre>
 * </li>
 * </ol>
 * 
 * @param pattern the given pattern

 * @since 3.2
 */
public static final boolean camelCaseMatch(char[] pattern, int patternStart, int patternEnd, char[] name, int nameStart, int nameEnd) {
	return camelCaseMatch(pattern, patternStart, patternEnd, name, nameStart, nameEnd, false/*not the same count of parts*/);
}

/**

 * but are not always considered as leading character. For instance, both
 * 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
 * <p>
 * CamelCase can be restricted to match only the same count of parts. When this
 * restriction is specified the given pattern and the given name must have <b>exactly</b>
 * the same number of parts (i.e. the same number of uppercase characters).<br>
 * For instance, 'HM' , 'HaMa' and  'HMap' patterns will match 'HashMap' and
 * 'HatMapper' <b>but not</b> 'HashMapEntry'.
 * Reversely, if the prefix match parameter is <code>false</code>, then pattern
 * and name must have <b>exactly</b> the same number of parts, and their last
 * parts must be identical if they contain lowercase characters.
 * For instance, 'HMap' and 'HaMap' patterns will match 'HashMap' but neither
 * 'HashMapEntry' nor 'HatMapper'. Note that when the last part does not contain
 * lowercase characters, then the name may end with lowercase characters.
 * So, 'HM' pattern will match both 'HashMap' <b>and</b> 'HatMapper' but will not
 * match 'HashMapEntry'.
 * <p>
 * <pre>
 * Examples:
 * <ol>
 * <li> pattern = "NPE".toCharArray()
 * patternStart = 0
 * patternEnd = 3
 * name = "NullPointerException".toCharArray()
 * nameStart = 0
 * nameEnd = 20
 * result => true</li>
 * <li> pattern = "NPE".toCharArray()
 * patternStart = 0
 * patternEnd = 3
 * name = "NoPermissionException".toCharArray()
 * nameStart = 0
 * nameEnd = 21
 * result => true</li>
 * <li> pattern = "NuPoEx".toCharArray()
 * patternStart = 0
 * patternEnd = 6
 * name = "NullPointerException".toCharArray()
 * nameStart = 0
 * nameEnd = 20
 * result => true</li>
 * <li> pattern = "NuPoEx".toCharArray()
 * patternStart = 0
 * patternEnd = 6
 * name = "NoPermissionException".toCharArray()
 * nameStart = 0
 * nameEnd = 21
 * result => false</li>
 * <li> pattern = "npe".toCharArray()
 * patternStart = 0
 * patternEnd = 3
 * name = "NullPointerException".toCharArray()
 * nameStart = 0
 * nameEnd = 20
 * result => false</li>
 * <li> pattern = "IPL3".toCharArray()
 * patternStart = 0
 * patternEnd = 4
 * name = "IPerspectiveListener3".toCharArray()
 * nameStart = 0
 * nameEnd = 21
 * result => true</li>
 * <li> pattern = "HM".toCharArray()
 * patternStart = 0
 * patternEnd = 2
 * name = "HashMapEntry".toCharArray()
 * nameStart = 0
 * nameEnd = 12
 * result => (samePartCount == false)</li>
 * <li> pattern = { 'H', M', 'a', 'p' }
 * patternStart = 0
 * patternEnd = 4
 * name = { 'H', 'a', 't', 'M', 'a', 'p', 'p', 'e', 'r' }
 * nameStart = 0
 * nameEnd = 9
 * result => (exactMode == false)</li>
 * </ol>
 * </pre>
 * 

 * @param name the given name
 * @param nameStart the start index of the name, inclusive
 * @param nameEnd the end index of the name, exclusive
 * @param samePartCount flag telling whether the pattern and the name should
 * 	have the same count of parts or not.<br>
 * 	&nbsp;&nbsp;For example:
 * 	<ul>
 * 		<li>'HM' type string pattern will match 'HashMap' and 'HtmlMapper' types,
 * 				but not 'HashMapEntry'</li>
 * 		<li>'HMap' type string pattern will still match previous 'HashMap' and
 * 				'HtmlMapper' types, but not 'HighMagnitude'</li>
 * 		</li>
 * 		<li>and, when it's <code>false</code>:<br>
 * 			- 'HM' type string pattern will match both   'HashMap' and 'HtmlMapper'
 * 			  and 'HashMapEntry'<br>
 * 			- 'HMap' type string pattern will match both 'HashMap' and 'HtmlMapper'
 * 			  types.
 * 		</li>
 * 	</ul>
 * @return true if a sub-pattern matches the sub-part of the given name, false otherwise
 * @since 3.4
 */
public static final boolean camelCaseMatch(char[] pattern, int patternStart, int patternEnd, char[] name, int nameStart, int nameEnd, boolean samePartCount) {

	/* !!!!!!!!!! WARNING !!!!!!!!!!
	 * The content of this method has been fully copied to
	 * SearchPattern#camelCaseMatch(String, int, int, String, int, int, boolean).
	 * 
	 * So, if current method is modified, do NOT forget to copy again its content
	 * to SearchPattern corresponding method!
	 */

	if (name == null)
		return false; // null name cannot match
	if (pattern == null)

		iName++;

		if (iPattern == patternEnd) { // we have exhausted pattern...
			// it's a match if the name can have additional parts (i.e. uppercase characters) or is also exhausted
			if (!samePartCount || iName == nameEnd) return true;

			// it's not a match if last pattern character is a lowercase
			if ((patternChar = pattern[iPattern-1]) < ScannerHelper.MAX_OBVIOUS) {
				if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[patternChar] & (ScannerHelper.C_UPPER_LETTER | ScannerHelper.C_DIGIT)) == 0) {
					return false;
				}
			}
			else if (Character.isJavaIdentifierPart(patternChar) && !Character.isUpperCase(patternChar) && !Character.isDigit(patternChar)) {
				return false;
			}

			// otherwise it's a match only if the name has no more uppercase characters
			while (true) {
				if (iName == nameEnd) {
					// we have exhausted the name, so it's a match
					return true;
				}
				nameChar = name[iName];
				// test if the name character is uppercase
				if (nameChar < ScannerHelper.MAX_OBVIOUS) {
					if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar] & ScannerHelper.C_UPPER_LETTER) != 0) {
						// nameChar is uppercase, so it's not a match
						return false;
					}
				}

		}

		if (iName == nameEnd){
			// We have exhausted the name (and not the pattern), so it's not a match 
			return false;
		}





	 * 		'NullPointerException' type.</li>
	 * </ul>
	 *
	 * This rule is not intended to be combined with any other match rule. In case
	 * of other match rule flags are combined with this one, then match rule validation
	 * will return a modified rule in order to perform a better appropriate search request
	 * (see {@link #validateMatchRule(String, int)} for more details).
	 * Match rule {@link #R_PATTERN_MATCH} may also be combined but both rules
	 * will not be used simultaneously as they are mutually exclusive.
	 * Used match rule depends on whether string pattern contains specific pattern 
	 * characters (e.g. '*' or '?') or not. If it does, then only Pattern match rule
	 * will be used, otherwise only Camel Case match will be used.
	 * For example, with 'NPE' string pattern, search will only use
	 * Camel Case match rule, but with 'N*P*E*' string pattern, it will 
	 * use only Pattern match rule.
	 * <p>
	 * @see #camelCaseMatch(String, String) for a detailed explanation of Camel
	 * 	Case matching.


	/**
	 * Match rule: The search pattern contains a Camel Case expression with
	 * a strict expected number of parts.
	 * part (if it consists of multiple letters).
	 * <br>
	 * Examples:
	 * <ul>
	 * 	<li>'HM' type string pattern will match 'HashMap' and 'HtmlMapper' types,
	 * 		but not 'HashMapEntry'
	 * 	</li>
	 * 	<li>'HMap' type string pattern will still match previous 'HashMap' and
	 * 		'HtmlMapper' types, but not 'HighMagnitude'
	 * 	</li>
	 * </ul>
	 *
	 * This rule is not intended to be combined with any other match rule. In case
	 * of other match rule flags are combined with this one, then match rule validation
	 * will return a modified rule in order to perform a better appropriate search request
	 * (see {@link #validateMatchRule(String, int)} for more details).
	 * <p>
	 * This rule still can be combined to prefix match to accept prefix matches
	 * ('HashMap' pattern matching 'HashMapEntry' name). It can also be combined
	 * to case sensitive match to reject case insensitive matches ('HAMA' pattern
	 * will not match 'HashMap' name).
	 *<p>
	 * If {@link #R_PATTERN_MATCH} rule is also combined, then the real used
	 * match rule will depend on whether string pattern contains specific pattern
	 * characters (e.g. '*' or '?') or not. If it does, then only Pattern match rule will
	 * be used, otherwise only Camel Case match will be used.<br>
	 * For example, with 'NPE' string pattern, search will only use
	 * Camel Case match rule, but with 'N*P*E*' string pattern, it will 
	 * use only Pattern match rule.
	 *<p>
	 * @see CharOperation#camelCaseMatch(char[], char[], boolean) for a detailed
	 * explanation of Camel Case matching.
	 *<p>
	 * @since 3.4
	 * <p><b>WARNING: work is still in progress on this new constant due to
	 * bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=201426.<br>
	 * So, there's high chance that this constant will be renamed and its behavior
	 * slightly changed in next milestone...</b>
	 */
	public static final int R_CAMELCASE_SAME_PART_COUNT_MATCH = 0x0100;

	private static final int MODE_MASK = R_EXACT_MATCH
		| R_PREFIX_MATCH 
		| R_PATTERN_MATCH 
		| R_REGEXP_MATCH 
		| R_CAMELCASE_MATCH
		| R_CAMELCASE_SAME_PART_COUNT_MATCH;

	private int matchRule;


 * It can be exact match, prefix match, pattern match or regexp match.
 * Rule can also be combined with a case sensitivity flag.
 * 
 * @param matchRule one of following match rule
 * 	<ul>
 * 		<li>{@link #R_EXACT_MATCH}</li>
 * 		<li>{@link #R_PREFIX_MATCH}</li>
 * 		<li>{@link #R_PATTERN_MATCH}</li>
 * 		<li>{@link #R_REGEXP_MATCH}</li>
 * 		<li>{@link #R_CAMELCASE_MATCH}</li>
 * 		<li>{@link #R_CAMELCASE_SAME_PART_COUNT_MATCH}</li>
 * 	</ul>
 * 	which may be also combined with one of following flag:
 * 	<ul>
 * 		<li>{@link #R_CASE_SENSITIVE}</li>
 * 		<li>{@link #R_ERASURE_MATCH}</li>
 * 		<li>{@link #R_EQUIVALENT_MATCH}</li>
 * 	</ul>
 *		For example,
 *		<ul>
 *			<li>{@link #R_EXACT_MATCH} | {@link #R_CASE_SENSITIVE}: if an exact
 *				and case sensitive match is requested,</li>
 *			<li>{@link #R_PREFIX_MATCH} if a case insensitive prefix match is requested</li>
 *			<li>{@link #R_EXACT_MATCH} | {@link #R_ERASURE_MATCH}: if a case
 *				insensitive and erasure match is requested.</li>
 *		</ul>
 * 	Note that {@link #R_ERASURE_MATCH} or {@link #R_EQUIVALENT_MATCH} has no effect
 * 	on non-generic types/methods search.
 * 	<p>
 * 	Note also that default behavior for generic types/methods search is to find exact matches.
 */
public SearchPattern(int matchRule) {

	if ((matchRule & (R_EQUIVALENT_MATCH | R_ERASURE_MATCH )) == 0) {
		this.matchRule |= R_FULL_MATCH;
	}
	if ((matchRule & R_CAMELCASE_SAME_PART_COUNT_MATCH) != 0) {
		// reset other incompatible flags
		this.matchRule &= ~R_CAMELCASE_MATCH;
		this.matchRule &= ~R_PREFIX_MATCH;
	} else if ((matchRule & R_CAMELCASE_MATCH) != 0) {
		// reset other incompatible flags
		this.matchRule &= ~R_PREFIX_MATCH;
	}
}

/**

 * but are not always considered as leading character. For instance, both
 * 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
 * <p>
 * Using this method allows matching names to have more parts than the specified
 * pattern (see {@link #camelCaseMatch(String, String, boolean)}).<br>
 * For instance, 'HM' , 'HaMa' and  'HMap' patterns will match 'HashMap',
 * 'HatMapper' <b>and also</b> 'HashMapEntry'.
 * <p>
 * <pre>
 * Examples:

	if (name == null)
		return false; // null name cannot match

	return camelCaseMatch(pattern, 0, pattern.length(), name, 0, name.length(), false/*not the same count of parts*/);
}

/**

 * but are not always considered as leading character. For instance, both
 * 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
 * <p>
 * CamelCase can be restricted to match only the same count of parts. When this
 * restriction is specified the given pattern and the given name must have <b>exactly</b>
 * the same number of parts (i.e. the same number of uppercase characters).<br>
 * For instance, 'HM' , 'HaMa' and  'HMap' patterns will match 'HashMap' and
 * 'HatMapper' <b>but not</b> 'HashMapEntry'.
 * Reversely, if the prefix match parameter is <code>false</code>, then pattern
 * and name must have <b>exactly</b> the same number of parts, and their last
 * parts must be identical if they contain lowercase characters.
 * For instance, 'HMap' and 'HaMap' patterns will match 'HashMap' but neither
 * 'HashMapEntry' nor 'HatMapper'. Note that when the last part does not contain
 * lowercase characters, then the name may end with lowercase characters.
 * So, 'HM' pattern will match both 'HashMap' <b>and</b> 'HatMapper' but will not
 * match 'HashMapEntry'.
 * <p>
 * <pre>
 * Examples:

 *  result => true</li>
 * <li>  pattern = "HM"
 *  name = "HashMapEntry"
 *  result => (samePartCount == false)</li>
 * <li>  pattern = "HMap"
 *  name = "HatMapper"
 *  result => (prefixMatch == true)</li>
 * </ol></pre>
 * 
 * @see #camelCaseMatch(String, int, int, String, int, int, boolean) for algorithm

 * 
 * @param pattern the given pattern
 * @param name the given name
 * @param samePartCount flag telling whether the pattern and the name should
 * 	have the same count of parts or not.<br>
 * 	&nbsp;&nbsp;For example:
 * 	<ul>
 * 		<li>'HM' type string pattern will match 'HashMap' and 'HtmlMapper' types,
 * 				but not 'HashMapEntry'</li>
 * 		<li>'HMap' type string pattern will still match previous 'HashMap' and
 * 				'HtmlMapper' types, but not 'HighMagnitude'</li>
 * 			- <code>HMap</code> type string pattern will match
 * 			  <code>HashMap</code> type but not <code>HtmlMapper</code>.
 * 		</li>
 * 		<li>and, when it's <code>false</code>:<br>
 * 			- <code>HM</code> type string pattern will match both 
 * 			  <code>HashMap</code> and <code>HtmlMapper</code>
 * 			  and <code>HashMapEntry</code><br>
 * 			- <code>HMap</code> type string pattern will match both
 * 			  <code>HashMap</code> and <code>HtmlMapper</code> types.
 * 		</li>
 * 	</ul>
 * @return true if the pattern matches the given name, false otherwise
 * @since 3.4
 */
public static final boolean camelCaseMatch(String pattern, String name, boolean samePartCount) {
	if (pattern == null)
		return true; // null pattern is equivalent to '*'
	if (name == null)
		return false; // null name cannot match

	return camelCaseMatch(pattern, 0, pattern.length(), name, 0, name.length(), samePartCount);
}

/**

 * but are not always considered as leading character. For instance, both
 * 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
 * <p>
 * Using this method allows matching names to have more parts than the specified
 * pattern (see {@link #camelCaseMatch(String, int, int, String, int, int, boolean)}).<br>
 * For instance, 'HM' , 'HaMa' and  'HMap' patterns will match 'HashMap',
 * 'HatMapper' <b>and also</b> 'HashMapEntry'.
 * <p>
 * <pre>Examples:<ol>
 * <li>  pattern = "NPE"

 * @since 3.2
 */
public static final boolean camelCaseMatch(String pattern, int patternStart, int patternEnd, String name, int nameStart, int nameEnd) {
	return camelCaseMatch(pattern, patternStart, patternEnd, name, nameStart, nameEnd, false/*not the same count of parts*/);
}

/**

 * but are not always considered as leading character. For instance, both
 * 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
 * <p>
 * CamelCase can be restricted to match only the same count of parts. When this
 * restriction is specified the given pattern and the given name must have <b>exactly</b>
 * the same number of parts (i.e. the same number of uppercase characters).<br>
 * For instance, 'HM' , 'HaMa' and  'HMap' patterns will match 'HashMap' and
 * 'HatMapper' <b>but not</b> 'HashMapEntry'.
 * Reversely, if the prefix match parameter is <code>false</code>, then pattern
 * and name must have <b>exactly</b> the same number of parts, and their last
 * parts must be identical if they contain lowercase characters.
 * For instance, 'HMap' and 'HaMap' patterns will match 'HashMap' but neither
 * 'HashMapEntry' nor 'HatMapper'. Note that when the last part does not contain
 * lowercase characters, then the name may end with lowercase characters.
 * So, 'HM' pattern will match both 'HashMap' <b>and</b> 'HatMapper' but will not
 * match 'HashMapEntry'.
 * <p>
 * <pre>Examples:<ol>
 * <li>  pattern = "NPE"

 *  name = "HashMapEntry"
 *  nameStart = 0
 *  nameEnd = 12
 *  result => (samePartCount == false)</li>
 * <li>  pattern = "HMap"
 *  patternStart = 0
 *  patternEnd = 4
 *  name = "HatMapper"
 *  nameStart = 0
 *  nameEnd = 9
 *  result => (prefixMatch == true)</li>
 * </ol></pre>
 * 
 * @see CharOperation#camelCaseMatch(char[], int, int, char[], int, int, boolean)

 * @param name the given name
 * @param nameStart the start index of the name, inclusive
 * @param nameEnd the end index of the name, exclusive
 * @param samePartCount flag telling whether the pattern and the name should
 * 	have the same count of parts or not.<br>
 * 	&nbsp;&nbsp;For example:
 * 	<ul>
 * 		<li>'HM' type string pattern will match 'HashMap' and 'HtmlMapper' types,
 * 				but not 'HashMapEntry'</li>
 * 		<li>'HMap' type string pattern will still match previous 'HashMap' and
 * 				'HtmlMapper' types, but not 'HighMagnitude'</li>
 * 			- <code>HMap</code> type string pattern will match
 * 			  <code>HashMap</code> type but not <code>HtmlMapper</code>.
 * 		</li>
 * 		<li>and, when it's <code>false</code>:<br>
 * 			- <code>HM</code> type string pattern will match both 
 * 			  <code>HashMap</code> and <code>HtmlMapper</code>
 * 			  and <code>HashMapEntry</code><br>
 * 			- <code>HMap</code> type string pattern will match both
 * 			  <code>HashMap</code> and <code>HtmlMapper</code> types.
 * 		</li>
 * 	</ul>
 * @return true if a sub-pattern matches the sub-part of the given name, false otherwise
 * @since 3.4
 */
public static final boolean camelCaseMatch(String pattern, int patternStart, int patternEnd, String name, int nameStart, int nameEnd, boolean samePartCount) {

	/* !!!!!!!!!! WARNING !!!!!!!!!!
	 * The algorithm of this method has been entirely copied from
	 * CharOperation#camelCaseMatch(char[], int, int, char[], int, int, boolean).
	 * Array lengths have been replaced with call to {@link String#length()} and
	 * array direct access have been replaced with call to {@link String#charAt(int)}.
	 * 
	 * So, do NOT modify this method directly to fix any bug but modify first the
	 * corresponding CharOperation method and do the copy again to be sure that
	 * these two methods are kept synchronized.
	 */

	if (name == null)

		// first char must strictly match (upper/lower)
		return false;
	}

	char patternChar, nameChar;
	int iPattern = patternStart;
	int iName = nameStart;

		iName++;

		if (iPattern == patternEnd) { // we have exhausted pattern...
			// it's a match if the name can have additional parts (i.e. uppercase characters) or is also exhausted
			if (!samePartCount || iName == nameEnd) return true;

			// it's not a match if last pattern character is a lowercase
			if ((patternChar = pattern.charAt(iPattern-1)) < ScannerHelper.MAX_OBVIOUS) {
				if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[patternChar] & (ScannerHelper.C_UPPER_LETTER | ScannerHelper.C_DIGIT)) == 0) {
					return false;
				}
			}
			else if (Character.isJavaIdentifierPart(patternChar) && !Character.isUpperCase(patternChar) && !Character.isDigit(patternChar)) {
				return false;
			}

			// otherwise it's a match only if the name has no more uppercase characters
			while (true) {
				if (iName == nameEnd) {
					// we have exhausted the name, so it's a match
					return true;
				}
				nameChar = name.charAt(iName);
				// test if the name character is uppercase
				if (nameChar < ScannerHelper.MAX_OBVIOUS) {
					if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar] & ScannerHelper.C_UPPER_LETTER) != 0) {
						// nameChar is uppercase, so it's not a match
						return false;
					}
				}

		}

		if (iName == nameEnd){
			// We have exhausted the name (and not the pattern), so it's not a match 
			return false;
		}


 *				{@link IJavaSearchConstants#INTERFACE} is respectively used instead of {@link IJavaSearchConstants#TYPE}.
 *		</li>
 *	</ul>
 * @param matchRule one of the following match rule
 * 	<ul>
 * 		<li>{@link #R_EXACT_MATCH}</li>
 * 		<li>{@link #R_PREFIX_MATCH}</li>
 * 		<li>{@link #R_PATTERN_MATCH}</li>
 * 		<li>{@link #R_REGEXP_MATCH}</li>
 * 		<li>{@link #R_CAMELCASE_MATCH}</li>
 * 		<li>{@link #R_CAMELCASE_SAME_PART_COUNT_MATCH}</li>
 * 	</ul>
 * 	which may be also combined with one of the following flag:
 * 	<ul>
 * 		<li>{@link #R_CASE_SENSITIVE}</li>
 * 		<li>{@link #R_ERASURE_MATCH}</li>
 * 		<li>{@link #R_EQUIVALENT_MATCH}</li>
 * 	</ul>
 *		For example,
 *		<ul>
 *			<li>{@link #R_EXACT_MATCH} | {@link #R_CASE_SENSITIVE}: if an exact
 *				and case sensitive match is requested,</li>
 *			<li>{@link #R_PREFIX_MATCH} if a case insensitive prefix match is requested</li>
 *			<li>{@link #R_EXACT_MATCH} | {@link #R_ERASURE_MATCH}: if a case
 *				insensitive and erasure match is requested.</li>
 *		</ul>
 * 	Note that {@link #R_ERASURE_MATCH} or {@link #R_EQUIVALENT_MATCH} has no effect
 * 	on non-generic types/methods search.
 * 	<p>
 * 	Note also that default behavior for generic types/methods search is to find exact matches.
 * @return a search pattern on the given string pattern, or <code>null</code> if the string pattern is ill-formed
 */

 *				which directly implement/extend a given interface.
 *		</li>
 *	</ul>
 * @param matchRule one of the following match rule
 * 	<ul>
 * 		<li>{@link #R_EXACT_MATCH}</li>
 * 		<li>{@link #R_PREFIX_MATCH}</li>
 * 		<li>{@link #R_PATTERN_MATCH}</li>
 * 		<li>{@link #R_REGEXP_MATCH}</li>
 * 		<li>{@link #R_CAMELCASE_MATCH}</li>
 * 		<li>{@link #R_CAMELCASE_SAME_PART_COUNT_MATCH}</li>
 * 	</ul>
 * 	which may be also combined with one of the following flag:
 * 	<ul>
 * 		<li>{@link #R_CASE_SENSITIVE}</li>
 * 		<li>{@link #R_ERASURE_MATCH}</li>
 * 		<li>{@link #R_EQUIVALENT_MATCH}</li>
 * 	</ul>
 *		For example,
 *		<ul>
 *			<li>{@link #R_EXACT_MATCH} | {@link #R_CASE_SENSITIVE}: if an exact
 *				and case sensitive match is requested,</li>
 *			<li>{@link #R_PREFIX_MATCH} if a case insensitive prefix match is requested</li>
 *			<li>{@link #R_EXACT_MATCH} | {@link #R_ERASURE_MATCH}: if a case
 *				insensitive and erasure match is requested.</li>
 *		</ul>
 * 	Note that {@link #R_ERASURE_MATCH} or {@link #R_EQUIVALENT_MATCH} has no effect
 * 	on non-generic types/methods search.
 * 	<p>
 * 	Note also that default behavior for generic types/methods search is to find exact matches.
 * @return a search pattern for a Java element or <code>null</code> if the given element is ill-formed
 * @since 3.1

		ignoreDeclaringType = (limitTo & IJavaSearchConstants.IGNORE_DECLARING_TYPE) != 0;
		ignoreReturnType = (limitTo & IJavaSearchConstants.IGNORE_RETURN_TYPE) != 0;
	}
	if ((matchRule = validateMatchRule(null, matchRule)) == -1) {
		return null;
	}
	char[] declaringSimpleName = null;
	char[] declaringQualification = null;
	switch (element.getElementType()) {

	if (pattern == null) return true; // null is as if it was "*"
	if (name != null) {
		boolean isCaseSensitive = (this.matchRule & R_CASE_SENSITIVE) != 0;
		boolean isCamelCase = (this.matchRule & R_CAMEL_CASE_MATCH) != 0;
		int matchMode = this.matchRule & MODE_MASK;
		boolean emptyPattern = pattern.length == 0;
		if (emptyPattern && (this.matchRule & R_PREFIX_MATCH) != 0) return true;
		if (isPrefix && emptyPattern) return true;
		boolean sameLength = pattern.length == name.length;
		boolean canBePrefix = name.length >= pattern.length;
		boolean matchFirstChar = !isCaseSensitive || emptyPattern || (name.length > 0 &&  pattern[0] == name[0]);
		if (isCamelCase) {
			if (matchFirstChar && CharOperation.camelCaseMatch(pattern, name, isPrefix)) {
				return true;
			}
			if (isCaseSensitive) return false;
		}
		switch (matchMode) {
			case R_EXACT_MATCH :
				if (sameLength && matchFirstChar) {
					return CharOperation.equals(pattern, name, isCaseSensitive);
				}
				break;

			case R_PREFIX_MATCH :
				if (canBePrefix && matchFirstChar) {
					return CharOperation.prefixEquals(pattern, name, isCaseSensitive);

					pattern = CharOperation.toLowerCase(pattern);
				return CharOperation.match(pattern, name, isCaseSensitive);

			case SearchPattern.R_CAMELCASE_MATCH:
				if (matchFirstChar && CharOperation.camelCaseMatch(pattern, name, false)) {
					return true;
				}
				// only test case insensitive as CamelCase already verified prefix case sensitive
				if (!isCaseSensitive && matchFirstChar && CharOperation.prefixEquals(pattern, name, false)) {
					return true;
				}
				break;

			case SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH:
				return matchFirstChar && CharOperation.camelCaseMatch(pattern, name, true);

			case R_REGEXP_MATCH :
				// TODO (frederic) implement regular expression match
				return true;

/**
 * Validate compatibility between given string pattern and match rule.
 *<br>
 * In certain circumstances described in the table below, the returned match rule is
 * modified in order to provide a more efficient search pattern:
 * <ol>
 * 	<li>when regexp match flag is set (e.g. {@link #R_REGEXP_MATCH}),<br>
 * 		then <b>the pattern is rejected</b> as this kind of match is not supported
 * 		yet and <code>-1</code> is returned).
 * 		simultaneously set:<br>
 * 		&nbsp;=> <b>prefix match flag is reset</b>,
 * 	</li>
 * 	<li>when the string pattern has <u>no</u> pattern characters (e.g. '*' or '?') and
 * 		the pattern match flag is set (i.e. the match rule has the {@link #R_PATTERN_MATCH}
 * 		flag),<br>then <b>the pattern match flag is reset</b>. Reversely, when
 * 		the string pattern has pattern characters and the pattern match flag is
 * 		<u>not</u> set,<br>then <b>the pattern match flag is set</b>.
 * 	</li>
 * 	<li>when the pattern match flag is set with other match flags ({@link #R_PREFIX_MATCH},
 * 		{@link #R_CAMELCASE_MATCH} or {@link #R_CAMELCASE_SAME_PART_COUNT_MATCH}),<br>
 * 		then <b>all these other match flags are reset</b>.
 * 	</li>
 * 	<li>when the CamelCase match flag is set with other match flags ({@link #R_PREFIX_MATCH}
 * 		or  or {@link #R_CAMELCASE_SAME_PART_COUNT_MATCH}),<br>
 * 		then <b>all these other match flags are reset</b>. If the string pattern cannot
 * 		be a camel case pattern (see {@link #validateCamelCasePattern(String)}),<br>
 * 		then <b>the CamelCase match is replaced with a prefix match flag</b>.
 * 	</li>
 * 	<li>when the CamelCase part count match flag is set with other match flags
 * 		({@link #R_PREFIX_MATCH}),<br> then <b>all these other match flags
 * 		are reset</b>. If the string pattern cannot be a camel case pattern (see
 * 		{@link #validateCamelCasePattern(String)}),<br> then <b>the CamelCase
 * 		part count match is replaced with a prefix match flag</b>.
 * 	</li>
 * </ol>
 * <i>Note: the rules are validated in the documented order. For example, it means
 * 	that as soon as the string pattern contains one pattern character, the pattern
 * 	match flag will be set and all other match flags reset: validation of rule 2)
 * 	followed by rule 3)...</i>
 *<p>
 *
 * @param stringPattern The string pattern
 * @param matchRule The match rule

	// Verify Regexp match rule
	if ((matchRule & R_REGEXP_MATCH) != 0) {
		if ((matchRule & R_PATTERN_MATCH) != 0 || (matchRule & R_PREFIX_MATCH) != 0 || 
			(matchRule & R_CAMELCASE_MATCH) != 0 || (matchRule & R_CAMELCASE_SAME_PART_COUNT_MATCH) != 0) {
			// regexp is not supported yet
			return -1;
		}
	}

	// Verify Pattern match rule
	if (stringPattern != null) {
		int starIndex = stringPattern.indexOf('*');
		int questionIndex = stringPattern.indexOf('?');
		if (starIndex < 0 && questionIndex < 0) {
			// reset pattern match flag if any
			matchRule &= ~R_PATTERN_MATCH;
		} else {
			// force Pattern rule
			matchRule |= R_PATTERN_MATCH;
		}
	}
	if ((matchRule & R_PATTERN_MATCH) != 0) {
		// reset other incompatible flags
		matchRule &= ~R_CAMELCASE_MATCH;
		matchRule &= ~R_CAMELCASE_SAME_PART_COUNT_MATCH;
		matchRule &= ~R_PREFIX_MATCH;
		return matchRule;
	}

	// Verify Camel Case
	if ((matchRule & R_CAMELCASE_MATCH) != 0) {
		// reset other incompatible flags
		matchRule &= ~R_CAMELCASE_SAME_PART_COUNT_MATCH;
		matchRule &= ~R_PREFIX_MATCH;
		// validate camel case rule and modify it if not valid
		boolean validCamelCase = validateCamelCasePattern(stringPattern);
		for (int i=0; i<length && validCamelCase; i++) {
			char ch = stringPattern.charAt(i);
			validCamelCase = i==0 ? ScannerHelper.isJavaIdentifierStart(ch) : ScannerHelper.isJavaIdentifierPart(ch);
			// at least one uppercase character is need in CamelCase pattern
			// (see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=136313)
			if (!uppercase) uppercase = ScannerHelper.isUpperCase(ch);
		}
		validCamelCase = validCamelCase && uppercase;
		// Verify flags compatibility
		if (!validCamelCase) {
			matchRule &= ~R_CAMELCASE_MATCH;
			matchRule |= R_PREFIX_MATCH;
		}
		return matchRule;
	}
	
	// Verify Camel Case with same count of parts
	if ((matchRule & R_CAMELCASE_SAME_PART_COUNT_MATCH) != 0) {
		// reset other incompatible flags
		matchRule &= ~R_PREFIX_MATCH;
		// validate camel case rule and modify it if not valid
		boolean validCamelCase = validateCamelCasePattern(stringPattern);
		if (!validCamelCase) {
			matchRule &= ~R_CAMELCASE_SAME_PART_COUNT_MATCH;
			matchRule |= R_PREFIX_MATCH;
			// at least one uppercase character is need in CamelCase pattern
			// (see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=136313)
			if (!uppercase) uppercase = ScannerHelper.isUpperCase(ch);
		}
		validCamelCase = validCamelCase && uppercase;
		// Verify flags compatibility
		if (validCamelCase) {
			if ((matchRule & R_PREFIX_MATCH) != 0) {
				if ((matchRule & R_CASE_SENSITIVE) != 0) {
					// This is equivalent to Camel Case match rule
					matchRule &= ~R_PREFIX_MATCH;
					matchRule &= ~R_CASE_SENSITIVE;
				}
			}
		} else {
			matchRule &= ~R_CAMELCASE_MATCH;
			if ((matchRule & R_PREFIX_MATCH) == 0) {
				matchRule |= R_PREFIX_MATCH;
				matchRule |= R_CASE_SENSITIVE;
			}
		}
		return matchRule;
	}

	// Return the validated match rule (modified if necessary)
	return matchRule;
}

/*
 * Validate pattern for a camel case match rule
 * @return
 */
private static boolean validateCamelCasePattern(String stringPattern) {
	if (stringPattern == null) return true;
	// verify sting pattern validity
	int length = stringPattern.length();
	boolean validCamelCase = true;
	int uppercase = 0;
	for (int i=0; i<length && validCamelCase; i++) {
		char ch = stringPattern.charAt(i);
		validCamelCase = i==0 ? ScannerHelper.isJavaIdentifierStart(ch) : ScannerHelper.isJavaIdentifierPart(ch);
		// at least one uppercase character is need in CamelCase pattern
		// (see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=136313)
		if (ScannerHelper.isUpperCase(ch)) uppercase++;
	}
	if (validCamelCase) {
		validCamelCase = uppercase > 0;
	}
	return validCamelCase;
}

/**




	 *					May be <code>null</code>, then any type name is accepted.
	 * @param matchRule type name match rule one of
	 * <ul>
	 *		<li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type
	 *			name are the full names of the searched types.</li>
	 *		<li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type
	 *			name are prefixes of the names of the searched types.</li>
	 *		<li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and
	 *			type name contain wild-cards.</li>
	 *		<li>{@link SearchPattern#R_CAMELCASE_MATCH} if the type name is a
	 *			camel case of the searched types name.</li>
	 *		<li>{@link SearchPattern#R_CAMELCASE_SAME_PART_COUNT_MATCH}
	 *			if the type name is a camel case with same part count of the searched
	 *			types name.</li>
	 * </ul>
	 * combined with {@link SearchPattern#R_CASE_SENSITIVE},
	 *   e.g. {@link SearchPattern#R_EXACT_MATCH} | {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested, 

	 *					May be <code>null</code>, then any type name is accepted.
	 * @param packageMatchRule one of
	 * <ul>
	 *		<li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type
	 *			name are the full names of the searched types.</li>
	 *		<li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type
	 *			name are prefixes of the names of the searched types.</li>
	 *		<li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and
	 *			type name contain wild-cards.</li>
	 *		<li>{@link SearchPattern#R_CAMELCASE_MATCH} if the package name is a
	 *			camel case of the searched types package name.</li>
	 *		<li>{@link SearchPattern#R_CAMELCASE_SAME_PART_COUNT_MATCH}
	 *			if the package name is a camel case with same part count of the searched
	 *			types package name.</li>
	 * </ul>
	 * combined with {@link SearchPattern#R_CASE_SENSITIVE},
	 *   e.g. {@link SearchPattern#R_EXACT_MATCH} | {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested, 
	 *   or {@link SearchPattern#R_PREFIX_MATCH} if a prefix non case sensitive match is requested.
	 * @param typeMatchRule one of
	 * <ul>
	 *		<li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type
	 *			name are the full names of the searched types.</li>
	 *		<li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type
	 *			name are prefixes of the names of the searched types.</li>
	 *		<li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and
	 *			type name contain wild-cards.</li>
	 *		<li>{@link SearchPattern#R_CAMELCASE_MATCH} if the type name is a
	 *			camel case of the searched types name.</li>
	 *		<li>{@link SearchPattern#R_CAMELCASE_SAME_PART_COUNT_MATCH}
	 *			if the type name is a camel case with same part count of the searched
	 *			types name.</li>
	 * </ul>
	 * combined with {@link SearchPattern#R_CASE_SENSITIVE},
	 *   e.g. {@link SearchPattern#R_EXACT_MATCH} | {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested, 

		this.basicEngine.searchAllTypeNames(packageName,
			packageMatchRule,
			typeName,
			typeMatchRule, 
			searchFor,
			scope,
			requestorWrapper,

	 *						May be <code>null</code>, then any package name is accepted.
	 * @param packageMatchRule one of
	 * <ul>
	 *		<li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type
	 *			name are the full names of the searched types.</li>
	 *		<li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type
	 *			name are prefixes of the names of the searched types.</li>
	 *		<li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and
	 *			type name contain wild-cards.</li>
	 *		<li>{@link SearchPattern#R_CAMELCASE_MATCH} if the package name is a
	 *			camel case of the searched types package name.</li>
	 *		<li>{@link SearchPattern#R_CAMELCASE_SAME_PART_COUNT_MATCH}
	 *			if the package name is a camel case with same part count of the searched
	 *			types package name.</li>
	 * </ul>
	 * combined with {@link SearchPattern#R_CASE_SENSITIVE},
	 *   e.g. {@link SearchPattern#R_EXACT_MATCH} | {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested, 

	 *					May be <code>null</code>, then any type name is accepted.
	 * @param typeMatchRule one of
	 * <ul>
	 *		<li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type
	 *			name are the full names of the searched types.</li>
	 *		<li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type
	 *			name are prefixes of the names of the searched types.</li>
	 *		<li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and
	 *			type name contain wild-cards.</li>
	 *		<li>{@link SearchPattern#R_CAMELCASE_MATCH} if the type name is a
	 *			camel case of the searched types name.</li>
	 *		<li>{@link SearchPattern#R_CAMELCASE_SAME_PART_COUNT_MATCH}
	 *			if the type name is a camel case with same part count of the searched
	 *			types name.</li>
	 * </ul>
	 * combined with {@link SearchPattern#R_CASE_SENSITIVE},
	 *   e.g. {@link SearchPattern#R_EXACT_MATCH} | {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested, 

		this.basicEngine.searchAllTypeNames(packageName, 
			packageMatchRule, 
			typeName, 
			typeMatchRule, 
			searchFor, 
			scope, 
			requestorWrapper, 




	SearchPattern.R_PATTERN_MATCH |
	SearchPattern.R_REGEXP_MATCH |
	SearchPattern.R_CASE_SENSITIVE |
	SearchPattern.R_CAMELCASE_MATCH |
	SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH;

public static boolean isMatch(char[] pattern, char[] word, int matchRule) {
	if (pattern == null) return true;

	if (patternLength == 0) return matchRule != SearchPattern.R_EXACT_MATCH;
	if (wordLength == 0) return (matchRule & SearchPattern.R_PATTERN_MATCH) != 0 && patternLength == 1 && pattern[0] == '*';

	// First test camel case if necessary
	boolean isCamelCase = (matchRule & SearchPattern.R_CAMEL_CASE_MATCH) != 0;
	if (isCamelCase) {
		// prefix is always needed as index key got characters after type simple name
		// see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=201064
		if (pattern[0] == word[0] && CharOperation.camelCaseMatch(pattern, word, true/*prefix match*/)) {
			return true;
		}
		if ((matchRule & SearchPattern.R_CASE_SENSITIVE) != 0) return false;
	}

	// need to mask some bits of pattern rule (bug 79790)
	matchRule &= ~SearchPattern.R_CAMEL_CASE_MATCH;
	switch(matchRule & MATCH_RULE_INDEX_MASK) {
		case SearchPattern.R_EXACT_MATCH :
			return patternLength == wordLength && CharOperation.equals(pattern, word, false);

			return patternLength <= wordLength && CharOperation.prefixEquals(pattern, word, false);
		case SearchPattern.R_PATTERN_MATCH :
			return CharOperation.match(pattern, word, false);
		case SearchPattern.R_CAMELCASE_MATCH:
		// same part count is not activated because index key may have uppercase letters after the type name
		case SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH:
			if (CharOperation.camelCaseMatch(pattern, word, false)) {
				return true;
			}
			return patternLength <= wordLength && CharOperation.prefixEquals(pattern, word, false);
		case SearchPattern.R_EXACT_MATCH | SearchPattern.R_CASE_SENSITIVE :
			return pattern[0] == word[0] && patternLength == wordLength && CharOperation.equals(pattern, word);
		case SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE :
			return pattern[0] == word[0] && patternLength <= wordLength && CharOperation.prefixEquals(pattern, word);
		case SearchPattern.R_PATTERN_MATCH | SearchPattern.R_CASE_SENSITIVE :
			return CharOperation.match(pattern, word, true);
		case SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE :
		// same part count is not activated because index key may have uppercase letters after the type name
		case SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH | SearchPattern.R_CASE_SENSITIVE :
			return (pattern[0] == word[0] && CharOperation.camelCaseMatch(pattern, word, false));
	}
	return false;
}

Lines 380-386 Link Here

(-)model/org/eclipse/jdt/internal/core/SearchableEnvironment.java (-1 / +1 lines)
380	};	380	};
381	try {	381	try {
382	int matchRule = SearchPattern.R_PREFIX_MATCH;	382	int matchRule = SearchPattern.R_PREFIX_MATCH;
383	if (camelCaseMatch) matchRule \|= SearchPattern.R_CAMEL_CASE_MATCH \| SearchPattern.R_PREFIX_MATCH;	383	if (camelCaseMatch) matchRule \|= SearchPattern.R_CAMELCASE_MATCH;
384	new BasicSearchEngine(this.workingCopies).searchAllTypeNames(	384	new BasicSearchEngine(this.workingCopies).searchAllTypeNames(
385	qualification,	385	qualification,
386	SearchPattern.R_EXACT_MATCH,	386	SearchPattern.R_EXACT_MATCH,




/**
 * Search basic engine. Public search engine (see {@link org.eclipse.jdt.core.search.SearchEngine}
 * for detailed comment), now uses basic engine functionalities.
 * Note that search basic engine does not implement deprecated functionalities...
 */
public class BasicSearchEngine {


				case SearchPattern.R_REGEXP_MATCH:
					buffer.append("R_REGEXP_MATCH"); //$NON-NLS-1$
					break;
				case SearchPattern.R_CAMELCASE_MATCH:
					buffer.append("R_CAMELCASE_MATCH"); //$NON-NLS-1$
					break;
				case SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH:
					buffer.append("R_CAMELCASE_SAME_PART_COUNT_MATCH"); //$NON-NLS-1$
					break;
			}
		}

				return false;
		
		if (patternTypeName != null) {
			boolean isCamelCase = (matchRule & (SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH)) != 0;
			int matchMode = matchRule & JavaSearchPattern.MATCH_MODE_MASK;
			if (!isCaseSensitive && !isCamelCase) {
				patternTypeName = CharOperation.toLowerCase(patternTypeName);
			}
			boolean matchFirstChar = !isCaseSensitive || patternTypeName[0] == typeName[0];
			if (isCamelCase) {
				if (matchFirstChar && CharOperation.camelCaseMatch(patternTypeName, typeName, (matchRule & SearchPattern.R_PREFIX_MATCH) != 0)) {
					return true;
				}
				if (isCaseSensitive) return false;
			}
			switch(matchMode) {
				case SearchPattern.R_EXACT_MATCH :
					return matchFirstChar && CharOperation.equals(patternTypeName, typeName, isCaseSensitive);

				case SearchPattern.R_REGEXP_MATCH :
					// TODO (frederic) implement regular expression match
					break;
				case SearchPattern.R_CAMELCASE_MATCH:
					if (matchFirstChar && CharOperation.camelCaseMatch(patternTypeName, typeName, false)) {
						return true;
					}
					return !isCaseSensitive && matchFirstChar && CharOperation.prefixEquals(patternTypeName, typeName, false);
				case SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH:
					return matchFirstChar && CharOperation.camelCaseMatch(patternTypeName, typeName, true);
			}
		}
		return true;

		int waitingPolicy,
		IProgressMonitor progressMonitor)  throws JavaModelException {

		// Validate match rule first
		final int validatedTypeMatchRule = SearchPattern.validateMatchRule(typeName == null ? null : new String (typeName), typeMatchRule);
		
		// Debug
		if (VERBOSE) {
			Util.verbose("BasicSearchEngine.searchAllTypeNames(char[], char[], int, int, IJavaSearchScope, IRestrictedAccessTypeRequestor, int, IProgressMonitor)"); //$NON-NLS-1$
			Util.verbose("	- package name: "+(packageName==null?"null":new String(packageName))); //$NON-NLS-1$ //$NON-NLS-2$
			Util.verbose("	- package match rule: "+getMatchRuleString(packageMatchRule)); //$NON-NLS-1$
			Util.verbose("	- type name: "+(typeName==null?"null":new String(typeName))); //$NON-NLS-1$ //$NON-NLS-2$
			Util.verbose("	- type match rule: "+getMatchRuleString(typeMatchRule)); //$NON-NLS-1$
			if (validatedTypeMatchRule != typeMatchRule) {
				Util.verbose("	- validated type match rule: "+getMatchRuleString(validatedTypeMatchRule)); //$NON-NLS-1$
			}
			Util.verbose("	- search for: "+searchFor); //$NON-NLS-1$
			Util.verbose("	- scope: "+scope); //$NON-NLS-1$
		}
		if (validatedTypeMatchRule == -1) return; // invalid match rule => return no results

		// Create pattern
		IndexManager indexManager = JavaModelManager.getIndexManager();

				null,
				typeName,
				typeSuffix,
				validatedTypeMatchRule)
			: new QualifiedTypeDeclarationPattern(
				packageName,
				packageMatchRule,
				typeName,
				typeSuffix,
				validatedTypeMatchRule);

		// 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();

						break;
					case 1:
						if (singleWkcpPath.equals(documentPath)) {
							return true; // filter out *the* working copy
						}
						break;
					default:

							} else /*if (type.isInterface())*/ {
								kind = TypeDeclaration.INTERFACE_DECL;
							}
							if (match(typeSuffix, packageName, typeName, validatedTypeMatchRule, kind, packageDeclaration, simpleName)) {
								if (nameRequestor instanceof TypeNameMatchRequestorWrapper) {
									((TypeNameMatchRequestorWrapper)nameRequestor).requestor.acceptTypeNameMatch(new JavaSearchTypeNameMatch(type, type.getFlags()));
								} else {

									return false; // no local/anonymous type
								}
								public boolean visit(TypeDeclaration typeDeclaration, CompilationUnitScope compilationUnitScope) {
									if (match(typeSuffix, packageName, typeName, validatedTypeMatchRule, TypeDeclaration.kind(typeDeclaration.modifiers), packageDeclaration, typeDeclaration.name)) {
										if (nameRequestor instanceof TypeNameMatchRequestorWrapper) {
											IType type = workingCopy.getType(new String(typeName));
											((TypeNameMatchRequestorWrapper)nameRequestor).requestor.acceptTypeNameMatch(new JavaSearchTypeNameMatch(type, typeDeclaration.modifiers));

									return true;
								}
								public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope classScope) {
									if (match(typeSuffix, packageName, typeName, validatedTypeMatchRule, TypeDeclaration.kind(memberTypeDeclaration.modifiers), packageDeclaration, memberTypeDeclaration.name)) {
										// compute enclosing type names
										TypeDeclaration enclosing = memberTypeDeclaration.enclosingType;
										char[][] enclosingTypeNames = CharOperation.NO_CHAR_CHAR;

	public void searchAllTypeNames(
		final char[][] qualifications, 
		final char[][] typeNames,
		int matchRule, 
		int searchFor, 
		IJavaSearchScope scope, 
		final IRestrictedAccessTypeRequestor nameRequestor,
		int waitingPolicy,
		IProgressMonitor progressMonitor)  throws JavaModelException {

		// Validate match rule first
		int namesLength = typeNames == null ? 0 : typeNames.length;
		for (int i=0; i<namesLength; i++) {
			matchRule &= SearchPattern.validateMatchRule(new String(typeNames[i]), matchRule);
		}
		final int validatedMatchRule = matchRule;
		
		// Debug
		if (VERBOSE) {
			Util.verbose("BasicSearchEngine.searchAllTypeNames(char[][], char[][], int, int, IJavaSearchScope, IRestrictedAccessTypeRequestor, int, IProgressMonitor)"); //$NON-NLS-1$
			Util.verbose("	- package name: "+(qualifications==null?"null":new String(CharOperation.concatWith(qualifications, ',')))); //$NON-NLS-1$ //$NON-NLS-2$
			Util.verbose("	- type name: "+(typeNames==null?"null":new String(CharOperation.concatWith(typeNames, ',')))); //$NON-NLS-1$ //$NON-NLS-2$
			Util.verbose("	- match rule: "+matchRule); //$NON-NLS-1$
			if (validatedMatchRule != matchRule) {
				Util.verbose("	- validated match rule: "+getMatchRuleString(validatedMatchRule)); //$NON-NLS-1$
			}
			Util.verbose("	- search for: "+searchFor); //$NON-NLS-1$
			Util.verbose("	- scope: "+scope); //$NON-NLS-1$
		}
		IndexManager indexManager = JavaModelManager.getIndexManager();

		// Create pattern
		final char typeSuffix;
		switch(searchFor){
			case IJavaSearchConstants.CLASS :

				typeSuffix = IIndexConstants.TYPE_SUFFIX;
				break;
		}
		final MultiTypeDeclarationPattern pattern = new MultiTypeDeclarationPattern(qualifications, typeNames, typeSuffix, validatedMatchRule);

		// 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();

						break;
					case 1:
						if (singleWkcpPath.equals(documentPath)) {
							return true; // filter out *the* working copy
						}
						break;
					default:

								}
								public boolean visit(TypeDeclaration typeDeclaration, CompilationUnitScope compilationUnitScope) {
									SearchPattern decodedPattern =
										new QualifiedTypeDeclarationPattern(packageDeclaration, typeDeclaration.name, convertTypeKind(TypeDeclaration.kind(typeDeclaration.modifiers)), validatedMatchRule);
									if (pattern.matchesDecodedKey(decodedPattern)) {
										nameRequestor.acceptType(typeDeclaration.modifiers, packageDeclaration, typeDeclaration.name, CharOperation.NO_CHAR_CHAR, path, null);
									}
									return true;
								}
								public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope classScope) {
									// compute enclosing type names
									char[] qualification = packageDeclaration;
									TypeDeclaration enclosing = memberTypeDeclaration.enclosingType;
									char[][] enclosingTypeNames = CharOperation.NO_CHAR_CHAR;

										}
									}
									SearchPattern decodedPattern =
										new QualifiedTypeDeclarationPattern(qualification, memberTypeDeclaration.name, convertTypeKind(TypeDeclaration.kind(memberTypeDeclaration.modifiers)), validatedMatchRule);
									if (pattern.matchesDecodedKey(decodedPattern)) {
										nameRequestor.acceptType(memberTypeDeclaration.modifiers, packageDeclaration, memberTypeDeclaration.name, enclosingTypeNames, path, null);
									}




 *
 * These tests are not really duplicates of {@link JavaSearchBugsTests} ones
 * as they also test camel case in indexes...
 * @deprecated As using a depreciated constant
 */
public void testCamelCaseTypePattern01_CamelCase() throws CoreException {
	search("RE", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"src/a3/References.java a3.References [References]\n" + 
		""+ getExternalJCLPathString() + " java.lang.RuntimeException"
	);
}
public void testCamelCaseTypePattern02_CamelCase() throws CoreException {
	search("RE", TYPE, DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults(
		""+ getExternalJCLPathString() + " java.lang.RuntimeException"
	);
}
/** @deprecated As using a depreciated constant */
public void testCamelCaseTypePattern02() throws CoreException {
	search("RException", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		""+ getExternalJCLPathString() + " java.lang.RuntimeException"
	);
}
public void testCamelCaseTypePattern03_CamelCase() throws CoreException {
public void testCamelCaseTypePattern03() throws CoreException {
	search("RuntimeException", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		""+ getExternalJCLPathString() + " java.lang.RuntimeException"
	);
}
public void testCamelCaseTypePattern04_CamelCase() throws CoreException {
public void testCamelCaseTypePattern04() throws CoreException {
	search("RUNTIMEEXCEPTION", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		""+ getExternalJCLPathString() + " java.lang.RuntimeException"
	);
}
public void testCamelCaseTypePattern05_CamelCase() throws CoreException {
 * @deprecated As using a depreciated constant
 */
public void testCamelCaseTypePattern05() throws CoreException {
	search("R*E*", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"src/a3/References.java a3.References [References]\n" + 
		""+ getExternalJCLPathString() + " java.lang.RuntimeException"
	);
}
public void testCamelCaseTypePattern06_CamelCase() throws CoreException {
public void testCamelCaseTypePattern06() throws CoreException {
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("CNS", SearchPattern.R_CAMELCASE_MATCH, requestor);
		null,
		SearchPattern.R_EXACT_MATCH,
		"CNS".toCharArray(),
		SearchPattern.R_CAMELCASE_MATCH,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null
	);
	assertSearchResults(
		"Unexpected all type names",
		"java.lang.CloneNotSupportedException",
		requestor);
}
public void testCamelCaseTypePattern07_CamelCase() throws CoreException {
public void testCamelCaseTypePattern07() throws CoreException {
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("AA", SearchPattern.R_CAMELCASE_MATCH, requestor);
		null,
		SearchPattern.R_EXACT_MATCH,
		"AA".toCharArray(),
		SearchPattern.R_CAMELCASE_MATCH,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null
	);
	assertSearchResults(
		"Unexpected all type names",
		"AA\n" + 

		"q1.AA",
		requestor);
}
public void testCamelCaseTypePattern08_CamelCase() throws CoreException {
public void testCamelCaseTypePattern08() throws CoreException {
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("aa", SearchPattern.R_CAMELCASE_MATCH, requestor);
		null,
		SearchPattern.R_EXACT_MATCH,
		"aa".toCharArray(),
		SearchPattern.R_CAMELCASE_MATCH,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null
	);
	assertSearchResults(
		"Unexpected all type names",
		"AA\n" + 

		"q1.AA",
		requestor);
}
public void testCamelCaseTypePattern09_CamelCase() throws CoreException {
public void testCamelCaseTypePattern09() throws CoreException {
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("aa", SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_PREFIX_MATCH, requestor);
		null,
		SearchPattern.R_EXACT_MATCH,
		"aa".toCharArray(),
		SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_PREFIX_MATCH,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null
	);
	assertSearchResults(
		"Unexpected all type names",
		"AA\n" + 

		"q1.AA",
		requestor);
}
public void testCamelCaseTypePattern10_CamelCase() throws CoreException {
public void testCamelCaseTypePattern10() throws CoreException {
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearch/src/Test.java",
		"class Null {}\n" + 
		"class NULL {}\n" + 
		"class NullPointerException {}\n" + 
		"class Nullpointerexception {}\n" + 
		"class NULLPointerException {}\n" + 
		"class NULLPOINTERException {}\n" + 
		"class NULLPOINTEREXCEPTION {}\n"

		"src/Test.java Null [Null]\n" +
		"src/Test.java NULL [NULL]\n" +
		"src/Test.java NullPointerException [NullPointerException]\n" +
		"src/Test.java Nullpointerexception [Nullpointerexception]\n" +
		"src/Test.java NULLPointerException [NULLPointerException]\n" +
		"src/Test.java NULLPOINTERException [NULLPOINTERException]\n" +
		"src/Test.java NULLPOINTEREXCEPTION [NULLPOINTEREXCEPTION]"
	);
}
public void testCamelCaseTypePattern11_CamelCase() throws CoreException {
public void testCamelCaseTypePattern11() throws CoreException {
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearch/src/Test.java",
		"class Null {}\n" + 
		"class NULL {}\n" + 
		"class NullPointerException {}\n" + 
		"class Nullpointerexception {}\n" + 
		"class NULLPointerException {}\n" + 
		"class NULLPOINTERException {}\n" + 
		"class NULLPOINTEREXCEPTION {}\n"

		"src/Test.java Null [Null]\n" +
		"src/Test.java NULL [NULL]\n" +
		"src/Test.java NullPointerException [NullPointerException]\n" +
		"src/Test.java Nullpointerexception [Nullpointerexception]\n" +
		"src/Test.java NULLPointerException [NULLPointerException]\n" +
		"src/Test.java NULLPOINTERException [NULLPOINTERException]\n" +
		"src/Test.java NULLPOINTEREXCEPTION [NULLPOINTEREXCEPTION]"
	);
}
public void testCamelCaseTypePattern12_CamelCase() throws CoreException {
public void testCamelCaseTypePattern12() throws CoreException {
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearch/src/Test.java",
		"class Null {}\n" + 
		"class NULL {}\n" + 
		"class NullPointerException {}\n" + 
		"class Nullpointerexception {}\n" + 
		"class NULLPointerException {}\n" + 
		"class NULLPOINTERException {}\n" + 
		"class NULLPOINTEREXCEPTION {}\n"
	);
	search("Null", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE);
	assertSearchResults(
		"src/Test.java Null [Null]\n" + 
		"src/Test.java NullPointerException [NullPointerException]\n" +
		"src/Test.java Nullpointerexception [Nullpointerexception]"
	);
}
public void testCamelCaseTypePattern13_CamelCase() throws CoreException {
public void testCamelCaseTypePattern13() throws CoreException {
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearch/src/Test.java",
		"class Null {}\n" + 
		"class NULL {}\n" + 
		"class NullPointerException {}\n" + 
		"class Nullpointerexception {}\n" + 
		"class NULLPointerException {}\n" + 
		"class NULLPOINTERException {}\n" + 
		"class NULLPOINTEREXCEPTION {}\n"

	search("Null", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE);
	assertSearchResults(
		"src/Test.java Null [Null]\n" + 
		"src/Test.java NullPointerException [NullPointerException]\n" +
		"src/Test.java Nullpointerexception [Nullpointerexception]"
	);
}
// Same tests using SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH instead
public void testCamelCaseTypePattern01_CamelCaseSamePartCount() throws CoreException {
	search("RE", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		""+ getExternalJCLPathString() + " java.lang.RuntimeException"
	);
}
public void testCamelCaseTypePattern02_CamelCaseSamePartCount() throws CoreException {
	search("RException", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		""+ getExternalJCLPathString() + " java.lang.RuntimeException"
	);
}
public void testCamelCaseTypePattern03_CamelCaseSamePartCount() throws CoreException {
	search("RuntimeException", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		""+ getExternalJCLPathString() + " java.lang.RuntimeException"
	);
}
public void testCamelCaseTypePattern04_CamelCaseSamePartCount() throws CoreException {
	search("RUNTIMEEXCEPTION", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults("");
}
public void testCamelCaseTypePattern05_CamelCaseSamePartCount() throws CoreException {
	search("R*E*", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/a3/References.java a3.References [References]\n" + 
		""+ getExternalJCLPathString() + " java.lang.RuntimeException"
	);
}
public void testCamelCaseTypePattern06_CamelCaseSamePartCount() throws CoreException {
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("CNS", SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH, requestor);
	assertSearchResults(
		"Unexpected all type names",
		"",
		requestor);
}
public void testCamelCaseTypePattern07_CamelCaseSamePartCount() throws CoreException {
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("AA", SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH, requestor);
	assertSearchResults(
		"Unexpected all type names",
		"AA\n" + 
		"d8.AA\n" + 
		"p6.AA\n" + 
		"q1.AA",
		requestor);
}
public void testCamelCaseTypePattern08_CamelCaseSamePartCount() throws CoreException {
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("aa", SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH, requestor);
	assertSearchResults(
		"Unexpected all type names",
		"AA\n" + 
		"d8.AA\n" + 
		"p6.AA\n" + 
		"q1.AA",
		requestor);
}
public void testCamelCaseTypePattern09_CamelCaseSamePartCount() throws CoreException {
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("aa", SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH | SearchPattern.R_PREFIX_MATCH, requestor);
	assertSearchResults(
		"Unexpected all type names",
		"AA\n" + 
		"d8.AA\n" + 
		"p6.AA\n" + 
		"q1.AA",
		requestor);
}
public void testCamelCaseTypePattern10_CamelCaseSamePartCount() throws CoreException {
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearch/src/Test.java",
		"class Null {}\n" + 
		"class NULL {}\n" + 
		"class NullPointerException {}\n" + 
		"class Nullpointerexception {}\n" + 
		"class NULLPointerException {}\n" + 
		"class NULLPOINTERException {}\n" + 
		"class NULLPOINTEREXCEPTION {}\n"
	);
	search("Null", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/Test.java Null [Null]\n" +
		"src/Test.java Nullpointerexception [Nullpointerexception]"
	);
}
public void testCamelCaseTypePattern11_CamelCaseSamePartCount() throws CoreException {
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearch/src/Test.java",
		"class Null {}\n" + 
		"class NULL {}\n" + 
		"class NullPointerException {}\n" + 
		"class Nullpointerexception {}\n" + 
		"class NULLPointerException {}\n" + 
		"class NULLPOINTERException {}\n" + 
		"class NULLPOINTEREXCEPTION {}\n"
	);
	search("Null", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH | SearchPattern.R_PREFIX_MATCH);
	assertSearchResults(
		"src/Test.java Null [Null]\n" +
		"src/Test.java Nullpointerexception [Nullpointerexception]"
		"src/Test.java NullPointerException [NullPointerException]\n" +
		"src/Test.java NULLPointerException [NULLPointerException]\n" +
		"src/Test.java NULLPOINTERException [NULLPOINTERException]\n" +
		"src/Test.java NULLPOINTEREXCEPTION [NULLPOINTEREXCEPTION]"
	);
}
public void testCamelCaseTypePattern12_CamelCaseSamePartCount() throws CoreException {
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearch/src/Test.java",
		"class Null {}\n" + 
		"class NULL {}\n" + 
		"class NullPointerException {}\n" + 
		"class Nullpointerexception {}\n" + 
		"class NULLPointerException {}\n" + 
		"class NULLPOINTERException {}\n" + 
		"class NULLPOINTEREXCEPTION {}\n"
	);
	search("Null", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH | SearchPattern.R_CASE_SENSITIVE);
	assertSearchResults(
		"src/Test.java Null [Null]\n" +
		"src/Test.java Nullpointerexception [Nullpointerexception]"
	);
}
public void testCamelCaseTypePattern13_CamelCaseSamePartCount() throws CoreException {
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearch/src/Test.java",
		"class Null {}\n" + 
		"class NULL {}\n" + 
		"class NullPointerException {}\n" + 
		"class Nullpointerexception {}\n" + 
		"class NULLPointerException {}\n" + 
		"class NULLPOINTERException {}\n" + 
		"class NULLPOINTEREXCEPTION {}\n"
	);
	search("Null", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH | SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE);
	assertSearchResults(
		"src/Test.java Null [Null]\n" +
		"src/Test.java Nullpointerexception [Nullpointerexception]"
	);
}





		"interface IDocumentExtension315 {}\n"
	);
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	int validatedRule = SearchPattern.validateMatchRule("IDE3", SearchPattern.R_CAMELCASE_MATCH);
	searchAllTypeNames("IDE3", validatedRule, requestor);
	assertSearchResults(
		"IDocumentExtension135\n" + 

		"interface IDocumentProviderExtension54321 {}\n"
	);
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	int validatedRule = SearchPattern.validateMatchRule("IDPE3", SearchPattern.R_CAMELCASE_MATCH);
	searchAllTypeNames("IDPE3", validatedRule, requestor);
	assertSearchResults(
		"IDocumentProviderExtension12345\n" + 

		"interface IPerspectiveListener3 {}\n"
	);
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	int validatedRule = SearchPattern.validateMatchRule("IPL3", SearchPattern.R_CAMELCASE_MATCH);
	searchAllTypeNames("IPL3", validatedRule, requestor);
	assertSearchResults(
		"IPerspectiveListener3",

		"interface IPropertySource2 {}\n"
	);
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	int validatedRule = SearchPattern.validateMatchRule("IPS2", SearchPattern.R_CAMELCASE_MATCH);
	searchAllTypeNames("IPS2", validatedRule, requestor);
	assertSearchResults(
		"IPropertySource2",

		"interface IWorkbenchWindowPulldownDelegate4 {}\n"
	);
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	int validatedRule = SearchPattern.validateMatchRule("IWWPD2", SearchPattern.R_CAMELCASE_MATCH);
	searchAllTypeNames("IWWPD2", validatedRule, requestor);
	assertSearchResults(
		"IWorkbenchWindowPulldownDelegate2",

		"class UTFDocScannerSupport {}\n"
	);
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	int validatedRule = SearchPattern.validateMatchRule("UTF16DSS", SearchPattern.R_CAMELCASE_MATCH);
	searchAllTypeNames("UTF16DSS", validatedRule, requestor);
	assertSearchResults(
		"UTF16DocumentScannerSupport",

		"class UTFDocScannerSupport {}\n"
	);
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	int validatedRule = SearchPattern.validateMatchRule("UTF1DSS", SearchPattern.R_CAMELCASE_MATCH);
	searchAllTypeNames("UTF1DSS", validatedRule, requestor);
	assertSearchResults(
		"UTF16DocumentScannerSupport\n" + 

		"class UTFDocScannerSupport {}\n"
	);
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	int validatedRule = SearchPattern.validateMatchRule("UTF6DSS", SearchPattern.R_CAMELCASE_MATCH);
	searchAllTypeNames("UTF6DSS", validatedRule, requestor);
	assertSearchResults(
		"UTF16DocumentScannerSupport\n" + 

		"class UTFDocScannerSupport {}\n"
	);
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	int validatedRule = SearchPattern.validateMatchRule("UTFDSS", SearchPattern.R_CAMELCASE_MATCH);
	searchAllTypeNames("UTFDSS", validatedRule, requestor);
	assertSearchResults(
		"UTF16DocumentScannerSupport\n" + 

		"class AxxAyy {}\n"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_TypePattern01() throws CoreException {
	setUpBug110060_TypePattern();
	search("AA", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_MATCH);

		"src/b110060/Test.java b110060.Test.a6 [AxxAyy] EXACT_MATCH"
	);
}
public void testBug110060_TypePattern01_SamePartCount() throws CoreException {
	setUpBug110060_TypePattern();
	search("AA", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.a2 [AAa] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.a4 [AAxx] EXACT_MATCH\n" + 

		"src/b110060/Test.java b110060.Test.a6 [AxxAyy] EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_TypePattern02() throws CoreException {
	setUpBug110060_TypePattern();
	search("AA", TYPE, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);

		"src/b110060/Test.java b110060.AxxAyy [AxxAyy] EXACT_MATCH"
	);
}
public void testBug110060_TypePattern02_SamePartCount() throws CoreException {
	setUpBug110060_TypePattern();
	search("AA", TYPE, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.a2 [AAa] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.a4 [AAxx] EXACT_MATCH\n" + 

		"src/b110060/Test.java b110060.AxxAyy [AxxAyy] EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_TypePattern03() throws CoreException {
	setUpBug110060_TypePattern();
	search("AAx", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_MATCH);

		"src/b110060/Test.java b110060.Test.a4 [AAxx] EXACT_MATCH"
	);
}
public void testBug110060_TypePattern03_SamePartCount() throws CoreException {
	setUpBug110060_TypePattern();
	search("AAx", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.a4 [AAxx] EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_TypePattern04() throws CoreException {
	setUpBug110060_TypePattern();
	search("Axx", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_MATCH);

		"src/b110060/Test.java b110060.Test.a6 [AxxAyy] EXACT_MATCH"
	);
}
public void testBug110060_TypePattern04_SamePartCount() throws CoreException {
	setUpBug110060_TypePattern();
	search("Axx", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults("");
		"" // no result as camel case does not allow prefix match
	);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_TypePattern05() throws CoreException {
	setUpBug110060_TypePattern();
	search("Ax", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_MATCH);

		"src/b110060/Test.java b110060.Test.a6 [AxxAyy] EXACT_MATCH"
	);
}
public void testBug110060_TypePattern05_SamePartCount() throws CoreException {
	setUpBug110060_TypePattern();
	search("Ax", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults("");
		"" // no result as camel case does not allow prefix match
	);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_TypePattern06() throws CoreException {
	setUpBug110060_TypePattern();
	search("A*A*", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_MATCH);
	// Invalid camel case pattern => replace the camel case flag with pattern match one (case insensitive)
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.a1 [Aaa] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.a2 [AAa] EXACT_MATCH\n" + 

		"src/b110060/Test.java b110060.Test.a6 [AxxAyy] EXACT_MATCH"
	);
}
public void testBug110060_TypePattern06_SamePartCount() throws CoreException {
	setUpBug110060_TypePattern();
	search("A*A*", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	// Invalid camel case pattern => replace the camel case flag with pattern match one (case insensitive)
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.a1 [Aaa] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.a2 [AAa] EXACT_MATCH\n" + 

		"src/b110060/Test.java b110060.Test.a6 [AxxAyy] EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_TypePattern07() throws CoreException {
	setUpBug110060_TypePattern();
	search("aaa", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_MATCH);
	// Invalid camel case pattern => replace the camel case flag by prefix match one (case insensitive)
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.a1 [Aaa] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.a2 [AAa] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.a3 [AaAaAa] EXACT_MATCH"
	);
}
public void testBug110060_TypePattern07_SamePartCount() throws CoreException {
	setUpBug110060_TypePattern();
	search("aaa", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	// Invalid camel case pattern => replace the camel case flag by prefix match one (case insensitive)
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.a1 [Aaa] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.a2 [AAa] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.a3 [AaAaAa] EXACT_MATCH"
		"src/b110060/Test.java b110060.Test.a4 [AAxx] EXACT_MATCH"
	);
}
public void testBug110060_TypePattern08() throws CoreException {
	setUpBug110060_TypePattern();
	search("Aaa", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.a1 [Aaa] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.a2 [AAa] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.a3 [AaAaAa] EXACT_MATCH"
	);
}
public void testBug110060_TypePattern08_SamePartCount() throws CoreException {
	setUpBug110060_TypePattern();
	search("Aaa", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.a1 [Aaa] EXACT_MATCH"
	);
}
public void testBug110060_TypePattern09() throws CoreException {
	setUpBug110060_TypePattern();
	search("Aaa", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE);
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.a1 [Aaa] EXACT_MATCH"
	);
}
public void testBug110060_TypePattern09_SamePartCount() throws CoreException {
	setUpBug110060_TypePattern();
	search("Aaa", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH | SearchPattern.R_CASE_SENSITIVE);
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.a1 [Aaa] EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_TypePattern10() throws CoreException {
	setUpBug110060_TypePattern();
	search("AxAx", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults("");
}
public void testBug110060_TypePattern10_SamePartCount() throws CoreException {
	setUpBug110060_TypePattern();
	search("AxAx", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults("");
}
/** @deprecated As using a depreciated constant */
public void testBug110060_TypePattern11() throws CoreException {
	setUpBug110060_TypePattern();
	search("AxxA", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_MATCH);

		"src/b110060/Test.java b110060.Test.a6 [AxxAyy] EXACT_MATCH"
	);
}
public void testBug110060_TypePattern11_SamePartCount() throws CoreException {
	setUpBug110060_TypePattern();
	search("AxxA", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.a6 [AxxAyy] EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_TypePattern12() throws CoreException {
	setUpBug110060_TypePattern();
	search("AxXA", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_MATCH);

		"src/b110060/Test.java b110060.Test.a6 [AxxAyy] EXACT_MATCH"
	);
}
public void testBug110060_TypePattern12_SamePartCount() throws CoreException {
	setUpBug110060_TypePattern();
	search("AxXA", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults("");
}

// Search all type names requests
/** @deprecated As using a depreciated constant */
public void testBug110060_AllTypeNames01() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("AA", SearchPattern.R_CAMELCASE_MATCH, requestor);
	assertSearchResults("Unexpected all type names",
		"Unexpected all type names",
		"b110060.AAa\n" + 
		"b110060.AAxx\n" + 
		"b110060.AaAaAa\n" + 

		"b110060.AxxAyy",
		requestor);
}
public void testBug110060_AllTypeNames01_SamePartCount() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("AA", SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH, requestor);
	assertSearchResults("Unexpected all type names",
		"Unexpected all type names",
		"b110060.AAa\n" + 
		"b110060.AAxx\n" + 
		"b110060.AxA\n" + 

public void testBug110060_AllTypeNames02() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("aaa", SearchPattern.R_CAMELCASE_MATCH, requestor);
	// Invalid camel case pattern => replace the camel case flag with prefix match one (case insensitive)
	assertSearchResults("Unexpected all type names",
		"b110060.AAa\n" + 
		"b110060.AAxx\n" + 
		"b110060.AaAaAa\n" + 
		"b110060.Aaa",
		requestor);
}
public void testBug110060_AllTypeNames02_SamePartCount() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("aaa", SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH, requestor);
	// Invalid camel case pattern => replace the camel case flag with prefix match one (case insensitive)
	assertSearchResults("Unexpected all type names",
		"b110060.AAa\n" + 
		"b110060.AaAaAa\n" + 
		"b110060.Aaa",
		requestor);
}
public void testBug110060_AllTypeNames03() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("AAa", SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE, requestor);
	assertSearchResults("Unexpected all type names",
		"b110060.AAa\n" + 
		"b110060.AaAaAa",
		requestor);
}
public void testBug110060_AllTypeNames03_SamePartCount() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("AAa", SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH | SearchPattern.R_CASE_SENSITIVE, requestor);
	assertSearchResults("Unexpected all type names",
		"b110060.AAa",
		"b110060.AAa\n" + 
		"b110060.AAxx\n" + 
		"b110060.AaAaAa\n" + 
		"b110060.AxA\n" + 
		"b110060.AxxAyy",
		requestor);
}
public void testBug110060_AllTypeNames04() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("AA", SearchPattern.R_PREFIX_MATCH, requestor);

		"b110060.Aaa",
		requestor);
}
public void testBug110060_AllTypeNames05() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("AAA", SearchPattern.R_CASE_SENSITIVE, requestor);

		"",
		requestor);
}
public void testBug110060_AllTypeNames06() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("AA", SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE, requestor);

		"b110060.AAxx",
		requestor);
}
public void testBug110060_AllTypeNames07() throws CoreException {
public void testBug110060_AllTypeNames08() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("aaa", SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_PREFIX_MATCH, requestor);
	// Invalid camel case pattern => replace the camel case flag with prefix match one (case insensitive)
	assertSearchResults(
		"Unexpected all type names",
		"b110060.AAa\n" + 
		"b110060.AAxx\n" + 
		"b110060.AaAaAa\n" + 
		"b110060.Aaa",
		requestor);
}
public void testBug110060_AllTypeNames07_SamePartCount() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("aaa", SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH | SearchPattern.R_PREFIX_MATCH, requestor);
	// Invalid camel case pattern => replace the camel case flag with prefix match one (case insensitive)
	assertSearchResults(
		"Unexpected all type names",
		"b110060.AAa\n" + 
		"b110060.AaAaAa\n" + 
		"b110060.Aaa",
		requestor);
}
public void testBug110060_AllTypeNames08() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("aaa", SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE, requestor);
	// Invalid camel case pattern => replace the camel case flag with prefix match one keeping case sensitive
	assertSearchResults(
		"Unexpected all type names",
		"",
		requestor);
}
public void testBug110060_AllTypeNames08_SamePartCount() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("aaa", SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH | SearchPattern.R_CASE_SENSITIVE, requestor);
	// Invalid camel case pattern => replace the camel case flag with prefix match one keeping case sensitive
	assertSearchResults(
		"Unexpected all type names",
		"",
		requestor);
}
public void testBug110060_AllTypeNames09() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("aaa", SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE, requestor);
	// Invalid camel case pattern => reset the camel case flag keeping prefix match and case sensitive ones
	assertSearchResults(
		"Unexpected all type names",
		"",
		requestor);
}
public void testBug110060_AllTypeNames09_SamePartCount() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("aaa", SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH | SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE, requestor);
	// Invalid camel case pattern => reset the camel case flag keeping prefix match and case sensitive ones
	assertSearchResults(
		"Unexpected all type names",
		"",

// Constructor search
private void setUpBug110060_ConstructorPattern() throws CoreException {
	workingCopies = new ICompilationUnit[5];
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b110060/AAAA.java",
		"package b110060;\n" +
		"public class AAAA {\n" +
		"	AAAA() {}\n" +
		"}\n"
	);
	workingCopies[1] = getWorkingCopy("/JavaSearchBugs/src/b110060/AAxx.java",

		"	AxxAyy() {}\n" +
		"}\n"
	);
	workingCopies[3] = getWorkingCopy("/JavaSearchBugs/src/b110060/AxAyAz.java",
		"package b110060;\n" +
		"public class AxAyAz {\n" +
		"	AxAyAz() {}\n" +
		"}\n"
	);
	workingCopies[4] = getWorkingCopy("/JavaSearchBugs/src/b110060/Test.java",
		"package b110060;\n" +
		"public class Test {\n" +
		"	AAAA aaaa = new AAAA();\n" +
		"	AAxx aaxx = new AAxx();\n" +
		"	AxAyAz axayaz = new AxAyAz();\n" +
		"	AxxAyy axxayy = new AxxAyy();\n" +
		"}\n"
	);
}
public void testBug110060_ConstructorPattern01() throws CoreException {
	setUpBug110060_ConstructorPattern();
	search("AA", CONSTRUCTOR, REFERENCES, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.aaaa [new AAAA()] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.aaxx [new AAxx()] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.axayaz [new AxAyAz()] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.axxayy [new AxxAyy()] EXACT_MATCH"
	);
}
public void testBug110060_ConstructorPattern01_SamePartCount() throws CoreException {
	setUpBug110060_ConstructorPattern();
	search("AA", CONSTRUCTOR, REFERENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.aa [new AA()] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.aaxx [new AAxx()] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.axa [new AxA()] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.axxayy [new AxxAyy()] EXACT_MATCH"
	);
}
public void testBug110060_ConstructorPattern02() throws CoreException {
	setUpBug110060_ConstructorPattern();
	search("AA", CONSTRUCTOR, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"src/b110060/AAAA.java b110060.AAAA() [AAAA] EXACT_MATCH\n" +
		"src/b110060/AAxx.java b110060.AAxx() [AAxx] EXACT_MATCH\n" +
		"src/b110060/AxAyAz.java b110060.AxAyAz() [AxAyAz] EXACT_MATCH\n" +
		"src/b110060/AxxAyy.java b110060.AxxAyy() [AxxAyy] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.aaaa [new AAAA()] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.aaxx [new AAxx()] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.axayaz [new AxAyAz()] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.axxayy [new AxxAyy()] EXACT_MATCH"
	);
}
public void testBug110060_ConstructorPattern02_SamePartCount() throws CoreException {
	setUpBug110060_ConstructorPattern();
	search("AA", CONSTRUCTOR, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/b110060/AAxx.java b110060.AAxx() [AAxx] EXACT_MATCH\n" + 
		"src/b110060/AxxAyy.java b110060.AxxAyy() [AxxAyy] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.aaxx [new AAxx()] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.axxayy [new AxxAyy()] EXACT_MATCH"
	);
}
public void testBug110060_ConstructorPattern03() throws CoreException {
	setUpBug110060_ConstructorPattern();
	search("AAx", CONSTRUCTOR, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"src/b110060/AAxx.java b110060.AAxx() [AAxx] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.aaxx [new AAxx()] EXACT_MATCH"
	);
}
public void testBug110060_ConstructorPattern03_SamePartCount() throws CoreException {
	setUpBug110060_ConstructorPattern();
	search("AAx", CONSTRUCTOR, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/b110060/AAxx.java b110060.AAxx() [AAxx] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.aaxx [new AAxx()] EXACT_MATCH"
	);
}
public void testBug110060_ConstructorPattern04() throws CoreException {
	setUpBug110060_ConstructorPattern();
	search("AxA", CONSTRUCTOR, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"src/b110060/AxAyAz.java b110060.AxAyAz() [AxAyAz] EXACT_MATCH\n" +
		"src/b110060/AxxAyy.java b110060.AxxAyy() [AxxAyy] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.axayaz [new AxAyAz()] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.axxayy [new AxxAyy()] EXACT_MATCH"
	);
}
public void testBug110060_ConstructorPattern04_SamePartCount() throws CoreException {
	setUpBug110060_ConstructorPattern();
	search("AxA", CONSTRUCTOR, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/b110060/AxxAyy.java b110060.AxxAyy() [AxxAyy] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.axxayy [new AxxAyy()] EXACT_MATCH"
	);
}
public void testBug110060_ConstructorPattern05() throws CoreException {
	setUpBug110060_ConstructorPattern();
	search("A*A*", CONSTRUCTOR, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);
	// Invalid camel case pattern => replace the camel case flag with pattern match one (case insensitive)
	assertSearchResults(
		"src/b110060/AAAA.java b110060.AAAA() [AAAA] EXACT_MATCH\n" +
		"src/b110060/AAxx.java b110060.AAxx() [AAxx] EXACT_MATCH\n" +
		"src/b110060/AxAyAz.java b110060.AxAyAz() [AxAyAz] EXACT_MATCH\n" +
		"src/b110060/AxxAyy.java b110060.AxxAyy() [AxxAyy] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.aaaa [new AAAA()] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.aaxx [new AAxx()] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.axayaz [new AxAyAz()] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.axxayy [new AxxAyy()] EXACT_MATCH"
	);
}
public void testBug110060_ConstructorPattern05_SamePartCount() throws CoreException {
	setUpBug110060_ConstructorPattern();
	search("A*A*", CONSTRUCTOR, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	// Invalid camel case pattern => replace the camel case flag with pattern match one (case insensitive)
	assertSearchResults(
		"src/b110060/AAAA.java b110060.AAAA() [AAAA] EXACT_MATCH\n" +
		"src/b110060/AAxx.java b110060.AAxx() [AAxx] EXACT_MATCH\n" +
		"src/b110060/AxAyAz.java b110060.AxAyAz() [AxAyAz] EXACT_MATCH\n" +
		"src/b110060/AxxAyy.java b110060.AxxAyy() [AxxAyy] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.aaaa [new AAAA()] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.aaxx [new AAxx()] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.axayaz [new AxAyAz()] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.axxayy [new AxxAyy()] EXACT_MATCH"
	);
}

		"}\n"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_MethodPattern01() throws CoreException {
	setUpBug110060_MethodPattern();
	search("MWD", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults("");
}
public void testBug110060_MethodPattern01_SamePartCount() throws CoreException {
	setUpBug110060_MethodPattern();
	search("MWD", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults("");
}
/** @deprecated As using a depreciated constant */
public void testBug110060_MethodPattern02() throws CoreException {
	setUpBug110060_MethodPattern();
	search("AMWD", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults("");
}
public void testBug110060_MethodPattern02_SamePartCount() throws CoreException {
	setUpBug110060_MethodPattern();
	search("AMWD", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults("");
}
/** @deprecated As using a depreciated constant */
public void testBug110060_MethodPattern03() throws CoreException {
	setUpBug110060_MethodPattern();
	search("aMWD", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);

		"src/b110060/Test.java void b110060.Test.testReferences() [aMethodWith1DigitAnd_AnUnderscore()] EXACT_MATCH"
	);
}
public void testBug110060_MethodPattern03_SamePartCount() throws CoreException {
	setUpBug110060_MethodPattern();
	search("aMWD", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/b110060/Test.java void b110060.Test.aMethodWith1Digit() [aMethodWith1Digit] EXACT_MATCH\n" + 
		"src/b110060/Test.java void b110060.Test.testReferences() [aMethodWith1Digit()] EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_MethodPattern04() throws CoreException {
	setUpBug110060_MethodPattern();
	search("aMW", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);

		"src/b110060/Test.java void b110060.Test.testReferences() [aMethodWithNothingSpecial()] EXACT_MATCH"
	);
}
public void testBug110060_MethodPattern04_SamePartCount() throws CoreException {
	setUpBug110060_MethodPattern();
	search("aMW", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		""
	);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_MethodPattern05() throws CoreException {
	setUpBug110060_MethodPattern();
	search("aMethod", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);

		"src/b110060/Test.java void b110060.Test.testReferences() [aMethodWithNothingSpecial()] EXACT_MATCH"
	);
}
public void testBug110060_MethodPattern05_SamePartCount() throws CoreException {
	setUpBug110060_MethodPattern();
	search("aMethod", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults("");
		"" // no result as prefix match is not set
	);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_MethodPattern06() throws CoreException {
	setUpBug110060_MethodPattern();
	search("aMethodWith1", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);

		"src/b110060/Test.java void b110060.Test.testReferences() [aMethodWith1Or2_Or_3_Or__4__DigitsAnd_Several_Underscores()] EXACT_MATCH"
	);
}
public void testBug110060_MethodPattern06_SamePartCount() throws CoreException {
	setUpBug110060_MethodPattern();
	search("aMethodWith1", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults("");
		"" // no result as prefix match is not set
	);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_MethodPattern07() throws CoreException {
	setUpBug110060_MethodPattern();
	search("*Method*With*A*", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);
	// Invalid camel case pattern => replace the camel case flag with pattern match one (case insensitive)
	assertSearchResults(
		"src/b110060/Test.java void b110060.Test.aMethodWithNothingSpecial() [aMethodWithNothingSpecial] EXACT_MATCH\n" +
		"src/b110060/Test.java void b110060.Test.aMethodWith1DigitAnd_AnUnderscore() [aMethodWith1DigitAnd_AnUnderscore] EXACT_MATCH\n" +

		"src/b110060/Test.java void b110060.Test.testReferences() [otherMethodWhichStartsWithAnotherLetter()] EXACT_MATCH"
	);
}
public void testBug110060_MethodPattern07_SamePartCount() throws CoreException {
	setUpBug110060_MethodPattern();
	search("*Method*With*A*", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	// Invalid camel case pattern => replace the camel case flag with pattern match one (case insensitive)
	assertSearchResults(
		"src/b110060/Test.java void b110060.Test.aMethodWithNothingSpecial() [aMethodWithNothingSpecial] EXACT_MATCH\n" +
		"src/b110060/Test.java void b110060.Test.aMethodWith1DigitAnd_AnUnderscore() [aMethodWith1DigitAnd_AnUnderscore] EXACT_MATCH\n" +

		"src/b110060/Test.java void b110060.Test.testReferences() [otherMethodWhichStartsWithAnotherLetter()] EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_MethodPattern08() throws CoreException {
	setUpBug110060_MethodPattern();
	search("aMW1D", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);

		"src/b110060/Test.java void b110060.Test.testReferences() [aMethodWith1DigitAnd_AnUnderscore()] EXACT_MATCH"
	);
}
public void testBug110060_MethodPattern08_SamePartCount() throws CoreException {
	setUpBug110060_MethodPattern();
	search("aMW1D", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/b110060/Test.java void b110060.Test.aMethodWith1Digit() [aMethodWith1Digit] EXACT_MATCH\n" + 
		"src/b110060/Test.java void b110060.Test.testReferences() [aMethodWith1Digit()] EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_MethodPattern09() throws CoreException {
	setUpBug110060_MethodPattern();
	search("aMWOOODASU", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);

		"src/b110060/Test.java void b110060.Test.testReferences() [aMethodWith1Or2_Or_3_Or__4__DigitsAnd_Several_Underscores()] EXACT_MATCH"
	);
}
public void testBug110060_MethodPattern09_SamePartCount() throws CoreException {
	setUpBug110060_MethodPattern();
	search("aMWOOODASU", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/b110060/Test.java void b110060.Test.aMethodWith1Or2_Or_3_Or__4__DigitsAnd_Several_Underscores() [aMethodWith1Or2_Or_3_Or__4__DigitsAnd_Several_Underscores] EXACT_MATCH\n" +
		"src/b110060/Test.java void b110060.Test.testReferences() [aMethodWith1Or2_Or_3_Or__4__DigitsAnd_Several_Underscores()] EXACT_MATCH"

		"}\n"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_FieldPattern01() throws CoreException {
	setUpBug110060_FieldPattern();
	search("aFWSD", FIELD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);

		"src/b110060/Test.java void b110060.Test.testReferences() [aFieldWith$Several$DollarslAnd1DigitAnd_1Underscore] EXACT_MATCH"
	);
}
public void testBug110060_FieldPattern01_SamePartCount() throws CoreException {
	setUpBug110060_FieldPattern();
	search("aFWSD", FIELD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.aFieldWithS$Dollar [aFieldWithS$Dollar] EXACT_MATCH\n" + 
		"src/b110060/Test.java void b110060.Test.testReferences() [aFieldWithS$Dollar] EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_FieldPattern02() throws CoreException {
	setUpBug110060_FieldPattern();
	search("afwsd", FIELD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults("");
}
public void testBug110060_FieldPattern02_SamePartCount() throws CoreException {
	setUpBug110060_FieldPattern();
	search("afwsd", FIELD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults("");
}
/** @deprecated As using a depreciated constant */
public void testBug110060_FieldPattern03() throws CoreException {
	setUpBug110060_FieldPattern();
	search("aFWS$", FIELD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);

		"src/b110060/Test.java void b110060.Test.testReferences() [aFieldWithS$Dollar] EXACT_MATCH"
	);
}
public void testBug110060_FieldPattern03_SamePartCount() throws CoreException {
	setUpBug110060_FieldPattern();
	search("aFWS$", FIELD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults("");
		"" // no result as prefix match is not set
	);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_FieldPattern04() throws CoreException {
	setUpBug110060_FieldPattern();
	search("aSFWSCD", FIELD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);

		"src/b110060/Test.java void b110060.Test.testReferences() [aStrangeFieldWith$$$$$$$$$$$$$$$SeveraContiguousDollars] EXACT_MATCH"
	);
}
public void testBug110060_FieldPattern04_SamePartCount() throws CoreException {
	setUpBug110060_FieldPattern();
	search("aSFWSCD", FIELD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.aStrangeFieldWith$$$$$$$$$$$$$$$SeveraContiguousDollars [aStrangeFieldWith$$$$$$$$$$$$$$$SeveraContiguousDollars] EXACT_MATCH\n" +
		"src/b110060/Test.java void b110060.Test.testReferences() [aStrangeFieldWith$$$$$$$$$$$$$$$SeveraContiguousDollars] EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_FieldPattern05() throws CoreException {
	setUpBug110060_FieldPattern();
	search("oF", FIELD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);

}
public void testBug110060_FieldPattern05new() throws CoreException {
	setUpBug110060_FieldPattern();
	search("oF", FIELD, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.oF [oF] EXACT_MATCH"
	);

}

/**
 * @test Bug 110336: [plan][search] Should optionally return the local variable for type reference
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=110336"
 */
public void testBug110336a() throws CoreException {

 *	@test Ensure that camel case pattern may use end character
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=124624"
 */
private void setupBug124624() throws JavaModelException {
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
		"class HashMap {}\n" + 
		"class HtmlMapper {}\n" + 
		"class HashMapEntry {}\n" + 
		"class HaxMapxxxx {}\n"
	);
	search("HM", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH\n" + 
		"src/Test.java HtmlMapper [HtmlMapper] EXACT_MATCH\n" + 
		"src/Test.java HatMappage [HatMappage] EXACT_MATCH"
	);
}
public void testBug124624_HM_CamelCase() throws CoreException {
	setupBug124624();
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
		"class HashMap {}\n" + 
		"class HtmlMapper {}\n" + 
		"class HashMapEntry {}\n" + 
		"class HatMappage {}\n"
	);
	search("HM", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH\n" + 
		"src/Test.java HtmlMapper [HtmlMapper] EXACT_MATCH\n" + 
		"src/Test.java HashMapEntry [HashMapEntry] EXACT_MATCH\n" + 
		"src/Test.java HaxMapxxxx [HaxMapxxxx] EXACT_MATCH"
	);
}
public void testBug124624_HM_CamelCaseSamePartCount() throws CoreException {
	setupBug124624();
	search("HM", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
		"class HashMap {}\n" + 
		"class HtmlMapper {}\n" + 
		"class HashMapEntry {}\n" + 
		"class HatMappage {}\n"
	);
	search("HaM", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH\n" + 
		"src/Test.java HtmlMapper [HtmlMapper] EXACT_MATCH\n" + 
		"src/Test.java HaxMapxxxx [HaxMapxxxx] EXACT_MATCH"
	);
}
public void testBug124624_HaM_CamelCase() throws CoreException {
	setupBug124624();
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
		"class HashMap {}\n" + 
		"class HtmlMapper {}\n" + 
		"class HashMapEntry {}\n" + 
		"class HatMappage {}\n"
	);
	search("HaM", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH\n" + 
		"src/Test.java HashMapEntry [HashMapEntry] EXACT_MATCH\n" + 
		"src/Test.java HaxMapxxxx [HaxMapxxxx] EXACT_MATCH"
	);
}
public void testBug124624_HaM_CamelCaseSamePartCount() throws CoreException {
	setupBug124624();
	search("HaM", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
		"class HashMap {}\n" + 
		"class HtmlMapper {}\n" + 
		"class HashMapEntry {}\n" + 
		"class HatMappage {}\n"
	);
	search("HashM", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH\n" + 
		"src/Test.java HaxMapxxxx [HaxMapxxxx] EXACT_MATCH"
	);
}
public void testBug124624_HashM_CamelCase() throws CoreException {
	setupBug124624();
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
		"class HashMap {}\n" + 
		"class HtmlMapper {}\n" + 
		"class HashMapEntry {}\n" + 
		"class HatMappage {}\n"
	);
	search("HashM", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH\n" + 
		"src/Test.java HashMapEntry [HashMapEntry] EXACT_MATCH"
	);
}
public void testBug124624_HashM_CamelCaseSamePartCount() throws CoreException {
	setupBug124624();
	search("HashM", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH"
		"class HashMapEntry {}\n" + 
		"class HatMappage {}\n"
	);
	search("HMa", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults("");
}
public void testBug124624_HMa_CamelCase() throws CoreException {
	setupBug124624();
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
		"class HashMap {}\n" + 
		"class HtmlMapper {}\n" + 
		"class HashMapEntry {}\n" + 
		"class HatMappage {}\n"
	);
	search("HMa", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH\n" + 
		"src/Test.java HtmlMapper [HtmlMapper] EXACT_MATCH\n" + 
		"src/Test.java HashMapEntry [HashMapEntry] EXACT_MATCH\n" + 
		"src/Test.java HaxMapxxxx [HaxMapxxxx] EXACT_MATCH"
	);
}
public void testBug124624_HMa_CamelCaseSamePartCount() throws CoreException {
	setupBug124624();
	search("HMa", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH\n" + 
		"src/Test.java HtmlMapper [HtmlMapper] EXACT_MATCH\n" + 
		"src/Test.java HaxMapxxxx [HaxMapxxxx] EXACT_MATCH"
	);
	search("HaMa", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults("");
}
public void testBug124624_HaMa_CamelCase() throws CoreException {
	setupBug124624();
	search("HaMa", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
		"class HashMap {}\n" + 
		"class HtmlMapper {}\n" + 
		"class HashMapEntry {}\n" + 
		"class HatMappage {}\n"
	);
	search("HashMa", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH\n" + 
		"src/Test.java HashMapEntry [HashMapEntry] EXACT_MATCH\n" + 
		"src/Test.java HaxMapxxxx [HaxMapxxxx] EXACT_MATCH"
	);
}
public void testBug124624_HaMa_CamelCaseSamePartCount() throws CoreException {
	setupBug124624();
	search("HaMa", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH\n" + 
		"src/Test.java HaxMapxxxx [HaxMapxxxx] EXACT_MATCH"
		"class HatMappage {}\n"
	);
	search("HashMa", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults("");
}
public void testBug124624_HashMa_CamelCase() throws CoreException {
	setupBug124624();
	search("HashMa", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
		"class HashMap {}\n" + 
		"class HtmlMapper {}\n" + 
		"class HashMapEntry {}\n" + 
		"class HatMappage {}\n"
	);
	search("HashM", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH\n" + 
		"src/Test.java HashMapEntry [HashMapEntry] EXACT_MATCH"
	);
}
public void testBug124624_HashMa_CamelCaseSamePartCount() throws CoreException {
	setupBug124624();
	search("HashMa", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
		"class HashMap {}\n" + 
		"class HtmlMapper {}\n" + 
		"class HashMapEntry {}\n" + 
		"class HatMappage {}\n"
	);
	search("HMap", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH"
	);
}
public void testBug124624_HMap_CamelCase() throws CoreException {
	setupBug124624();
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
		"class HashMap {}\n" + 
		"class HtmlMapper {}\n" + 
		"class HashMapEntry {}\n" + 
		"class HatMappage {}\n"
	);
	search("HMap", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH\n" + 
		"src/Test.java HtmlMapper [HtmlMapper] EXACT_MATCH\n" + 
		"src/Test.java HashMapEntry [HashMapEntry] EXACT_MATCH\n" + 
		"src/Test.java HaxMapxxxx [HaxMapxxxx] EXACT_MATCH"
	);
}
public void testBug124624_HMap_CamelCaseSamePartCount() throws CoreException {
	setupBug124624();
	search("HMap", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
		"class HashMap {}\n" + 
		"class HtmlMapper {}\n" + 
		"class HashMapEntry {}\n" + 
		"class HatMappage {}\n"
	);
	search("HaMap", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH\n" + 
		"src/Test.java HtmlMapper [HtmlMapper] EXACT_MATCH\n" + 
		"src/Test.java HaxMapxxxx [HaxMapxxxx] EXACT_MATCH"
	);
}
public void testBug124624_HaMap_CamelCase() throws CoreException {
	setupBug124624();
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
		"class HashMap {}\n" + 
		"class HtmlMapper {}\n" + 
		"class HashMapEntry {}\n" + 
		"class HatMappage {}\n"
	);
	search("HaMap", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH\n" + 
		"src/Test.java HashMapEntry [HashMapEntry] EXACT_MATCH\n" + 
		"src/Test.java HaxMapxxxx [HaxMapxxxx] EXACT_MATCH"
	);
}
public void testBug124624_HaMap_CamelCaseSamePartCount() throws CoreException {
	setupBug124624();
	search("HaMap", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
		"class HashMap {}\n" + 
		"class HtmlMapper {}\n" + 
		"class HashMapEntry {}\n" + 
		"class HatMappage {}\n"
	);
	search("HashMap", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH\n" + 
		"src/Test.java HaxMapxxxx [HaxMapxxxx] EXACT_MATCH"
	);
}
public void testBug124624_HashMap_CamelCase() throws CoreException {
	setupBug124624();
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
		"class HashMap {}\n" + 
		"class HtmlMapper {}\n" + 
		"class HashMapEntry {}\n" + 
		"class HatMappage {}\n"
	);
	search("HashMap", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH\n" + 
		"src/Test.java HashMapEntry [HashMapEntry] EXACT_MATCH"
	);
}
public void testBug124624_HashMap_CamelCaseSamePartCount() throws CoreException {
	setupBug124624();
	search("HashMap", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH"
	);
}

/**
 * @test Bug 124645: [search] for implementors does not find subclasses of binary classes

		"}\n"
	);
}
public void testBug130390_CamelCase() throws CoreException {
public void testBug130390() throws CoreException {
	setUpBug130390();
	search("NuPoEx", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
	);
}
public void testBug130390_CamelCaseSamePartCount() throws CoreException {
	setUpBug130390();
	search("NuPoEx", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
	);
}
public void testBug130390b_CamelCase() throws CoreException {
public void testBug130390b() throws CoreException {
	setUpBug130390();
	search("NPE", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(

		"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
	);
}
public void testBug130390b_CamelCaseSamePartCount() throws CoreException {
	setUpBug130390();
	search("NPE", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/b130390/Npe.java b130390.Npe [Npe] EXACT_MATCH\n" +
		"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
	);
}
public void testBug130390c_CamelCase() throws CoreException {
public void testBug130390c() throws CoreException {
	setUpBug130390();
	search("NPE", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE);
	assertSearchResults(
		"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
	);
}
public void testBug130390c_CamelCaseSamePartCount() throws CoreException {
	setUpBug130390();
	search("NPE", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH | SearchPattern.R_CASE_SENSITIVE);
	assertSearchResults(
		"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
	);
}
public void testBug130390d_CamelCase() throws CoreException {
public void testBug130390d() throws CoreException {
	setUpBug130390();
	search("Npe", TYPE, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"src/b130390/Npe.java b130390.Npe [Npe] EXACT_MATCH"
	);
}
public void testBug130390d_CamelCaseSamePartCount() throws CoreException {
	setUpBug130390();
	search("Npe", TYPE, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/b130390/Npe.java b130390.Npe [Npe] EXACT_MATCH"
	);
}
public void testBug130390e_CamelCase() throws CoreException {
public void testBug130390e() throws CoreException {
	setUpBug130390();
	search("Npe", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE);
	assertSearchResults(
		"src/b130390/Npe.java b130390.Npe [Npe] EXACT_MATCH"
	);
}
public void testBug130390e_CamelCaseSamePartCount() throws CoreException {
	setUpBug130390();
	search("Npe", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH | SearchPattern.R_CASE_SENSITIVE);
	assertSearchResults(
		"src/b130390/Npe.java b130390.Npe [Npe] EXACT_MATCH"
	);
}
public void testBug130390f_CamelCase() throws CoreException {
public void testBug130390f() throws CoreException {
	setUpBug130390();
	search("NullPE", TYPE, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
	);
}
public void testBug130390f_CamelCaseSamePartCount() throws CoreException {
	setUpBug130390();
	search("NullPE", TYPE, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
	assertSearchResults(
		"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
	);
}
public void testBug130390g_CamelCase() throws CoreException {
public void testBug130390g() throws CoreException {
	setUpBug130390();
	search("TZ", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE);
	assertSearchResults(

		"src/b130390/TimeZone.java b130390.TimeZone [TimeZone] EXACT_MATCH"
	);
}
public void testBug130390g_CamelCaseSamePartCount() throws CoreException {
	setUpBug130390();
	search("TZ", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH | SearchPattern.R_CASE_SENSITIVE);
	assertSearchResults(
		"src/b130390/TZ.java b130390.TZ [TZ] EXACT_MATCH\n" +
		"src/b130390/TimeZone.java b130390.TimeZone [TimeZone] EXACT_MATCH"
	);
}
public void testBug130390h_CamelCase() throws CoreException {
	setUpBug130390();
	search("TiZo", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE);
	assertSearchResults(
		"src/b130390/TimeZone.java b130390.TimeZone [TimeZone] EXACT_MATCH"
	);
}
public void testBug130390h_CamelCaseSamePartCount() throws CoreException {
	setUpBug130390();
	search("TiZo", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH | SearchPattern.R_CASE_SENSITIVE);
	assertSearchResults(
		"src/b130390/TimeZone.java b130390.TimeZone [TimeZone] EXACT_MATCH"
	);
}


 *
 * @bug 137087: Open Type - missing matches when using mixed case pattern
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=137087"
 * @deprecated As using a depreciated constant
 */
public void testBug137087_CamelCase() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "runtimeEx";
	search(pattern, TYPE, DECLARATIONS, matchRule);

		""+ getExternalJCLPathString("1.5") + " java.lang.RuntimeException EXACT_MATCH"
	);
}
public void testBug137087b_CamelCase() throws CoreException {
public void testBug137087b() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "Runtimeex";
	search(pattern, TYPE, DECLARATIONS, matchRule);

		""+ getExternalJCLPathString("1.5") + " java.lang.RuntimeException EXACT_MATCH"
	);
}
public void testBug137087c_CamelCase() throws CoreException {
public void testBug137087c() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "runtimeexception";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.RuntimeException EXACT_MATCH"
			// prefix case sensitive match bu SearchPatter.validateMatchRule(...) (old behavior)
	);
}
public void testBug137087d_CamelCase() throws CoreException {
public void testBug137087d() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "Runtimexception";
	search(pattern, TYPE, DECLARATIONS, matchRule);

		"" // no match expected as pattern is missing a 'e'
	);
}
public void testBug137087e_CamelCase() throws CoreException {
public void testBug137087e() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "IllegalMSException";
	search(pattern, TYPE, DECLARATIONS, matchRule);

		""+ getExternalJCLPathString("1.5") + " java.lang.IllegalMonitorStateException EXACT_MATCH"
	);
}
public void testBug137087f_CamelCase() throws CoreException {
public void testBug137087f() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "illegalMsExceptionSException";
	search(pattern, TYPE, DECLARATIONS, matchRule);

		"" // expected no result as uppercase characters in pattern do not match any camelcase ones in existing types
	);
}
public void testBug137087g_CamelCase() throws CoreException {
public void testBug137087g() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "clonenotsupportedex";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
			// prefix case sensitive match bu SearchPatter.validateMatchRule(...) (old behavior)
	);
}
public void testBug137087h_CamelCase() throws CoreException {
public void testBug137087h() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "CloneNotSupportedEx";
	search(pattern, TYPE, DECLARATIONS, matchRule);

		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
}
public void testBug137087i_CamelCase() throws CoreException {
public void testBug137087i() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "cloneNotsupportedEx";
	search(pattern, TYPE, DECLARATIONS, matchRule);

		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
}
public void testBug137087j_CamelCase() throws CoreException {
public void testBug137087j() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "ClonenotSupportedexc";
	search(pattern, TYPE, DECLARATIONS, matchRule);

		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
}
public void testBug137087k_CamelCase() throws CoreException {
public void testBug137087k() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "cloneNotSupportedExcep";
	search(pattern, TYPE, DECLARATIONS, matchRule);

		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
}
public void testBug137087l_CamelCase() throws CoreException {
public void testBug137087l() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "Clonenotsupportedexception";
	search(pattern, TYPE, DECLARATIONS, matchRule);

		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
}
public void testBug137087m_CamelCase() throws CoreException {
public void testBug137087m() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "CloneNotSupportedException";
	search(pattern, TYPE, DECLARATIONS, matchRule);

		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
}
// Same tests using SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH
public void testBug137087_CamelCaseSamePartCount() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH;
	String pattern = "runtimeEx";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults("");
}
public void testBug137087b_CamelCaseSamePartCount() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH;
	String pattern = "Runtimeex";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults("");
}
public void testBug137087c_CamelCaseSamePartCount() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH;
	String pattern = "runtimeexception";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.RuntimeException EXACT_MATCH"
	);
}
public void testBug137087d_CamelCaseSamePartCount() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH;
	String pattern = "Runtimexception";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		"" // no match expected as pattern is missing a 'e'
	);
}
public void testBug137087e_CamelCaseSamePartCount() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH;
	String pattern = "IllegalMSException";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.IllegalMonitorStateException EXACT_MATCH"
	);
}
public void testBug137087f_CamelCaseSamePartCount() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH;
	String pattern = "illegalMsExceptionSException";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		"" // expected no result as uppercase characters in pattern do not match any camelcase ones in existing types
	);
}
public void testBug137087g_CamelCaseSamePartCount() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH;
	String pattern = "clonenotsupportedex";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
}
public void testBug137087h_CamelCaseSamePartCount() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH;
	String pattern = "CloneNotSupportedEx";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
}
public void testBug137087i_CamelCaseSamePartCount() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH;
	String pattern = "cloneNotsupportedEx";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults("");
}
public void testBug137087j_CamelCaseSamePartCount() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH;
	String pattern = "ClonenotSupportedexc";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults("");
}
public void testBug137087k_CamelCaseSamePartCount() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH;
	String pattern = "cloneNotSupportedExcep";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults("");
}
public void testBug137087l_CamelCaseSamePartCount() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH;
	String pattern = "Clonenotsupportedexception";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults("");
}
public void testBug137087m_CamelCaseSamePartCount() throws CoreException {
	int matchRule = SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH;
	String pattern = "CloneNotSupportedException";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
}

/**
 * Bug 137984: [search] Field references not found when type is a qualified member type [regression]

 * @test Ensure that indexing still works properly after close/restart
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=201064"
 */
public void testBug201064a_CamelCase() throws CoreException {
	TypeNameMatchCollector collector = new TypeNameMatchCollector();
	searchAllTypeNames("CCase", SearchPattern.R_CAMELCASE_MATCH, collector);
	assertSearchResults(
		"CamelCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CamelCaseEntry (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" +
		"CamelCasexxEntry (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" +
		"CatCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CatCasexx (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CxxCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" +
		"CxxxxCasexx (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]",
		collector
	);
}
public void testBug201064b_CamelCase() throws CoreException {
	TypeNameMatchCollector collector = new TypeNameMatchCollector();
	searchAllTypeNames("CaCase", SearchPattern.R_CAMELCASE_MATCH, collector);
	assertSearchResults(
		"CamelCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CamelCaseEntry (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" +
		"CamelCasexxEntry (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" +
		"CatCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CatCasexx (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]",
		collector
	);
}
public void testBug201064c_CamelCase() throws CoreException {
	TypeNameMatchCollector collector = new TypeNameMatchCollector();
	searchAllTypeNames("CamelCase", SearchPattern.R_CAMELCASE_MATCH, collector);
	assertSearchResults(
		"CamelCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CamelCaseEntry (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" +
		"CamelCasexxEntry (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]",
		collector
	);
}
public void testBug201064d_CamelCase() throws CoreException {
	TypeNameMatchCollector collector = new TypeNameMatchCollector();
	searchAllTypeNames("CC", SearchPattern.R_CAMELCASE_MATCH, collector);
	assertSearchResults(
		"CamelCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CamelCaseEntry (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" +
		"CamelCasexxEntry (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" +
		"CatCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CatCasexx (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CxxCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" +
		"CxxxxCasexx (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]",
		collector
	);
}
public void testBug201064e_CamelCase() throws CoreException {
	TypeNameMatchCollector collector = new TypeNameMatchCollector();
	searchAllTypeNames("CaC", SearchPattern.R_CAMELCASE_MATCH, collector);
	assertSearchResults(
		"CamelCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CamelCaseEntry (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" +
		"CamelCasexxEntry (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" +
		"CatCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CatCasexx (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]",
		collector
	);
}
public void testBug201064f_CamelCase() throws CoreException {
	TypeNameMatchCollector collector = new TypeNameMatchCollector();
	searchAllTypeNames("CamelC", SearchPattern.R_CAMELCASE_MATCH, collector);
	assertSearchResults(
		"CamelCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CamelCaseEntry (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" +
		"CamelCasexxEntry (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]",
		collector
	);
}
public void testBug201064g_CamelCase() throws CoreException {
	TypeNameMatchCollector collector = new TypeNameMatchCollector();
	searchAllTypeNames("CCa", SearchPattern.R_CAMELCASE_MATCH, collector);
	assertSearchResults(
		"CamelCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CamelCaseEntry (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" +
		"CamelCasexxEntry (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" +
		"CatCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CatCasexx (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CxxCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" +
		"CxxxxCasexx (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]",
		collector
	);
}
public void testBug201064h_CamelCase() throws CoreException {
	TypeNameMatchCollector collector = new TypeNameMatchCollector();
	searchAllTypeNames("CaCa", SearchPattern.R_CAMELCASE_MATCH, collector);
	assertSearchResults(
		"CamelCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CamelCaseEntry (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" +
		"CamelCasexxEntry (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" +
		"CatCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CatCasexx (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]",
		collector
	);
}
public void testBug201064i_CamelCase() throws CoreException {
	TypeNameMatchCollector collector = new TypeNameMatchCollector();
	searchAllTypeNames("CamelCa", SearchPattern.R_CAMELCASE_MATCH, collector);
	assertSearchResults(
		"CamelCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CamelCaseEntry (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" +
		"CamelCasexxEntry (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]",
		collector
	);
}
// Same tests using SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH
public void testBug201064a_CamelCaseSamePartCount() throws CoreException {
	TypeNameMatchCollector collector = new TypeNameMatchCollector();
	searchAllTypeNames("CCase", SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH, collector);
	assertSearchResults(
		"CamelCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CatCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CatCasexx (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CxxCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" +
		"CxxxxCasexx (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]",
		collector
	);
}
public void testBug201064b_CamelCaseSamePartCount() throws CoreException {
	TypeNameMatchCollector collector = new TypeNameMatchCollector();
	searchAllTypeNames("CaCase", SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH, collector);
	assertSearchResults(
		"CamelCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CatCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CatCasexx (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]",
		collector
	);
}
public void testBug201064c_CamelCaseSamePartCount() throws CoreException {
	TypeNameMatchCollector collector = new TypeNameMatchCollector();
	searchAllTypeNames("CamelCase", SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH, collector);
	assertSearchResults(
		"CamelCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]",
		collector
	);
}
public void testBug201064d_CamelCaseSamePartCount() throws CoreException {
	TypeNameMatchCollector collector = new TypeNameMatchCollector();
	searchAllTypeNames("CC", SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH, collector);
	assertSearchResults(
		"CamelCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CatCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CatCasexx (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CxxCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" +
		"CxxxxCasexx (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]",
		collector
	);
}
public void testBug201064e_CamelCaseSamePartCount() throws CoreException {
	TypeNameMatchCollector collector = new TypeNameMatchCollector();
	searchAllTypeNames("CaC", SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH, collector);
	assertSearchResults(
		"CamelCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CatCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 

		collector
	);
}
public void testBug201064f_CamelCaseSamePartCount() throws CoreException {
	TypeNameMatchCollector collector = new TypeNameMatchCollector();
	searchAllTypeNames("CamelC", SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH, collector);
	assertSearchResults(
		"CamelCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]",
		collector
	);
}
public void testBug201064g_CamelCaseSamePartCount() throws CoreException {
	TypeNameMatchCollector collector = new TypeNameMatchCollector();
	searchAllTypeNames("CCa", SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH, collector);
	assertSearchResults(
		"CamelCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CatCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CatCasexx (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CxxCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" +
		"CxxxxCasexx (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]",
		collector
	);
}
public void testBug201064h_CamelCaseSamePartCount() throws CoreException {
	TypeNameMatchCollector collector = new TypeNameMatchCollector();
	searchAllTypeNames("CaCa", SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH, collector);
	assertSearchResults(
		"CamelCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CatCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]\n" + 
		"CatCasexx (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]",
		collector
	);
}
public void testBug201064i_CamelCaseSamePartCount() throws CoreException {
	TypeNameMatchCollector collector = new TypeNameMatchCollector();
	searchAllTypeNames("CamelCa", SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH, collector);
	assertSearchResults(
		"CamelCase (not open) [in CamelCase.java [in b201064 [in src [in JavaSearchBugs]]]]",
		collector
	);
}

/**

	try {
		addLibraryEntry(javaProject, new Path("/JavaSearchBugs/b204652.jar"), false/*not exported*/);
		TypeNameMatchCollector collector = new TypeNameMatchCollector();
		searchAllTypeNames("b204652", null, SearchPattern.R_PREFIX_MATCH, collector);
			"b204652".toCharArray(),
			SearchPattern.R_EXACT_MATCH,
			null,
			SearchPattern.R_PREFIX_MATCH,
			IJavaSearchConstants.TYPE,
			getJavaSearchScope(),
			collector,
			IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
			null);
		IPackageFragment pkg = getPackage("/JavaSearchBugs/b204652.jar/b204652");
		pkg.open(null);
		IType result = (IType) collector.matches.get(0);

		javaProject.setRawClasspath(originalRawClasspath, null);
	}
}

}




		SearchPattern.R_PATTERN_MATCH | SearchPattern.R_PREFIX_MATCH,
		SearchPattern.R_PREFIX_MATCH);
}
/** @deprecated As using a depreciated constant */
public void testSearchPatternValidMatchRule05() {
	assertValidMatchRule("foo",
		SearchPattern.R_CAMELCASE_MATCH,
		SearchPattern.R_PREFIX_MATCH);
}
public void testSearchPatternValidMatchRule06() {
	assertValidMatchRule("foo",
		SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH,
		SearchPattern.R_PREFIX_MATCH);
}
public void testSearchPatternValidMatchRule10() {

		SearchPattern.R_PATTERN_MATCH | SearchPattern.R_PREFIX_MATCH,
		SearchPattern.R_PATTERN_MATCH);
}
/** @deprecated As using a depreciated constant */
public void testSearchPatternValidMatchRule14() {
	assertValidMatchRule("CP*P",
		SearchPattern.R_CAMELCASE_MATCH,

}
public void testSearchPatternValidMatchRule15() {
	assertValidMatchRule("CP*P",
		SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH,
		SearchPattern.R_PATTERN_MATCH);
}
/** @deprecated As using a depreciated constant */
public void testSearchPatternValidMatchRule20() {
	assertValidMatchRule("NPE", 
		SearchPattern.R_CAMELCASE_MATCH);
}
/** @deprecated As using a depreciated constant */
public void testSearchPatternValidMatchRule21() {
	assertValidMatchRule("NPE",
		SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE,
		SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE);
}
/** @deprecated As using a depreciated constant */
public void testSearchPatternValidMatchRule22() {
	assertValidMatchRule("nPE",
		SearchPattern.R_CAMELCASE_MATCH);
}
/** @deprecated As using a depreciated constant */
public void testSearchPatternValidMatchRule23() {
	assertValidMatchRule("NuPoEx", 
		SearchPattern.R_CAMELCASE_MATCH);
}
/** @deprecated As using a depreciated constant */
public void testSearchPatternValidMatchRule24() {
	assertValidMatchRule("oF",
		SearchPattern.R_CAMELCASE_MATCH);
}
public void testSearchPatternValidMatchRule30() {
	assertValidMatchRule("NPE",
		SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
}
public void testSearchPatternValidMatchRule31() {
	assertValidMatchRule("NPE",
		SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH | SearchPattern.R_PREFIX_MATCH,
		SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
}
public void testSearchPatternValidMatchRule32() {
	assertValidMatchRule("NPE",
		SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH | SearchPattern.R_CASE_SENSITIVE);
}
public void testSearchPatternValidMatchRule33() {
	assertValidMatchRule("NPE",
		SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH | SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE,
		SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH | SearchPattern.R_CASE_SENSITIVE);
}
public void testSearchPatternValidMatchRule34() {
	assertValidMatchRule("nPE",
		SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
}
public void testSearchPatternValidMatchRule35() {
	assertValidMatchRule("NuPoEx", 
		SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
}
public void testSearchPatternValidMatchRule36() {
	assertValidMatchRule("oF",
		SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
}
/** @deprecated As using a depreciated constant */
public void testSearchPatternValidMatchRule40() {
	assertValidMatchRule("Nu/Po/Ex",
		SearchPattern.R_CAMELCASE_MATCH,
		SearchPattern.R_PREFIX_MATCH);
}
/** @deprecated As using a depreciated constant */
public void testSearchPatternValidMatchRule41() {
	assertValidMatchRule("Nu.Po.Ex",
		SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_PREFIX_MATCH,
		SearchPattern.R_PREFIX_MATCH);
}
/** @deprecated As using a depreciated constant */
public void testSearchPatternValidMatchRule42() {
	assertValidMatchRule("hashMap",
		SearchPattern.R_CAMELCASE_MATCH);
}
/** @deprecated As using a depreciated constant */
public void testSearchPatternValidMatchRule43() {
	assertValidMatchRule("Hashmap",
		SearchPattern.R_CAMELCASE_MATCH,
		SearchPattern.R_CAMELCASE_MATCH);
}
public void testSearchPatternValidMatchRule44() {
	assertValidMatchRule("Nu/Po/Ex",
		SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH,
		SearchPattern.R_PREFIX_MATCH);
}
public void testSearchPatternValidMatchRule45() {
	assertValidMatchRule("Nu.Po.Ex",
		SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH | SearchPattern.R_PREFIX_MATCH,
		SearchPattern.R_PREFIX_MATCH);
}
public void testSearchPatternValidMatchRule46() {
	assertValidMatchRule("hashMap",
		SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
}
public void testSearchPatternValidMatchRule47() {
	assertValidMatchRule("Hashmap",
		SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH,
		SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
}

/**

Lines 659-668 Link Here

(-)src/org/eclipse/jdt/core/tests/model/AbstractJavaSearchTests.java (-2 / +5 lines)
659	);	659	);
660	}	660	}
661	protected void searchAllTypeNames(String pattern, int matchRule, TypeNameMatchCollector collector) throws JavaModelException {	661	protected void searchAllTypeNames(String pattern, int matchRule, TypeNameMatchCollector collector) throws JavaModelException {
		662	searchAllTypeNames(null, pattern, matchRule, collector);
		663	}
		664	protected void searchAllTypeNames(String packagePattern, String typePattern, int matchRule, TypeNameMatchCollector collector) throws JavaModelException {
662	new SearchEngine(this.workingCopies).searchAllTypeNames(	665	new SearchEngine(this.workingCopies).searchAllTypeNames(
663	null,	666	packagePattern==null ? null : packagePattern.toCharArray(),
664	SearchPattern.R_EXACT_MATCH,	667	SearchPattern.R_EXACT_MATCH,
665	pattern.toCharArray(),	668	typePattern==null ? null : typePattern.toCharArray(),
666	matchRule,	669	matchRule,
667	TYPE,	670	TYPE,
668	getJavaSearchScope(),	671	getJavaSearchScope(),




 * @bug 199392: [search] Type Dialog Error 'Items filtering ... Reason: Class file name must end with .class'
 * @test Ensure that types are found even in project which name ends either with ".jar" or ".zip"
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=199392"
 * @deprecated As using a depreciated constant
 */
public void testBug199392_Jar() throws CoreException {
	try {

		deleteProject("Test.jar");
	}
}
public void testBug199392_Jar_SamePartCount() throws CoreException {
	try {
		IJavaProject project = createJavaProject("Test.jar");
		createFolder("/Test.jar/test");

			null,
			SearchPattern.R_EXACT_MATCH,
			new char[] { 'M', 'y' },
			SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH,
			IJavaSearchConstants.TYPE,
			scope,
			collector,
			IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
			null);
		assertEquals("Found types sounds not to be correct", 
			"",
			collector.toString()
		);
	} finally {
		deleteProject("Test.jar");
	}
}
/** @deprecated As using a depreciated constant */
public void testBug199392_Zip() throws CoreException {
	try {
		IJavaProject project = createJavaProject("Test.zip");

		deleteProject("Test.zip");
	}
}
public void testBug199392_Zip_SamePartCount() throws CoreException {
	try {
		IJavaProject project = createJavaProject("Test.zip");
		createFolder("/Test.zip/test");

			null,
			SearchPattern.R_EXACT_MATCH,
			new char[] { 'M', 'y' },
			SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH,
			IJavaSearchConstants.TYPE,
			scope,
			collector,
			IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
			null);
		assertEquals("Found types sounds not to be correct", 
			"",
			collector.toString()
		);
	} finally {




 * If result is invalid then store warning in buffer and display it.
 */
void assertCamelCase(String pattern, String name, boolean match) {
	assertCamelCase(pattern, name, false /* name may have more parts*/, match);
}
/**
 * Assert that a pattern and a name matches or not.


// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=109695
public void test70() throws CoreException {
	assertCamelCase("IDE3", "IDocumentExtension", true /*same part count*/, false /* should not match */);
	assertCamelCase("IDE3", "IDocumentExtension2", true /*same part count*/, false /* should not match */);
	assertCamelCase("IDE3", "IDocumentExtension3", true /*same part count*/, true /* should match */);
	assertCamelCase("IDE3", "IDocumentExtension135", true /*same part count*/, true /* should match */);
	assertCamelCase("IDE3", "IDocumentExtension315", true /*same part count*/, true /* should match */);
	assertCamelCase("IDPE3", "IDocumentProviderExtension", true /*same part count*/, false /* should not match */);
	assertCamelCase("IDPE3", "IDocumentProviderExtension2", true /*same part count*/, false /* should not match */);
	assertCamelCase("IDPE3", "IDocumentProviderExtension4", true /*same part count*/, false /* should not match */);
	assertCamelCase("IDPE3", "IDocumentProviderExtension3", true /*same part count*/, true /* should match */);
	assertCamelCase("IDPE3", "IDocumentProviderExtension5", true /*same part count*/, false /* should not match */);
	assertCamelCase("IDPE3", "IDocumentProviderExtension54321", true /*same part count*/, true /* should match */);
	assertCamelCase("IDPE3", "IDocumentProviderExtension12345", true /*same part count*/, true /* should match */);
	assertCamelCase("IPL3", "IPerspectiveListener", true /*same part count*/, false /* should not match */);
	assertCamelCase("IPL3", "IPerspectiveListener2", true /*same part count*/, false /* should not match */);
	assertCamelCase("IPL3", "IPerspectiveListener3", true /*same part count*/, true /* should match */);
	assertCamelCase("IPS2", "IPropertySource", true /*same part count*/, false /* should not match */);
	assertCamelCase("IPS2", "IPropertySource2", true /*same part count*/, true /* should match */);
	assertCamelCase("IWWPD2", "IWorkbenchWindowPulldownDelegate", true /*same part count*/, false /* should not match */);
	assertCamelCase("IWWPD2", "IWorkbenchWindowPulldownDelegate2", true /*same part count*/, true /* should match */);
	assertCamelCase("UTF16DSS", "UTF16DocumentScannerSupport", true /*same part count*/, true /* should match */);
	assertCamelCase("UTF16DSS", "UTF1DocScannerSupport", true /*same part count*/, false /* should not match */);
	assertCamelCase("UTF16DSS", "UTF6DocScannerSupport", true /*same part count*/, false /* should not match */);
	assertCamelCase("UTF16DSS", "UTFDocScannerSupport", true /*same part count*/, false /* should not match */);
	assertCamelCase("UTF1DSS", "UTF16DocumentScannerSupport", true /*same part count*/, true /* should match */);
	assertCamelCase("UTF1DSS", "UTF1DocScannerSupport", true /*same part count*/, true /* should match */);
	assertCamelCase("UTF1DSS", "UTF6DocScannerSupport", true /*same part count*/, false /* should not match */);
	assertCamelCase("UTF1DSS", "UTFDocScannerSupport", true /*same part count*/, false /* should not match */);
	assertCamelCase("UTF6DSS", "UTF16DocumentScannerSupport", true /*same part count*/, true /* should match */);
	assertCamelCase("UTF6DSS", "UTF1DocScannerSupport", true /*same part count*/, false /* should not match */);
	assertCamelCase("UTF6DSS", "UTF6DocScannerSupport", true /*same part count*/, true /* should match */);
	assertCamelCase("UTF6DSS", "UTFDocScannerSupport", true /*same part count*/, false /* should not match */);
	assertCamelCase("UTFDSS", "UTF16DocumentScannerSupport", true /*same part count*/, true /* should match */);
	assertCamelCase("UTFDSS", "UTF1DocScannerSupport", true /*same part count*/, true /* should match */);
	assertCamelCase("UTFDSS", "UTF6DocScannerSupport", true /*same part count*/, true /* should match */);
	assertCamelCase("UTFDSS", "UTFDocScannerSupport", true /*same part count*/, true /* should match */);
	// Verify that there were no unexpected results
    assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
}
// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=124624
public void test71() {
	assertCamelCase("HM", "HashMap", true /*same count of parts expected*/, true /*should match*/);
	assertCamelCase("HM", "HtmlMapper", true /*same count of parts expected*/, true /*should match*/);
	assertCamelCase("HM", "HashMapEntry", true /*same count of parts expected*/, false /* should not match */);
	assertCamelCase("HaM", "HashMap", true /*same count of parts expected*/, true /* should match */);
	assertCamelCase("HaM", "HtmlMapper", true /*same count of parts expected*/, false /* should not match */);
	assertCamelCase("HaM", "HashMapEntry", true /*same count of parts expected*/, false /* should not match */);
	assertCamelCase("HashM", "HashMap", true /*same count of parts expected*/, true /* should match */);
	assertCamelCase("HashM", "HtmlMapper", true /*same count of parts expected*/, false /* should not match */);
	assertCamelCase("HashM", "HashMapEntry", true /*same count of parts expected*/, false /* should not match */);
	// Verify that there were no unexpected results
    assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
}

}
// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=124624
public void test72() {
	assertCamelCase("HMa", "HashMap", true /*same count of parts expected*/, true /* should match */);
	assertCamelCase("HMa", "HtmlMapper", true /*same count of parts expected*/, true /* should match */);
	assertCamelCase("HMa", "HashMapEntry", true /*same count of parts expected*/, false /* should not match */);
	assertCamelCase("HaMa", "HashMap", true /*same count of parts expected*/, true /* should match */);
	assertCamelCase("HaMa", "HtmlMapper", true /*same count of parts expected*/, false /* should not match */);
	assertCamelCase("HaMa", "HashMapEntry", true /*same count of parts expected*/, false /* should not match */);
	assertCamelCase("HashMa", "HashMap", true /*same count of parts expected*/, true /* should match */);
	assertCamelCase("HashMa", "HtmlMapper", true /*same count of parts expected*/, false /* should not match */);
	assertCamelCase("HashMa", "HashMapEntry", true /*same count of parts expected*/, false /* should not match */);
	// Verify that there were no unexpected results
    assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
}

}
// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=124624
public void test73() {
	assertCamelCase("HMap", "HashMap", true /*same count of parts expected*/, true /*should match*/);
	assertCamelCase("HMap", "HtmlMapper", true /*same count of parts expected*/, true /* should not match */);
	assertCamelCase("HMap", "HashMapEntry", true /*same count of parts expected*/, false /* should not match */);
	assertCamelCase("HaMap", "HashMap", true /*same count of parts expected*/, true /* should match */);
	assertCamelCase("HaMap", "HtmlMapper", true /*same count of parts expected*/, false /* should not match */);
	assertCamelCase("HaMap", "HashMapEntry", true /*same count of parts expected*/, false /* should not match */);
	assertCamelCase("HashMap", "HashMap", true /*same count of parts expected*/, true /* should match */);
	assertCamelCase("HashMap", "HtmlMapper", true /*same count of parts expected*/, false /* should not match */);
	assertCamelCase("HashMap", "HashMapEntry", true /*same count of parts expected*/, false /* should not match */);
	// Verify that there were no unexpected results
    assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
}

Return to bug 201426

Lines 308-314 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/MethodPattern.java (-1 / +4 lines)
308		308
309	switch(getMatchMode()) {	309	switch(getMatchMode()) {
310	case R_EXACT_MATCH :	310	case R_EXACT_MATCH :
311	if (this.isCamelCase) break;
312	if (this.selector != null && this.parameterCount >= 0 && !this.varargs)	311	if (this.selector != null && this.parameterCount >= 0 && !this.varargs)
313	key = createIndexKey(this.selector, this.parameterCount);	312	key = createIndexKey(this.selector, this.parameterCount);
314	else { // do a prefix query with the selector	313	else { // do a prefix query with the selector
Lines 329-334 Link Here
329	case R_REGEXP_MATCH :	328	case R_REGEXP_MATCH :
330	// TODO (frederic) implement regular expression match	329	// TODO (frederic) implement regular expression match
331	break;	330	break;
		331	case R_CAMELCASE_MATCH:
		332	case R_CAMELCASE_SAME_PART_COUNT_MATCH:
		333	// do a prefix query with the selector
		334	break;
332	}	335	}
333		336
334	return index.query(getIndexCategories(), key, matchRule); // match rule is irrelevant when the key is null	337	return index.query(getIndexCategories(), key, matchRule); // match rule is irrelevant when the key is null

Lines 23-29 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/PatternLocator.java (-24 / +45 lines)
23	// store pattern info	23	// store pattern info
24	protected int matchMode;	24	protected int matchMode;
25	protected boolean isCaseSensitive;	25	protected boolean isCaseSensitive;
26	protected boolean isCamelCase;
27	protected boolean isEquivalentMatch;	26	protected boolean isEquivalentMatch;
28	protected boolean isErasureMatch;	27	protected boolean isErasureMatch;
29	protected boolean mustResolve;	28	protected boolean mustResolve;
Lines 118-124 Link Here
118	public PatternLocator(SearchPattern pattern) {	117	public PatternLocator(SearchPattern pattern) {
119	int matchRule = pattern.getMatchRule();	118	int matchRule = pattern.getMatchRule();
120	this.isCaseSensitive = (matchRule & SearchPattern.R_CASE_SENSITIVE) != 0;	119	this.isCaseSensitive = (matchRule & SearchPattern.R_CASE_SENSITIVE) != 0;
121	this.isCamelCase = (matchRule & SearchPattern.R_CAMEL_CASE_MATCH) != 0;
122	this.isErasureMatch = (matchRule & SearchPattern.R_ERASURE_MATCH) != 0;	120	this.isErasureMatch = (matchRule & SearchPattern.R_ERASURE_MATCH) != 0;
123	this.isEquivalentMatch = (matchRule & SearchPattern.R_EQUIVALENT_MATCH) != 0;	121	this.isEquivalentMatch = (matchRule & SearchPattern.R_EQUIVALENT_MATCH) != 0;
124	this.matchMode = matchRule & JavaSearchPattern.MATCH_MODE_MASK;	122	this.matchMode = matchRule & JavaSearchPattern.MATCH_MODE_MASK;
Lines 282-304 Link Here
282	boolean matchFirstChar = !this.isCaseSensitive \|\| pattern[0] == name[0];	280	boolean matchFirstChar = !this.isCaseSensitive \|\| pattern[0] == name[0];
283	boolean sameLength = pattern.length == name.length;	281	boolean sameLength = pattern.length == name.length;
284	boolean canBePrefix = name.length >= pattern.length;	282	boolean canBePrefix = name.length >= pattern.length;
285	if (this.isCamelCase) {
286	if (matchFirstChar && CharOperation.camelCaseMatch(pattern, name, (this.matchMode & SearchPattern.R_PREFIX_MATCH) != 0)) {
287	return POSSIBLE_MATCH;
288	}
289	if (this.isCaseSensitive) return IMPOSSIBLE_MATCH;
290	}
291	switch (this.matchMode) {	283	switch (this.matchMode) {
292	case SearchPattern.R_EXACT_MATCH:	284	case SearchPattern.R_EXACT_MATCH:
293	if (sameLength && matchFirstChar && CharOperation.equals(pattern, name, this.isCaseSensitive)) {	285	if (sameLength && matchFirstChar && CharOperation.equals(pattern, name, this.isCaseSensitive)) {
294	return POSSIBLE_MATCH \| EXACT_FLAVOR;	286	return POSSIBLE_MATCH \| EXACT_FLAVOR;
295	}	287	}
296	break;	288	break;
		289
297	case SearchPattern.R_PREFIX_MATCH:	290	case SearchPattern.R_PREFIX_MATCH:
298	if (canBePrefix && matchFirstChar && CharOperation.prefixEquals(pattern, name, this.isCaseSensitive)) {	291	if (canBePrefix && matchFirstChar && CharOperation.prefixEquals(pattern, name, this.isCaseSensitive)) {
299	return POSSIBLE_MATCH;	292	return POSSIBLE_MATCH;
300	}	293	}
301	break;	294	break;
		295
302	case SearchPattern.R_PATTERN_MATCH:	296	case SearchPattern.R_PATTERN_MATCH:
303	// TODO_PERFS (frederic) Not sure this lowercase is necessary	297	// TODO_PERFS (frederic) Not sure this lowercase is necessary
304	if (!this.isCaseSensitive) {	298	if (!this.isCaseSensitive) {
Lines 308-316 Link Here
308	return POSSIBLE_MATCH;	302	return POSSIBLE_MATCH;
309	}	303	}
310	break;	304	break;
		305
311	case SearchPattern.R_REGEXP_MATCH :	306	case SearchPattern.R_REGEXP_MATCH :
312	// TODO (frederic) implement regular expression match	307	// TODO (frederic) implement regular expression match
313	break;	308	break;
		309
		310	case SearchPattern.R_CAMELCASE_MATCH:
		311	if (CharOperation.camelCaseMatch(pattern, name, false)) {
		312	return POSSIBLE_MATCH;
		313	}
		314	// if camel case does not match then try a insensitive prefix match if allowed
		315	if (!this.isCaseSensitive && CharOperation.prefixEquals(pattern, name, false)) {
		316	return POSSIBLE_MATCH;
		317	}
		318	break;
		319
		320	case SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH:
		321	if (CharOperation.camelCaseMatch(pattern, name, true)) {
		322	return POSSIBLE_MATCH;
		323	}
		324	break;
314	}	325	}
315	return IMPOSSIBLE_MATCH;	326	return IMPOSSIBLE_MATCH;
316	}	327	}
Lines 712-736 Link Here
712	sourceName = getQualifiedSourceName(binding);	723	sourceName = getQualifiedSourceName(binding);
713	}	724	}
714	if (sourceName == null) return IMPOSSIBLE_MATCH;	725	if (sourceName == null) return IMPOSSIBLE_MATCH;
715	if ((this.matchMode & SearchPattern.R_PREFIX_MATCH) != 0) {	726	switch (this.matchMode) {
716	if (CharOperation.prefixEquals(qualifiedPattern, sourceName, this.isCaseSensitive)) {	727	case SearchPattern.R_PREFIX_MATCH:
717	return ACCURATE_MATCH;	728	if (CharOperation.prefixEquals(qualifiedPattern, sourceName, this.isCaseSensitive)) {
718	}	729	return ACCURATE_MATCH;
719	}	730	}
720	if (this.isCamelCase) {	731	break;
721	if ((qualifiedPattern.length>0 && sourceName.length>0 && qualifiedPattern[0] == sourceName[0])) {	732	case SearchPattern.R_CAMELCASE_MATCH:
722	if (CharOperation.camelCaseMatch(qualifiedPattern, sourceName, (this.matchMode & SearchPattern.R_PREFIX_MATCH) != 0)) {	733	if ((qualifiedPattern.length>0 && sourceName.length>0 && qualifiedPattern[0] == sourceName[0])) {
		734	if (CharOperation.camelCaseMatch(qualifiedPattern, sourceName, false)) {
		735	return ACCURATE_MATCH;
		736	}
		737	}
		738	if (!this.isCaseSensitive && CharOperation.prefixEquals(qualifiedPattern, sourceName, false)) {
		739	return ACCURATE_MATCH;
		740	}
		741	break;
		742	case SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH:
		743	if ((qualifiedPattern.length>0 && sourceName.length>0 && qualifiedPattern[0] == sourceName[0])) {
		744	if (CharOperation.camelCaseMatch(qualifiedPattern, sourceName, true)) {
		745	return ACCURATE_MATCH;
		746	}
		747	}
		748	break;
		749	default:
		750	if (CharOperation.match(qualifiedPattern, sourceName, this.isCaseSensitive)) {
723	return ACCURATE_MATCH;	751	return ACCURATE_MATCH;
724	}	752	}
725	}
726	if (!this.isCaseSensitive && this.matchMode == SearchPattern.R_EXACT_MATCH) {
727	boolean matchPattern = CharOperation.equals(qualifiedPattern, sourceName, false);
728	return matchPattern ? ACCURATE_MATCH : IMPOSSIBLE_MATCH;
729	}
730	}	753	}
731	boolean matchPattern = CharOperation.match(qualifiedPattern, sourceName, this.isCaseSensitive);	754	return IMPOSSIBLE_MATCH;
732	return matchPattern ? ACCURATE_MATCH : IMPOSSIBLE_MATCH;
733
734	}	755	}
735		756
736	/**	757	/**

Lines 565-576 Link Here

(-)search/org/eclipse/jdt/core/search/SearchEngine.java (-32 / +57 lines)
565	* May be <code>null</code>, then any type name is accepted.	565	* May be <code>null</code>, then any type name is accepted.
566	* @param matchRule type name match rule one of	566	* @param matchRule type name match rule one of
567	* <ul>	567	* <ul>
568	* <li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type name are the full names	568	* <li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type
569	* of the searched types.</li>	569	* name are the full names of the searched types.</li>
570	* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type name are prefixes of the names	570	* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type
571	* of the searched types.</li>	571	* name are prefixes of the names of the searched types.</li>
572	* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and type name contain wild-cards.</li>	572	* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and
573	* <li>{@link SearchPattern#R_CAMEL_CASE_MATCH} if type name are camel case of the names of the searched types.</li>	573	* type name contain wild-cards.</li>
		574	* <li>{@link SearchPattern#R_CAMELCASE_MATCH} if the type name is a
		575	* camel case of the searched types name.</li>
		576	* <li>{@link SearchPattern#R_CAMELCASE_SAME_PART_COUNT_MATCH}
		577	* if the type name is a camel case with same part count of the searched
		578	* types name.</li>
574	* </ul>	579	* </ul>
575	* combined with {@link SearchPattern#R_CASE_SENSITIVE},	580	* combined with {@link SearchPattern#R_CASE_SENSITIVE},
576	* e.g. {@link SearchPattern#R_EXACT_MATCH} \| {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested,	581	* e.g. {@link SearchPattern#R_EXACT_MATCH} \| {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested,
Lines 632-655 Link Here
632	* May be <code>null</code>, then any type name is accepted.	637	* May be <code>null</code>, then any type name is accepted.
633	* @param packageMatchRule one of	638	* @param packageMatchRule one of
634	* <ul>	639	* <ul>
635	* <li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type name are the full names	640	* <li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type
636	* of the searched types.</li>	641	* name are the full names of the searched types.</li>
637	* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type name are prefixes of the names	642	* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type
638	* of the searched types.</li>	643	* name are prefixes of the names of the searched types.</li>
639	* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and type name contain wild-cards.</li>	644	* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and
640	* <li>{@link SearchPattern#R_CAMEL_CASE_MATCH} if type name are camel case of the names of the searched types.</li>	645	* type name contain wild-cards.</li>
		646	* <li>{@link SearchPattern#R_CAMELCASE_MATCH} if the package name is a
		647	* camel case of the searched types package name.</li>
		648	* <li>{@link SearchPattern#R_CAMELCASE_SAME_PART_COUNT_MATCH}
		649	* if the package name is a camel case with same part count of the searched
		650	* types package name.</li>
641	* </ul>	651	* </ul>
642	* combined with {@link SearchPattern#R_CASE_SENSITIVE},	652	* combined with {@link SearchPattern#R_CASE_SENSITIVE},
643	* e.g. {@link SearchPattern#R_EXACT_MATCH} \| {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested,	653	* e.g. {@link SearchPattern#R_EXACT_MATCH} \| {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested,
644	* or {@link SearchPattern#R_PREFIX_MATCH} if a prefix non case sensitive match is requested.	654	* or {@link SearchPattern#R_PREFIX_MATCH} if a prefix non case sensitive match is requested.
645	* @param typeMatchRule one of	655	* @param typeMatchRule one of
646	* <ul>	656	* <ul>
647	* <li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type name are the full names	657	* <li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type
648	* of the searched types.</li>	658	* name are the full names of the searched types.</li>
649	* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type name are prefixes of the names	659	* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type
650	* of the searched types.</li>	660	* name are prefixes of the names of the searched types.</li>
651	* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and type name contain wild-cards.</li>	661	* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and
652	* <li>{@link SearchPattern#R_CAMEL_CASE_MATCH} if type name are camel case of the names of the searched types.</li>	662	* type name contain wild-cards.</li>
		663	* <li>{@link SearchPattern#R_CAMELCASE_MATCH} if the type name is a
		664	* camel case of the searched types name.</li>
		665	* <li>{@link SearchPattern#R_CAMELCASE_SAME_PART_COUNT_MATCH}
		666	* if the type name is a camel case with same part count of the searched
		667	* types name.</li>
653	* </ul>	668	* </ul>
654	* combined with {@link SearchPattern#R_CASE_SENSITIVE},	669	* combined with {@link SearchPattern#R_CASE_SENSITIVE},
655	* e.g. {@link SearchPattern#R_EXACT_MATCH} \| {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested,	670	* e.g. {@link SearchPattern#R_EXACT_MATCH} \| {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested,
Lines 697-703 Link Here
697	this.basicEngine.searchAllTypeNames(packageName,	712	this.basicEngine.searchAllTypeNames(packageName,
698	packageMatchRule,	713	packageMatchRule,
699	typeName,	714	typeName,
700	SearchPattern.updateMatchRule(typeMatchRule),	715	typeMatchRule,
701	searchFor,	716	searchFor,
702	scope,	717	scope,
703	requestorWrapper,	718	requestorWrapper,
Lines 719-730 Link Here
719	* May be <code>null</code>, then any package name is accepted.	734	* May be <code>null</code>, then any package name is accepted.
720	* @param packageMatchRule one of	735	* @param packageMatchRule one of
721	* <ul>	736	* <ul>
722	* <li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type name are the full names	737	* <li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type
723	* of the searched types.</li>	738	* name are the full names of the searched types.</li>
724	* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type name are prefixes of the names	739	* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type
725	* of the searched types.</li>	740	* name are prefixes of the names of the searched types.</li>
726	* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and type name contain wild-cards.</li>	741	* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and
727	* <li>{@link SearchPattern#R_CAMEL_CASE_MATCH} if type name are camel case of the names of the searched types.</li>	742	* type name contain wild-cards.</li>
		743	* <li>{@link SearchPattern#R_CAMELCASE_MATCH} if the package name is a
		744	* camel case of the searched types package name.</li>
		745	* <li>{@link SearchPattern#R_CAMELCASE_SAME_PART_COUNT_MATCH}
		746	* if the package name is a camel case with same part count of the searched
		747	* types package name.</li>
728	* </ul>	748	* </ul>
729	* combined with {@link SearchPattern#R_CASE_SENSITIVE},	749	* combined with {@link SearchPattern#R_CASE_SENSITIVE},
730	* e.g. {@link SearchPattern#R_EXACT_MATCH} \| {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested,	750	* e.g. {@link SearchPattern#R_EXACT_MATCH} \| {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested,
Lines 735-746 Link Here
735	* May be <code>null</code>, then any type name is accepted.	755	* May be <code>null</code>, then any type name is accepted.
736	* @param typeMatchRule one of	756	* @param typeMatchRule one of
737	* <ul>	757	* <ul>
738	* <li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type name are the full names	758	* <li>{@link SearchPattern#R_EXACT_MATCH} if the package name and type
739	* of the searched types.</li>	759	* name are the full names of the searched types.</li>
740	* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type name are prefixes of the names	760	* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type
741	* of the searched types.</li>	761	* name are prefixes of the names of the searched types.</li>
742	* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and type name contain wild-cards.</li>	762	* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and
743	* <li>{@link SearchPattern#R_CAMEL_CASE_MATCH} if type name are camel case of the names of the searched types.</li>	763	* type name contain wild-cards.</li>
		764	* <li>{@link SearchPattern#R_CAMELCASE_MATCH} if the type name is a
		765	* camel case of the searched types name.</li>
		766	* <li>{@link SearchPattern#R_CAMELCASE_SAME_PART_COUNT_MATCH}
		767	* if the type name is a camel case with same part count of the searched
		768	* types name.</li>
744	* </ul>	769	* </ul>
745	* combined with {@link SearchPattern#R_CASE_SENSITIVE},	770	* combined with {@link SearchPattern#R_CASE_SENSITIVE},
746	* e.g. {@link SearchPattern#R_EXACT_MATCH} \| {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested,	771	* e.g. {@link SearchPattern#R_EXACT_MATCH} \| {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested,
Lines 789-795 Link Here
789	this.basicEngine.searchAllTypeNames(packageName,	814	this.basicEngine.searchAllTypeNames(packageName,
790	packageMatchRule,	815	packageMatchRule,
791	typeName,	816	typeName,
792	SearchPattern.updateMatchRule(typeMatchRule),	817	typeMatchRule,
793	searchFor,	818	searchFor,
794	scope,	819	scope,
795	requestorWrapper,	820	requestorWrapper,

Lines 1022-1036 Link Here

(-)src/org/eclipse/jdt/core/tests/model/SearchTests.java (-27 / +20 lines)
1022	SearchPattern.R_PATTERN_MATCH \| SearchPattern.R_PREFIX_MATCH,	1022	SearchPattern.R_PATTERN_MATCH \| SearchPattern.R_PREFIX_MATCH,
1023	SearchPattern.R_PREFIX_MATCH);	1023	SearchPattern.R_PREFIX_MATCH);
1024	}	1024	}
1025	/** @deprecated As using a depreciated constant */
1026	public void testSearchPatternValidMatchRule05() {	1025	public void testSearchPatternValidMatchRule05() {
1027	assertValidMatchRule("foo",	1026	assertValidMatchRule("foo",
1028	SearchPattern.R_CAMELCASE_MATCH,	1027	SearchPattern.R_CAMELCASE_MATCH,
1029	SearchPattern.R_PREFIX_MATCH \| SearchPattern.R_CASE_SENSITIVE);	1028	SearchPattern.R_PREFIX_MATCH);
1030	}	1029	}
1031	public void testSearchPatternValidMatchRule06() {	1030	public void testSearchPatternValidMatchRule06() {
1032	assertValidMatchRule("foo",	1031	assertValidMatchRule("foo",
1033	SearchPattern.R_CAMEL_CASE_MATCH,	1032	SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH,
1034	SearchPattern.R_PREFIX_MATCH);	1033	SearchPattern.R_PREFIX_MATCH);
1035	}	1034	}
1036	public void testSearchPatternValidMatchRule10() {	1035	public void testSearchPatternValidMatchRule10() {
Lines 1053-1059 Link Here
1053	SearchPattern.R_PATTERN_MATCH \| SearchPattern.R_PREFIX_MATCH,	1052	SearchPattern.R_PATTERN_MATCH \| SearchPattern.R_PREFIX_MATCH,
1054	SearchPattern.R_PATTERN_MATCH);	1053	SearchPattern.R_PATTERN_MATCH);
1055	}	1054	}
1056	/** @deprecated As using a depreciated constant */
1057	public void testSearchPatternValidMatchRule14() {	1055	public void testSearchPatternValidMatchRule14() {
1058	assertValidMatchRule("CP*P",	1056	assertValidMatchRule("CP*P",
1059	SearchPattern.R_CAMELCASE_MATCH,	1057	SearchPattern.R_CAMELCASE_MATCH,
Lines 1061-1162 Link Here
1061	}	1059	}
1062	public void testSearchPatternValidMatchRule15() {	1060	public void testSearchPatternValidMatchRule15() {
1063	assertValidMatchRule("CP*P",	1061	assertValidMatchRule("CP*P",
1064	SearchPattern.R_CAMEL_CASE_MATCH,	1062	SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH,
1065	SearchPattern.R_PATTERN_MATCH);	1063	SearchPattern.R_PATTERN_MATCH);
1066	}	1064	}
1067	/** @deprecated As using a depreciated constant */
1068	public void testSearchPatternValidMatchRule20() {	1065	public void testSearchPatternValidMatchRule20() {
1069	assertValidMatchRule("NPE",	1066	assertValidMatchRule("NPE",
1070	SearchPattern.R_CAMELCASE_MATCH);	1067	SearchPattern.R_CAMELCASE_MATCH);
1071	}	1068	}
1072	/** @deprecated As using a depreciated constant */
1073	public void testSearchPatternValidMatchRule21() {	1069	public void testSearchPatternValidMatchRule21() {
1074	assertValidMatchRule("NPE",	1070	assertValidMatchRule("NPE",
1075	SearchPattern.R_CAMELCASE_MATCH \| SearchPattern.R_PREFIX_MATCH \| SearchPattern.R_CASE_SENSITIVE,	1071	SearchPattern.R_CAMELCASE_MATCH \| SearchPattern.R_PREFIX_MATCH \| SearchPattern.R_CASE_SENSITIVE,
1076	SearchPattern.R_CAMELCASE_MATCH);	1072	SearchPattern.R_CAMELCASE_MATCH \| SearchPattern.R_CASE_SENSITIVE);
1077	}	1073	}
1078	/** @deprecated As using a depreciated constant */
1079	public void testSearchPatternValidMatchRule22() {	1074	public void testSearchPatternValidMatchRule22() {
1080	assertValidMatchRule("nPE",	1075	assertValidMatchRule("nPE",
1081	SearchPattern.R_CAMELCASE_MATCH);	1076	SearchPattern.R_CAMELCASE_MATCH);
1082	}	1077	}
1083	/** @deprecated As using a depreciated constant */
1084	public void testSearchPatternValidMatchRule23() {	1078	public void testSearchPatternValidMatchRule23() {
1085	assertValidMatchRule("NuPoEx",	1079	assertValidMatchRule("NuPoEx",
1086	SearchPattern.R_CAMELCASE_MATCH);	1080	SearchPattern.R_CAMELCASE_MATCH);
1087	}	1081	}
1088	/** @deprecated As using a depreciated constant */
1089	public void testSearchPatternValidMatchRule24() {	1082	public void testSearchPatternValidMatchRule24() {
1090	assertValidMatchRule("oF",	1083	assertValidMatchRule("oF",
1091	SearchPattern.R_CAMELCASE_MATCH);	1084	SearchPattern.R_CAMELCASE_MATCH);
1092	}	1085	}
1093	public void testSearchPatternValidMatchRule30() {	1086	public void testSearchPatternValidMatchRule30() {
1094	assertValidMatchRule("NPE",	1087	assertValidMatchRule("NPE",
1095	SearchPattern.R_CAMEL_CASE_MATCH);	1088	SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
1096	}	1089	}
1097	public void testSearchPatternValidMatchRule31() {	1090	public void testSearchPatternValidMatchRule31() {
1098	assertValidMatchRule("NPE",	1091	assertValidMatchRule("NPE",
1099	SearchPattern.R_CAMEL_CASE_MATCH \| SearchPattern.R_PREFIX_MATCH);	1092	SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH \| SearchPattern.R_PREFIX_MATCH,
		1093	SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
1100	}	1094	}
1101	public void testSearchPatternValidMatchRule32() {	1095	public void testSearchPatternValidMatchRule32() {
1102	assertValidMatchRule("NPE",	1096	assertValidMatchRule("NPE",
1103	SearchPattern.R_CAMEL_CASE_MATCH \| SearchPattern.R_CASE_SENSITIVE);	1097	SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH \| SearchPattern.R_CASE_SENSITIVE);
1104	}	1098	}
1105	public void testSearchPatternValidMatchRule33() {	1099	public void testSearchPatternValidMatchRule33() {
1106	assertValidMatchRule("NPE",	1100	assertValidMatchRule("NPE",
1107	SearchPattern.R_CAMEL_CASE_MATCH \| SearchPattern.R_PREFIX_MATCH \| SearchPattern.R_CASE_SENSITIVE);	1101	SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH \| SearchPattern.R_PREFIX_MATCH \| SearchPattern.R_CASE_SENSITIVE,
		1102	SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH \| SearchPattern.R_CASE_SENSITIVE);
1108	}	1103	}
1109	public void testSearchPatternValidMatchRule34() {	1104	public void testSearchPatternValidMatchRule34() {
1110	assertValidMatchRule("nPE",	1105	assertValidMatchRule("nPE",
1111	SearchPattern.R_CAMEL_CASE_MATCH);	1106	SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
1112	}	1107	}
1113	public void testSearchPatternValidMatchRule35() {	1108	public void testSearchPatternValidMatchRule35() {
1114	assertValidMatchRule("NuPoEx",	1109	assertValidMatchRule("NuPoEx",
1115	SearchPattern.R_CAMEL_CASE_MATCH);	1110	SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
1116	}	1111	}
1117	public void testSearchPatternValidMatchRule36() {	1112	public void testSearchPatternValidMatchRule36() {
1118	assertValidMatchRule("oF",	1113	assertValidMatchRule("oF",
1119	SearchPattern.R_CAMEL_CASE_MATCH);	1114	SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
1120	}	1115	}
1121	/** @deprecated As using a depreciated constant */
1122	public void testSearchPatternValidMatchRule40() {	1116	public void testSearchPatternValidMatchRule40() {
1123	assertValidMatchRule("Nu/Po/Ex",	1117	assertValidMatchRule("Nu/Po/Ex",
1124	SearchPattern.R_CAMELCASE_MATCH,	1118	SearchPattern.R_CAMELCASE_MATCH,
1125	SearchPattern.R_PREFIX_MATCH \| SearchPattern.R_CASE_SENSITIVE);	1119	SearchPattern.R_PREFIX_MATCH);
1126	}	1120	}
1127	/** @deprecated As using a depreciated constant */
1128	public void testSearchPatternValidMatchRule41() {	1121	public void testSearchPatternValidMatchRule41() {
1129	assertValidMatchRule("Nu.Po.Ex",	1122	assertValidMatchRule("Nu.Po.Ex",
1130	SearchPattern.R_CAMELCASE_MATCH \| SearchPattern.R_PREFIX_MATCH,	1123	SearchPattern.R_CAMELCASE_MATCH \| SearchPattern.R_PREFIX_MATCH,
1131	SearchPattern.R_PREFIX_MATCH);	1124	SearchPattern.R_PREFIX_MATCH);
1132	}	1125	}
1133	/** @deprecated As using a depreciated constant */
1134	public void testSearchPatternValidMatchRule42() {	1126	public void testSearchPatternValidMatchRule42() {
1135	assertValidMatchRule("hashMap",	1127	assertValidMatchRule("hashMap",
1136	SearchPattern.R_CAMELCASE_MATCH);	1128	SearchPattern.R_CAMELCASE_MATCH);
1137	}	1129	}
1138	/** @deprecated As using a depreciated constant */
1139	public void testSearchPatternValidMatchRule43() {	1130	public void testSearchPatternValidMatchRule43() {
1140	assertValidMatchRule("Hashmap",	1131	assertValidMatchRule("Hashmap",
		1132	SearchPattern.R_CAMELCASE_MATCH,
1141	SearchPattern.R_CAMELCASE_MATCH);	1133	SearchPattern.R_CAMELCASE_MATCH);
1142	}	1134	}
1143	public void testSearchPatternValidMatchRule44() {	1135	public void testSearchPatternValidMatchRule44() {
1144	assertValidMatchRule("Nu/Po/Ex",	1136	assertValidMatchRule("Nu/Po/Ex",
1145	SearchPattern.R_CAMEL_CASE_MATCH,	1137	SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH,
1146	SearchPattern.R_PREFIX_MATCH);	1138	SearchPattern.R_PREFIX_MATCH);
1147	}	1139	}
1148	public void testSearchPatternValidMatchRule45() {	1140	public void testSearchPatternValidMatchRule45() {
1149	assertValidMatchRule("Nu.Po.Ex",	1141	assertValidMatchRule("Nu.Po.Ex",
1150	SearchPattern.R_CAMEL_CASE_MATCH \| SearchPattern.R_PREFIX_MATCH,	1142	SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH \| SearchPattern.R_PREFIX_MATCH,
1151	SearchPattern.R_PREFIX_MATCH);	1143	SearchPattern.R_PREFIX_MATCH);
1152	}	1144	}
1153	public void testSearchPatternValidMatchRule46() {	1145	public void testSearchPatternValidMatchRule46() {
1154	assertValidMatchRule("hashMap",	1146	assertValidMatchRule("hashMap",
1155	SearchPattern.R_CAMEL_CASE_MATCH);	1147	SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
1156	}	1148	}
1157	public void testSearchPatternValidMatchRule47() {	1149	public void testSearchPatternValidMatchRule47() {
1158	assertValidMatchRule("Hashmap",	1150	assertValidMatchRule("Hashmap",
1159	SearchPattern.R_CAMEL_CASE_MATCH);	1151	SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH,
		1152	SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH);
1160	}	1153	}
1161		1154
1162	/**	1155	/**

Lines 923-929 Link Here

(-)src/org/eclipse/jdt/core/tests/model/JavaSearchMultipleProjectsTests.java (-8 / +6 lines)
923	* @bug 199392: [search] Type Dialog Error 'Items filtering ... Reason: Class file name must end with .class'	923	* @bug 199392: [search] Type Dialog Error 'Items filtering ... Reason: Class file name must end with .class'
924	* @test Ensure that types are found even in project which name ends either with ".jar" or ".zip"	924	* @test Ensure that types are found even in project which name ends either with ".jar" or ".zip"
925	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=199392"	925	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=199392"
926	* @deprecated As using a depreciated constant
927	*/	926	*/
928	public void testBug199392_Jar() throws CoreException {	927	public void testBug199392_Jar() throws CoreException {
929	try {	928	try {
Lines 961-967 Link Here
961	deleteProject("Test.jar");	960	deleteProject("Test.jar");
962	}	961	}
963	}	962	}
964	public void testBug199392_Jar_new() throws CoreException {	963	public void testBug199392_Jar_SamePartCount() throws CoreException {
965	try {	964	try {
966	IJavaProject project = createJavaProject("Test.jar");	965	IJavaProject project = createJavaProject("Test.jar");
967	createFolder("/Test.jar/test");	966	createFolder("/Test.jar/test");
Lines 983-1003 Link Here
983	null,	982	null,
984	SearchPattern.R_EXACT_MATCH,	983	SearchPattern.R_EXACT_MATCH,
985	new char[] { 'M', 'y' },	984	new char[] { 'M', 'y' },
986	SearchPattern.R_CAMEL_CASE_MATCH,	985	SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH,
987	IJavaSearchConstants.TYPE,	986	IJavaSearchConstants.TYPE,
988	scope,	987	scope,
989	collector,	988	collector,
990	IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,	989	IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
991	null);	990	null);
992	assertEquals("Found types sounds not to be correct",	991	assertEquals("Found types sounds not to be correct",
993	"", // no result as prefix match is not set	992	"",
994	collector.toString()	993	collector.toString()
995	);	994	);
996	} finally {	995	} finally {
997	deleteProject("Test.jar");	996	deleteProject("Test.jar");
998	}	997	}
999	}	998	}
1000	/** @deprecated As using a depreciated constant */
1001	public void testBug199392_Zip() throws CoreException {	999	public void testBug199392_Zip() throws CoreException {
1002	try {	1000	try {
1003	IJavaProject project = createJavaProject("Test.zip");	1001	IJavaProject project = createJavaProject("Test.zip");
Lines 1034-1040 Link Here
1034	deleteProject("Test.zip");	1032	deleteProject("Test.zip");
1035	}	1033	}
1036	}	1034	}
1037	public void testBug199392_Zip_new() throws CoreException {	1035	public void testBug199392_Zip_SamePartCount() throws CoreException {
1038	try {	1036	try {
1039	IJavaProject project = createJavaProject("Test.zip");	1037	IJavaProject project = createJavaProject("Test.zip");
1040	createFolder("/Test.zip/test");	1038	createFolder("/Test.zip/test");
Lines 1056-1069 Link Here
1056	null,	1054	null,
1057	SearchPattern.R_EXACT_MATCH,	1055	SearchPattern.R_EXACT_MATCH,
1058	new char[] { 'M', 'y' },	1056	new char[] { 'M', 'y' },
1059	SearchPattern.R_CAMEL_CASE_MATCH,	1057	SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH,
1060	IJavaSearchConstants.TYPE,	1058	IJavaSearchConstants.TYPE,
1061	scope,	1059	scope,
1062	collector,	1060	collector,
1063	IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,	1061	IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
1064	null);	1062	null);
1065	assertEquals("Found types sounds not to be correct",	1063	assertEquals("Found types sounds not to be correct",
1066	"", // no result as prefix match is not set	1064	"",
1067	collector.toString()	1065	collector.toString()
1068	);	1066	);
1069	} finally {	1067	} finally {

Lines 51-57 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/TypeReferencePattern.java (-5 / +5 lines)
51	((InternalSearchPattern)this).mustResolve = true; // always resolve (in case of a simple name reference being a potential match)	51	((InternalSearchPattern)this).mustResolve = true; // always resolve (in case of a simple name reference being a potential match)
52	}	52	}
53	/*	53	/*
54	* Instanciate a type reference pattern with additional information for generics search	54	* Instantiate a type reference pattern with additional information for generics search
55	*/	55	*/
56	public TypeReferencePattern(char[] qualification, char[] simpleName, String typeSignature, int matchRule) {	56	public TypeReferencePattern(char[] qualification, char[] simpleName, String typeSignature, int matchRule) {
57	this(qualification, simpleName,matchRule);	57	this(qualification, simpleName,matchRule);
Lines 65-71 Link Here
65	}	65	}
66	}	66	}
67	/*	67	/*
68	* Instanciate a type reference pattern with additional information for generics search	68	* Instantiate a type reference pattern with additional information for generics search
69	*/	69	*/
70	public TypeReferencePattern(char[] qualification, char[] simpleName, IType type, int matchRule) {	70	public TypeReferencePattern(char[] qualification, char[] simpleName, IType type, int matchRule) {
71	this(qualification, simpleName,matchRule);	71	this(qualification, simpleName,matchRule);
Lines 84-90 Link Here
84	if (this.simpleName != null)	84	if (this.simpleName != null)
85	return this.simpleName;	85	return this.simpleName;
86		86
87	// Optimization, eg. type reference is 'org.eclipse.jdt.core.*'	87	// Optimization, e.g. type reference is 'org.eclipse.jdt.core.*'
88	if (this.currentSegment >= 0)	88	if (this.currentSegment >= 0)
89	return this.segments[this.currentSegment];	89	return this.segments[this.currentSegment];
90	return null;	90	return null;
Lines 95-103 Link Here
95	protected boolean hasNextQuery() {	95	protected boolean hasNextQuery() {
96	if (this.segments == null) return false;	96	if (this.segments == null) return false;
97		97
98	// Optimization, eg. type reference is 'org.eclipse.jdt.core.*'	98	// Optimization, e.g. type reference is 'org.eclipse.jdt.core.*'
99	// if package has at least 4 segments, don't look at the first 2 since they are mostly	99	// if package has at least 4 segments, don't look at the first 2 since they are mostly
100	// redundant (eg. in 'org.eclipse.jdt.core.*' 'org.eclipse' is used all the time)	100	// redundant (e.g. in 'org.eclipse.jdt.core.*' 'org.eclipse' is used all the time)
101	return --this.currentSegment >= (this.segments.length >= 4 ? 2 : 0);	101	return --this.currentSegment >= (this.segments.length >= 4 ? 2 : 0);
102	}	102	}
103		103

Lines 38-44 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/MultiTypeDeclarationPattern.java (-7 / +9 lines)
38		38
39	this(matchRule);	39	this(matchRule);
40		40
41	if (isCaseSensitive() \|\| qualifications == null) {	41	if (this.isCaseSensitive \|\| qualifications == null) {
42	this.qualifications = qualifications;	42	this.qualifications = qualifications;
43	} else {	43	} else {
44	int length = qualifications.length;	44	int length = qualifications.length;
Lines 122-133 Link Here
122	// do a prefix query with the simpleName	122	// do a prefix query with the simpleName
123	break;	123	break;
124	case R_EXACT_MATCH :	124	case R_EXACT_MATCH :
125	if (!this.isCamelCase) {	125	// do a prefix query with the simpleName
126	// do a prefix query with the simpleName	126	matchRule &= ~R_EXACT_MATCH;
127	matchRule &= ~R_EXACT_MATCH;	127	matchRule \|= R_PREFIX_MATCH;
128	matchRule \|= R_PREFIX_MATCH;	128	key = CharOperation.append(key, SEPARATOR);
129	key = CharOperation.append(key, SEPARATOR);
130	}
131	break;	129	break;
132	case R_PATTERN_MATCH :	130	case R_PATTERN_MATCH :
133	if (key[key.length - 1] != '*')	131	if (key[key.length - 1] != '*')
Lines 136-141 Link Here
136	case R_REGEXP_MATCH :	134	case R_REGEXP_MATCH :
137	// TODO (frederic) implement regular expression match	135	// TODO (frederic) implement regular expression match
138	break;	136	break;
		137	case R_CAMELCASE_MATCH:
		138	case R_CAMELCASE_SAME_PART_COUNT_MATCH:
		139	// do a prefix query with the simpleName
		140	break;
139	}	141	}
140		142
141	EntryResult[] entries = index.query(getIndexCategories(), key, matchRule); // match rule is irrelevant when the key is null	143	EntryResult[] entries = index.query(getIndexCategories(), key, matchRule); // match rule is irrelevant when the key is null

Lines 248-254 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/SuperTypeReferencePattern.java (-1 / +4 lines)
248	// cannot include the superQualification since it may not exist in the index	248	// cannot include the superQualification since it may not exist in the index
249	switch(getMatchMode()) {	249	switch(getMatchMode()) {
250	case R_EXACT_MATCH :	250	case R_EXACT_MATCH :
251	if (this.isCamelCase) break;
252	// do a prefix query with the superSimpleName	251	// do a prefix query with the superSimpleName
253	matchRule &= ~R_EXACT_MATCH;	252	matchRule &= ~R_EXACT_MATCH;
254	matchRule \|= R_PREFIX_MATCH;	253	matchRule \|= R_PREFIX_MATCH;
Lines 264-269 Link Here
264	case R_REGEXP_MATCH :	263	case R_REGEXP_MATCH :
265	// TODO (frederic) implement regular expression match	264	// TODO (frederic) implement regular expression match
266	break;	265	break;
		266	case R_CAMELCASE_MATCH:
		267	case R_CAMELCASE_SAME_PART_COUNT_MATCH:
		268	// do a prefix query with the superSimpleName
		269	break;
267	}	270	}
268		271
269	return index.query(getIndexCategories(), key, matchRule); // match rule is irrelevant when the key is null	272	return index.query(getIndexCategories(), key, matchRule); // match rule is irrelevant when the key is null

Lines 95-128 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/PackageReferenceLocator.java (-12 / +22 lines)
95	protected int matchLevelForTokens(char[][] tokens) {	95	protected int matchLevelForTokens(char[][] tokens) {
96	if (this.pattern.pkgName == null) return ACCURATE_MATCH;	96	if (this.pattern.pkgName == null) return ACCURATE_MATCH;
97		97
98	char[] packageName = null;
99	if (this.isCamelCase) {
100	packageName = CharOperation.concatWith(tokens, '.');
101	if (CharOperation.camelCaseMatch(this.pattern.pkgName, packageName, (this.matchMode & SearchPattern.R_PREFIX_MATCH) != 0)) {
102	return POSSIBLE_MATCH;
103	}
104	if (this.isCaseSensitive) return IMPOSSIBLE_MATCH;
105	}
106	switch (this.matchMode) {	98	switch (this.matchMode) {
107	case SearchPattern.R_EXACT_MATCH:	99	case SearchPattern.R_EXACT_MATCH:
108	case SearchPattern.R_PREFIX_MATCH:	100	case SearchPattern.R_PREFIX_MATCH:
109	if (packageName==null) packageName = CharOperation.concatWith(tokens, '.');	101	if (CharOperation.prefixEquals(this.pattern.pkgName, CharOperation.concatWith(tokens, '.'), this.isCaseSensitive)) {
110	if (CharOperation.prefixEquals(this.pattern.pkgName, packageName, this.isCaseSensitive)) {
111	return POSSIBLE_MATCH;	102	return POSSIBLE_MATCH;
112	}	103	}
113	break;	104	break;
		105
114	case SearchPattern.R_PATTERN_MATCH:	106	case SearchPattern.R_PATTERN_MATCH:
115	char[] patternName = this.pattern.pkgName[this.pattern.pkgName.length - 1] == '*'	107	char[] patternName = this.pattern.pkgName[this.pattern.pkgName.length - 1] == '*'
116	? this.pattern.pkgName	108	? this.pattern.pkgName
117	: CharOperation.concat(this.pattern.pkgName, ".*".toCharArray()); //$NON-NLS-1$	109	: CharOperation.concat(this.pattern.pkgName, ".*".toCharArray()); //$NON-NLS-1$
118	if (packageName==null) packageName = CharOperation.concatWith(tokens, '.');	110	if (CharOperation.match(patternName, CharOperation.concatWith(tokens, '.'), this.isCaseSensitive)) {
119	if (CharOperation.match(patternName, packageName, this.isCaseSensitive)) {
120	return POSSIBLE_MATCH;	111	return POSSIBLE_MATCH;
121	}	112	}
122	break;	113	break;
		114
123	case SearchPattern.R_REGEXP_MATCH :	115	case SearchPattern.R_REGEXP_MATCH :
124	// TODO (frederic) implement regular expression match	116	// TODO (frederic) implement regular expression match
125	break;	117	break;
		118
		119	case SearchPattern.R_CAMELCASE_MATCH:
		120	char[] packageName = CharOperation.concatWith(tokens, '.');
		121	if (CharOperation.camelCaseMatch(this.pattern.pkgName, packageName, false)) {
		122	return POSSIBLE_MATCH;
		123	}
		124	// if camel case does not match then try a insensitive prefix match if allowed
		125	if (!this.isCaseSensitive && CharOperation.prefixEquals(this.pattern.pkgName, packageName, false)) {
		126	return POSSIBLE_MATCH;
		127	}
		128	break;
		129
		130	case SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH:
		131	packageName = CharOperation.concatWith(tokens, '.');
		132	if (CharOperation.camelCaseMatch(this.pattern.pkgName, CharOperation.concatWith(tokens, '.'), true)) {
		133	return POSSIBLE_MATCH;
		134	}
		135	break;
126	}	136	}
127	return IMPOSSIBLE_MATCH;	137	return IMPOSSIBLE_MATCH;
128	}	138	}

Lines 49-58 Link Here

(-)buildnotes_jdt-core.html (-1 / +108 lines)
49	<ul>	49	<ul>
50	<li>Added API <code>IJavaElementDelta#F_RESOLVED_CLASSPATH_CHANGED</code>. This flag is set when the resolved classpath of a Java project changes.	50	<li>Added API <code>IJavaElementDelta#F_RESOLVED_CLASSPATH_CHANGED</code>. This flag is set when the resolved classpath of a Java project changes.
51	This is independent from <code>IJavaElementDelta#F_CLASSPATH_CHANGED</code> which indicates that the raw classpath has changed.</li>	51	This is independent from <code>IJavaElementDelta#F_CLASSPATH_CHANGED</code> which indicates that the raw classpath has changed.</li>
		52	<li>Added API <code>SearchPattern#R_CAMELCASE_SAME_PART_COUNT_MATCH</code>.<br>
		53	This constant tells Search Engine to report matches which have <b>exactly</b>
		54	the same count of parts (i.e. uppercase characters) than the Camel Case pattern
		55	(see <a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=201426">bug 201426</a>):
		56	<pre>
		57	/**
		58	* Match rule: The search pattern contains a Camel Case expression with
		59	* a strict expected number of parts.
		60	*
		61	* Examples:
		62	* . 'HM' type string pattern will match 'HashMap' and 'HtmlMapper' types,
		63	* but not 'HashMapEntry'
		64	* . 'HMap' type string pattern will still match previous 'HashMap' and
		65	* 'HtmlMapper' types, but not 'HighMagnitude'
		66	*
		67	* This rule is not intended to be combined with any other match rule. In case
		68	* of other match rule flags are combined with this one, then match rule validation
		69	* will return a modified rule in order to perform a better appropriate search request
		70	* (see {@link #validateMatchRule(String, int)} for more details).
		71	*
		72	* @see CharOperation#camelCaseMatch(char[], char[], boolean) for a detailed
		73	* explanation of Camel Case matching.
		74	*
		75	* @since 3.4
		76	*/
		77	public static final int R_CAMELCASE_SAME_PART_COUNT_MATCH = 0x0100;
		78	</pre>
		79	Note that this constant replace previous one <code>R_CAMEL_CASE_MATCH</code>
		80	added while fixing <a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=124624">bug 124624</a>.<br>
		81	Also note that <code>R_CAMELCASE_MATCH</code> is no longer deprecated as, finally,
		82	Camel Case match rule flags are not supposed to be combined with other ones (e.g.
		83	<code>R_PREFIX_MATCH</code> or <code>R_PATTERN_MATCH</code>).
		84	</li>
		85	<li><code>CharOperation</code> and <code>SearchPattern</code> Camel Case API methods
		86	added while fixing <a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=124624">bug 124624</a>)
		87	have been modified to clarify the behavior of the additional boolean parameter.<br>
		88	This parameter now indicates whether the pattern and the name should have the same
		89	count of parts (i.e. uppercase characters) or not:
		90	<pre>
		91	/**
		92	*...
		93	* CamelCase can be restricted to match only the same count of parts. When this
		94	* restriction is specified the given pattern and the given name must have <b>exactly</b>
		95	* the same number of parts (i.e. the same number of uppercase characters).
		96	* For instance, 'HM' , 'HaMa' and 'HMap' patterns will match 'HashMap' and
		97	* 'HatMapper' <b>but not</b> 'HashMapEntry'.
		98	*...
		99	* . pattern = "HM".toCharArray()
		100	* name = "HashMapEntry".toCharArray()
		101	* result => (samePartCount == false)
		102	*...
		103	* @param samePartCount flag telling whether the pattern and the name should
		104	* have the same count of parts or not.
		105	*   For example:
		106	* . 'HM' type string pattern will match 'HashMap' and 'HtmlMapper' types,
		107	* but not 'HashMapEntry'
		108	* . 'HMap' type string pattern will still match previous 'HashMap' and
		109	* 'HtmlMapper' types, but not 'HighMagnitude'
		110	* @return true if the pattern matches the given name, false otherwise
		111	* @since 3.4
		112	*/
		113	public static final boolean camelCaseMatch(char[] pattern, char[] name, boolean samePartCount) {
		114	...
		115	}
116
117	/**
118	*...
119	* CamelCase can be restricted to match only the same count of parts. When this
120	* restriction is specified the given pattern and the given name must have <b>exactly</b>
121	* the same number of parts (i.e. the same number of uppercase characters).
122	* For instance, 'HM' , 'HaMa' and 'HMap' patterns will match 'HashMap' and
123	* 'HatMapper' <b>but not</b> 'HashMapEntry'.
124	*...
125	* . pattern = "HM".toCharArray()
126	* patternStart = 0
127	* patternEnd = 2
128	* name = "HashMapEntry".toCharArray()
129	* nameStart = 0
130	* nameEnd = 12
131	* result => (samePartCount == false)
132	*...
133	* @param samePartCount flag telling whether the pattern and the name should
134	* have the same count of parts or not.
135	*   For example:
136	* . 'HM' type string pattern will match 'HashMap' and 'HtmlMapper' types,
137	* but not 'HashMapEntry'
138	* . 'HMap' type string pattern will still match previous 'HashMap' and
139	* 'HtmlMapper' types, but not 'HighMagnitude'
140	* @return true if a sub-pattern matches the sub-part of the given name, false otherwise
141	* @since 3.4
142	*/
143	public static final boolean camelCaseMatch(char[] pattern, int patternStart, int patternEnd, char[] name, int nameStart, int nameEnd, boolean prefixMatch) {
144	...
145	}
146	</pre>
147	Note that similar modifications have been done on <code>SearchPattern</code>
148	corresponding methods:
149	<pre>
150	public static final boolean camelCaseMatch(String pattern, String name, boolean samePartCount) {
151	...
152	}
153	public static final boolean camelCaseMatch(String pattern, int patternStart, int patternEnd, String name, int nameStart, int nameEnd, boolean samePartCount) {
154	...
155	}
156	</li>
52	</ul>	157	</ul>
53		158
54	<h3>Problem Reports Fixed</h3>	159	<h3>Problem Reports Fixed</h3>
55	<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=204339">204339</a>	160	<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=201426">201426</a>
		161	[search] New SearchPattern constant R_CAMEL_CASE_MATCH name may be misleading for users
		162	<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=204339">204339</a>
56	[compiler] Invalid length for missing package declaration in empty package-info.java file	163	[compiler] Invalid length for missing package declaration in empty package-info.java file
57	<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=203587">203587</a>	164	<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=203587">203587</a>
58	Improve messages consistency in case of generic methods having same erasure	165	Improve messages consistency in case of generic methods having same erasure

Lines 47-53 Link Here

(-)search/org/eclipse/jdt/internal/core/index/Index.java (-13 / +13 lines)
47	SearchPattern.R_PATTERN_MATCH \|	47	SearchPattern.R_PATTERN_MATCH \|
48	SearchPattern.R_REGEXP_MATCH \|	48	SearchPattern.R_REGEXP_MATCH \|
49	SearchPattern.R_CASE_SENSITIVE \|	49	SearchPattern.R_CASE_SENSITIVE \|
50	SearchPattern.R_CAMEL_CASE_MATCH;	50	SearchPattern.R_CAMELCASE_MATCH \|
		51	SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH;
51		52
52	public static boolean isMatch(char[] pattern, char[] word, int matchRule) {	53	public static boolean isMatch(char[] pattern, char[] word, int matchRule) {
53	if (pattern == null) return true;	54	if (pattern == null) return true;
Lines 56-74 Link Here
56	if (patternLength == 0) return matchRule != SearchPattern.R_EXACT_MATCH;	57	if (patternLength == 0) return matchRule != SearchPattern.R_EXACT_MATCH;
57	if (wordLength == 0) return (matchRule & SearchPattern.R_PATTERN_MATCH) != 0 && patternLength == 1 && pattern[0] == '*';	58	if (wordLength == 0) return (matchRule & SearchPattern.R_PATTERN_MATCH) != 0 && patternLength == 1 && pattern[0] == '*';
58		59
59	// First test camel case if necessary
60	boolean isCamelCase = (matchRule & SearchPattern.R_CAMEL_CASE_MATCH) != 0;
61	if (isCamelCase) {
62	// prefix is always needed as index key got characters after type simple name
63	// see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=201064
64	if (pattern[0] == word[0] && CharOperation.camelCaseMatch(pattern, word, true/prefix match/)) {
65	return true;
66	}
67	if ((matchRule & SearchPattern.R_CASE_SENSITIVE) != 0) return false;
68	}
69
70	// need to mask some bits of pattern rule (bug 79790)	60	// need to mask some bits of pattern rule (bug 79790)
71	matchRule &= ~SearchPattern.R_CAMEL_CASE_MATCH;
72	switch(matchRule & MATCH_RULE_INDEX_MASK) {	61	switch(matchRule & MATCH_RULE_INDEX_MASK) {
73	case SearchPattern.R_EXACT_MATCH :	62	case SearchPattern.R_EXACT_MATCH :
74	return patternLength == wordLength && CharOperation.equals(pattern, word, false);	63	return patternLength == wordLength && CharOperation.equals(pattern, word, false);
Lines 76-87 Link Here
76	return patternLength <= wordLength && CharOperation.prefixEquals(pattern, word, false);	65	return patternLength <= wordLength && CharOperation.prefixEquals(pattern, word, false);
77	case SearchPattern.R_PATTERN_MATCH :	66	case SearchPattern.R_PATTERN_MATCH :
78	return CharOperation.match(pattern, word, false);	67	return CharOperation.match(pattern, word, false);
		68	case SearchPattern.R_CAMELCASE_MATCH:
		69	// same part count is not activated because index key may have uppercase letters after the type name
		70	case SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH:
		71	if (CharOperation.camelCaseMatch(pattern, word, false)) {
		72	return true;
		73	}
		74	return patternLength <= wordLength && CharOperation.prefixEquals(pattern, word, false);
79	case SearchPattern.R_EXACT_MATCH \| SearchPattern.R_CASE_SENSITIVE :	75	case SearchPattern.R_EXACT_MATCH \| SearchPattern.R_CASE_SENSITIVE :
80	return pattern[0] == word[0] && patternLength == wordLength && CharOperation.equals(pattern, word);	76	return pattern[0] == word[0] && patternLength == wordLength && CharOperation.equals(pattern, word);
81	case SearchPattern.R_PREFIX_MATCH \| SearchPattern.R_CASE_SENSITIVE :	77	case SearchPattern.R_PREFIX_MATCH \| SearchPattern.R_CASE_SENSITIVE :
82	return pattern[0] == word[0] && patternLength <= wordLength && CharOperation.prefixEquals(pattern, word);	78	return pattern[0] == word[0] && patternLength <= wordLength && CharOperation.prefixEquals(pattern, word);
83	case SearchPattern.R_PATTERN_MATCH \| SearchPattern.R_CASE_SENSITIVE :	79	case SearchPattern.R_PATTERN_MATCH \| SearchPattern.R_CASE_SENSITIVE :
84	return CharOperation.match(pattern, word, true);	80	return CharOperation.match(pattern, word, true);
		81	case SearchPattern.R_CAMELCASE_MATCH \| SearchPattern.R_CASE_SENSITIVE :
		82	// same part count is not activated because index key may have uppercase letters after the type name
		83	case SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH \| SearchPattern.R_CASE_SENSITIVE :
		84	return (pattern[0] == word[0] && CharOperation.camelCaseMatch(pattern, word, false));
85	}	85	}
86	return false;	86	return false;
87	}	87	}

Lines 36-42 Link Here

(-)search/org/eclipse/jdt/internal/core/search/BasicSearchEngine.java (-25 / +46 lines)
36	/**	36	/**
37	* Search basic engine. Public search engine (see {@link org.eclipse.jdt.core.search.SearchEngine}	37	* Search basic engine. Public search engine (see {@link org.eclipse.jdt.core.search.SearchEngine}
38	* for detailed comment), now uses basic engine functionalities.	38	* for detailed comment), now uses basic engine functionalities.
39	* Note that serch basic engine does not implement deprecated functionalities...	39	* Note that search basic engine does not implement deprecated functionalities...
40	*/	40	*/
41	public class BasicSearchEngine {	41	public class BasicSearchEngine {
42		42
Lines 271-281 Link Here
271	case SearchPattern.R_REGEXP_MATCH:	271	case SearchPattern.R_REGEXP_MATCH:
272	buffer.append("R_REGEXP_MATCH"); //$NON-NLS-1$	272	buffer.append("R_REGEXP_MATCH"); //$NON-NLS-1$
273	break;	273	break;
274	case 0x0080: // SearchPattern.R_CAMELCASE_MATCH:	274	case SearchPattern.R_CAMELCASE_MATCH:
275	buffer.append("R_CAMELCASE_MATCH"); //$NON-NLS-1$	275	buffer.append("R_CAMELCASE_MATCH"); //$NON-NLS-1$
276	break;	276	break;
277	case SearchPattern.R_CAMEL_CASE_MATCH:	277	case SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH:
278	buffer.append("R_CAMEL_CASE_MATCH"); //$NON-NLS-1$	278	buffer.append("R_CAMELCASE_SAME_PART_COUNT_MATCH"); //$NON-NLS-1$
279	break;	279	break;
280	}	280	}
281	}	281	}
Lines 457-474 Link Here
457	return false;	457	return false;
458		458
459	if (patternTypeName != null) {	459	if (patternTypeName != null) {
460	boolean isCamelCase = (matchRule & SearchPattern.R_CAMEL_CASE_MATCH) != 0;	460	boolean isCamelCase = (matchRule & (SearchPattern.R_CAMELCASE_MATCH \| SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH)) != 0;
461	int matchMode = matchRule & JavaSearchPattern.MATCH_MODE_MASK;	461	int matchMode = matchRule & JavaSearchPattern.MATCH_MODE_MASK;
462	if (!isCaseSensitive && !isCamelCase) {	462	if (!isCaseSensitive && !isCamelCase) {
463	patternTypeName = CharOperation.toLowerCase(patternTypeName);	463	patternTypeName = CharOperation.toLowerCase(patternTypeName);
464	}	464	}
465	boolean matchFirstChar = !isCaseSensitive \|\| patternTypeName[0] == typeName[0];	465	boolean matchFirstChar = !isCaseSensitive \|\| patternTypeName[0] == typeName[0];
466	if (isCamelCase) {
467	if (matchFirstChar && CharOperation.camelCaseMatch(patternTypeName, typeName, (matchRule & SearchPattern.R_PREFIX_MATCH) != 0)) {
468	return true;
469	}
470	if (isCaseSensitive) return false;
471	}
472	switch(matchMode) {	466	switch(matchMode) {
473	case SearchPattern.R_EXACT_MATCH :	467	case SearchPattern.R_EXACT_MATCH :
474	return matchFirstChar && CharOperation.equals(patternTypeName, typeName, isCaseSensitive);	468	return matchFirstChar && CharOperation.equals(patternTypeName, typeName, isCaseSensitive);
Lines 479-484 Link Here
479	case SearchPattern.R_REGEXP_MATCH :	473	case SearchPattern.R_REGEXP_MATCH :
480	// TODO (frederic) implement regular expression match	474	// TODO (frederic) implement regular expression match
481	break;	475	break;
		476	case SearchPattern.R_CAMELCASE_MATCH:
		477	if (matchFirstChar && CharOperation.camelCaseMatch(patternTypeName, typeName, false)) {
		478	return true;
		479	}
		480	return !isCaseSensitive && matchFirstChar && CharOperation.prefixEquals(patternTypeName, typeName, false);
		481	case SearchPattern.R_CAMELCASE_SAME_PART_COUNT_MATCH:
		482	return matchFirstChar && CharOperation.camelCaseMatch(patternTypeName, typeName, true);
482	}	483	}
483	}	484	}
484	return true;	485	return true;
Lines 645-659 Link Here
645	int waitingPolicy,	646	int waitingPolicy,
646	IProgressMonitor progressMonitor) throws JavaModelException {	647	IProgressMonitor progressMonitor) throws JavaModelException {
647		648
		649	// Validate match rule first
		650	final int validatedTypeMatchRule = SearchPattern.validateMatchRule(typeName == null ? null : new String (typeName), typeMatchRule);
		651
		652	// Debug
648	if (VERBOSE) {	653	if (VERBOSE) {
649	Util.verbose("BasicSearchEngine.searchAllTypeNames(char[], char[], int, int, IJavaSearchScope, IRestrictedAccessTypeRequestor, int, IProgressMonitor)"); //$NON-NLS-1$	654	Util.verbose("BasicSearchEngine.searchAllTypeNames(char[], char[], int, int, IJavaSearchScope, IRestrictedAccessTypeRequestor, int, IProgressMonitor)"); //$NON-NLS-1$
650	Util.verbose(" - package name: "+(packageName==null?"null":new String(packageName))); //$NON-NLS-1$ //$NON-NLS-2$	655	Util.verbose(" - package name: "+(packageName==null?"null":new String(packageName))); //$NON-NLS-1$ //$NON-NLS-2$
651	Util.verbose(" - match rule: "+getMatchRuleString(packageMatchRule)); //$NON-NLS-1$	656	Util.verbose(" - package match rule: "+getMatchRuleString(packageMatchRule)); //$NON-NLS-1$
652	Util.verbose(" - type name: "+(typeName==null?"null":new String(typeName))); //$NON-NLS-1$ //$NON-NLS-2$	657	Util.verbose(" - type name: "+(typeName==null?"null":new String(typeName))); //$NON-NLS-1$ //$NON-NLS-2$
653	Util.verbose(" - match rule: "+getMatchRuleString(typeMatchRule)); //$NON-NLS-1$	658	Util.verbose(" - type match rule: "+getMatchRuleString(typeMatchRule)); //$NON-NLS-1$
		659	if (validatedTypeMatchRule != typeMatchRule) {
		660	Util.verbose(" - validated type match rule: "+getMatchRuleString(validatedTypeMatchRule)); //$NON-NLS-1$
		661	}
654	Util.verbose(" - search for: "+searchFor); //$NON-NLS-1$	662	Util.verbose(" - search for: "+searchFor); //$NON-NLS-1$
655	Util.verbose(" - scope: "+scope); //$NON-NLS-1$	663	Util.verbose(" - scope: "+scope); //$NON-NLS-1$
656	}	664	}
		665	if (validatedTypeMatchRule == -1) return; // invalid match rule => return no results
657		666
658	// Create pattern	667	// Create pattern
659	IndexManager indexManager = JavaModelManager.getIndexManager();	668	IndexManager indexManager = JavaModelManager.getIndexManager();
Lines 690-702 Link Here
690	null,	699	null,
691	typeName,	700	typeName,
692	typeSuffix,	701	typeSuffix,
693	typeMatchRule)	702	validatedTypeMatchRule)
694	: new QualifiedTypeDeclarationPattern(	703	: new QualifiedTypeDeclarationPattern(
695	packageName,	704	packageName,
696	packageMatchRule,	705	packageMatchRule,
697	typeName,	706	typeName,
698	typeSuffix,	707	typeSuffix,
699	typeMatchRule);	708	validatedTypeMatchRule);
700		709
701	// Get working copy path(s). Store in a single string in case of only one to optimize comparison in requestor	710	// Get working copy path(s). Store in a single string in case of only one to optimize comparison in requestor
702	final HashSet workingCopyPaths = new HashSet();	711	final HashSet workingCopyPaths = new HashSet();
Lines 728-734 Link Here
728	break;	737	break;
729	case 1:	738	case 1:
730	if (singleWkcpPath.equals(documentPath)) {	739	if (singleWkcpPath.equals(documentPath)) {
731	return true; // fliter out the working copy	740	return true; // filter out the working copy
732	}	741	}
733	break;	742	break;
734	default:	743	default:
Lines 813-819 Link Here
813	} else /if (type.isInterface())/ {	822	} else /if (type.isInterface())/ {
814	kind = TypeDeclaration.INTERFACE_DECL;	823	kind = TypeDeclaration.INTERFACE_DECL;
815	}	824	}
816	if (match(typeSuffix, packageName, typeName, typeMatchRule, kind, packageDeclaration, simpleName)) {	825	if (match(typeSuffix, packageName, typeName, validatedTypeMatchRule, kind, packageDeclaration, simpleName)) {
817	if (nameRequestor instanceof TypeNameMatchRequestorWrapper) {	826	if (nameRequestor instanceof TypeNameMatchRequestorWrapper) {
818	((TypeNameMatchRequestorWrapper)nameRequestor).requestor.acceptTypeNameMatch(new JavaSearchTypeNameMatch(type, type.getFlags()));	827	((TypeNameMatchRequestorWrapper)nameRequestor).requestor.acceptTypeNameMatch(new JavaSearchTypeNameMatch(type, type.getFlags()));
819	} else {	828	} else {
Lines 833-839 Link Here
833	return false; // no local/anonymous type	842	return false; // no local/anonymous type
834	}	843	}
835	public boolean visit(TypeDeclaration typeDeclaration, CompilationUnitScope compilationUnitScope) {	844	public boolean visit(TypeDeclaration typeDeclaration, CompilationUnitScope compilationUnitScope) {
836	if (match(typeSuffix, packageName, typeName, typeMatchRule, TypeDeclaration.kind(typeDeclaration.modifiers), packageDeclaration, typeDeclaration.name)) {	845	if (match(typeSuffix, packageName, typeName, validatedTypeMatchRule, TypeDeclaration.kind(typeDeclaration.modifiers), packageDeclaration, typeDeclaration.name)) {
837	if (nameRequestor instanceof TypeNameMatchRequestorWrapper) {	846	if (nameRequestor instanceof TypeNameMatchRequestorWrapper) {
838	IType type = workingCopy.getType(new String(typeName));	847	IType type = workingCopy.getType(new String(typeName));
839	((TypeNameMatchRequestorWrapper)nameRequestor).requestor.acceptTypeNameMatch(new JavaSearchTypeNameMatch(type, typeDeclaration.modifiers));	848	((TypeNameMatchRequestorWrapper)nameRequestor).requestor.acceptTypeNameMatch(new JavaSearchTypeNameMatch(type, typeDeclaration.modifiers));
Lines 844-850 Link Here
844	return true;	853	return true;
845	}	854	}
846	public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope classScope) {	855	public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope classScope) {
847	if (match(typeSuffix, packageName, typeName, typeMatchRule, TypeDeclaration.kind(memberTypeDeclaration.modifiers), packageDeclaration, memberTypeDeclaration.name)) {	856	if (match(typeSuffix, packageName, typeName, validatedTypeMatchRule, TypeDeclaration.kind(memberTypeDeclaration.modifiers), packageDeclaration, memberTypeDeclaration.name)) {
848	// compute enclosing type names	857	// compute enclosing type names
849	TypeDeclaration enclosing = memberTypeDeclaration.enclosingType;	858	TypeDeclaration enclosing = memberTypeDeclaration.enclosingType;
850	char[][] enclosingTypeNames = CharOperation.NO_CHAR_CHAR;	859	char[][] enclosingTypeNames = CharOperation.NO_CHAR_CHAR;
Lines 892-914 Link Here
892	public void searchAllTypeNames(	901	public void searchAllTypeNames(
893	final char[][] qualifications,	902	final char[][] qualifications,
894	final char[][] typeNames,	903	final char[][] typeNames,
895	final int matchRule,	904	int matchRule,
896	int searchFor,	905	int searchFor,
897	IJavaSearchScope scope,	906	IJavaSearchScope scope,
898	final IRestrictedAccessTypeRequestor nameRequestor,	907	final IRestrictedAccessTypeRequestor nameRequestor,
899	int waitingPolicy,	908	int waitingPolicy,
900	IProgressMonitor progressMonitor) throws JavaModelException {	909	IProgressMonitor progressMonitor) throws JavaModelException {
901		910
		911	// Validate match rule first
		912	int namesLength = typeNames == null ? 0 : typeNames.length;
		913	for (int i=0; i<namesLength; i++) {
		914	matchRule &= SearchPattern.validateMatchRule(new String(typeNames[i]), matchRule);
		915	}
		916	final int validatedMatchRule = matchRule;
		917
		918	// Debug
902	if (VERBOSE) {	919	if (VERBOSE) {
903	Util.verbose("BasicSearchEngine.searchAllTypeNames(char[][], char[][], int, int, IJavaSearchScope, IRestrictedAccessTypeRequestor, int, IProgressMonitor)"); //$NON-NLS-1$	920	Util.verbose("BasicSearchEngine.searchAllTypeNames(char[][], char[][], int, int, IJavaSearchScope, IRestrictedAccessTypeRequestor, int, IProgressMonitor)"); //$NON-NLS-1$
904	Util.verbose(" - package name: "+(qualifications==null?"null":new String(CharOperation.concatWith(qualifications, ',')))); //$NON-NLS-1$ //$NON-NLS-2$	921	Util.verbose(" - package name: "+(qualifications==null?"null":new String(CharOperation.concatWith(qualifications, ',')))); //$NON-NLS-1$ //$NON-NLS-2$
905	Util.verbose(" - type name: "+(typeNames==null?"null":new String(CharOperation.concatWith(typeNames, ',')))); //$NON-NLS-1$ //$NON-NLS-2$	922	Util.verbose(" - type name: "+(typeNames==null?"null":new String(CharOperation.concatWith(typeNames, ',')))); //$NON-NLS-1$ //$NON-NLS-2$
906	Util.verbose(" - match rule: "+matchRule); //$NON-NLS-1$	923	Util.verbose(" - match rule: "+matchRule); //$NON-NLS-1$
		924	if (validatedMatchRule != matchRule) {
		925	Util.verbose(" - validated match rule: "+getMatchRuleString(validatedMatchRule)); //$NON-NLS-1$
		926	}
907	Util.verbose(" - search for: "+searchFor); //$NON-NLS-1$	927	Util.verbose(" - search for: "+searchFor); //$NON-NLS-1$
908	Util.verbose(" - scope: "+scope); //$NON-NLS-1$	928	Util.verbose(" - scope: "+scope); //$NON-NLS-1$
909	}	929	}
910	IndexManager indexManager = JavaModelManager.getIndexManager();	930	IndexManager indexManager = JavaModelManager.getIndexManager();
911		931
		932	// Create pattern
912	final char typeSuffix;	933	final char typeSuffix;
913	switch(searchFor){	934	switch(searchFor){
914	case IJavaSearchConstants.CLASS :	935	case IJavaSearchConstants.CLASS :
Lines 936-942 Link Here
936	typeSuffix = IIndexConstants.TYPE_SUFFIX;	957	typeSuffix = IIndexConstants.TYPE_SUFFIX;
937	break;	958	break;
938	}	959	}
939	final MultiTypeDeclarationPattern pattern = new MultiTypeDeclarationPattern(qualifications, typeNames, typeSuffix, matchRule);	960	final MultiTypeDeclarationPattern pattern = new MultiTypeDeclarationPattern(qualifications, typeNames, typeSuffix, validatedMatchRule);
940		961
941	// Get working copy path(s). Store in a single string in case of only one to optimize comparison in requestor	962	// Get working copy path(s). Store in a single string in case of only one to optimize comparison in requestor
942	final HashSet workingCopyPaths = new HashSet();	963	final HashSet workingCopyPaths = new HashSet();
Lines 968-974 Link Here
968	break;	989	break;
969	case 1:	990	case 1:
970	if (singleWkcpPath.equals(documentPath)) {	991	if (singleWkcpPath.equals(documentPath)) {
971	return true; // fliter out the working copy	992	return true; // filter out the working copy
972	}	993	}
973	break;	994	break;
974	default:	995	default:
Lines 1071-1084 Link Here
1071	}	1092	}
1072	public boolean visit(TypeDeclaration typeDeclaration, CompilationUnitScope compilationUnitScope) {	1093	public boolean visit(TypeDeclaration typeDeclaration, CompilationUnitScope compilationUnitScope) {
1073	SearchPattern decodedPattern =	1094	SearchPattern decodedPattern =
1074	new QualifiedTypeDeclarationPattern(packageDeclaration, typeDeclaration.name, convertTypeKind(TypeDeclaration.kind(typeDeclaration.modifiers)), matchRule);	1095	new QualifiedTypeDeclarationPattern(packageDeclaration, typeDeclaration.name, convertTypeKind(TypeDeclaration.kind(typeDeclaration.modifiers)), validatedMatchRule);
1075	if (pattern.matchesDecodedKey(decodedPattern)) {	1096	if (pattern.matchesDecodedKey(decodedPattern)) {
1076	nameRequestor.acceptType(typeDeclaration.modifiers, packageDeclaration, typeDeclaration.name, CharOperation.NO_CHAR_CHAR, path, null);	1097	nameRequestor.acceptType(typeDeclaration.modifiers, packageDeclaration, typeDeclaration.name, CharOperation.NO_CHAR_CHAR, path, null);
1077	}	1098	}
1078	return true;	1099	return true;
1079	}	1100	}
1080	public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope classScope) {	1101	public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope classScope) {
1081	// compute encloising type names	1102	// compute enclosing type names
1082	char[] qualification = packageDeclaration;	1103	char[] qualification = packageDeclaration;
1083	TypeDeclaration enclosing = memberTypeDeclaration.enclosingType;	1104	TypeDeclaration enclosing = memberTypeDeclaration.enclosingType;
1084	char[][] enclosingTypeNames = CharOperation.NO_CHAR_CHAR;	1105	char[][] enclosingTypeNames = CharOperation.NO_CHAR_CHAR;
Lines 1092-1098 Link Here
1092	}	1113	}
1093	}	1114	}
1094	SearchPattern decodedPattern =	1115	SearchPattern decodedPattern =
1095	new QualifiedTypeDeclarationPattern(qualification, memberTypeDeclaration.name, convertTypeKind(TypeDeclaration.kind(memberTypeDeclaration.modifiers)), matchRule);	1116	new QualifiedTypeDeclarationPattern(qualification, memberTypeDeclaration.name, convertTypeKind(TypeDeclaration.kind(memberTypeDeclaration.modifiers)), validatedMatchRule);
1096	if (pattern.matchesDecodedKey(decodedPattern)) {	1117	if (pattern.matchesDecodedKey(decodedPattern)) {
1097	nameRequestor.acceptType(memberTypeDeclaration.modifiers, packageDeclaration, memberTypeDeclaration.name, enclosingTypeNames, path, null);	1118	nameRequestor.acceptType(memberTypeDeclaration.modifiers, packageDeclaration, memberTypeDeclaration.name, enclosingTypeNames, path, null);
1098	}	1119	}

Lines 37-43 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/UtilTest.java (-63 / +63 lines)
37	* If result is invalid then store warning in buffer and display it.	37	* If result is invalid then store warning in buffer and display it.
38	*/	38	*/
39	void assertCamelCase(String pattern, String name, boolean match) {	39	void assertCamelCase(String pattern, String name, boolean match) {
40	assertCamelCase(pattern, name, true /prefix match/, match);	40	assertCamelCase(pattern, name, false /* name may have more parts*/, match);
41	}	41	}
42	/**	42	/**
43	* Assert that a pattern and a name matches or not.	43	* Assert that a pattern and a name matches or not.
Lines 619-673 Link Here
619		619
620	// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=109695	620	// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=109695
621	public void test70() throws CoreException {	621	public void test70() throws CoreException {
622	assertCamelCase("IDE3", "IDocumentExtension", false /no prefix match/, false /* should not match */);	622	assertCamelCase("IDE3", "IDocumentExtension", true /same part count/, false /* should not match */);
623	assertCamelCase("IDE3", "IDocumentExtension2", false /no prefix match/, false /* should not match */);	623	assertCamelCase("IDE3", "IDocumentExtension2", true /same part count/, false /* should not match */);
624	assertCamelCase("IDE3", "IDocumentExtension3", false /no prefix match/, true /* should match */);	624	assertCamelCase("IDE3", "IDocumentExtension3", true /same part count/, true /* should match */);
625	assertCamelCase("IDE3", "IDocumentExtension135", false /no prefix match/, true /* should match */);	625	assertCamelCase("IDE3", "IDocumentExtension135", true /same part count/, true /* should match */);
626	assertCamelCase("IDE3", "IDocumentExtension315", false /no prefix match/, true /* should match */);	626	assertCamelCase("IDE3", "IDocumentExtension315", true /same part count/, true /* should match */);
627	assertCamelCase("IDPE3", "IDocumentProviderExtension", false /no prefix match/, false /* should not match */);	627	assertCamelCase("IDPE3", "IDocumentProviderExtension", true /same part count/, false /* should not match */);
628	assertCamelCase("IDPE3", "IDocumentProviderExtension2", false /no prefix match/, false /* should not match */);	628	assertCamelCase("IDPE3", "IDocumentProviderExtension2", true /same part count/, false /* should not match */);
629	assertCamelCase("IDPE3", "IDocumentProviderExtension4", false /no prefix match/, false /* should not match */);	629	assertCamelCase("IDPE3", "IDocumentProviderExtension4", true /same part count/, false /* should not match */);
630	assertCamelCase("IDPE3", "IDocumentProviderExtension3", false /no prefix match/, true /* should match */);	630	assertCamelCase("IDPE3", "IDocumentProviderExtension3", true /same part count/, true /* should match */);
631	assertCamelCase("IDPE3", "IDocumentProviderExtension5", false /no prefix match/, false /* should not match */);	631	assertCamelCase("IDPE3", "IDocumentProviderExtension5", true /same part count/, false /* should not match */);
632	assertCamelCase("IDPE3", "IDocumentProviderExtension54321", false /no prefix match/, true /* should match */);	632	assertCamelCase("IDPE3", "IDocumentProviderExtension54321", true /same part count/, true /* should match */);
633	assertCamelCase("IDPE3", "IDocumentProviderExtension12345", false /no prefix match/, true /* should match */);	633	assertCamelCase("IDPE3", "IDocumentProviderExtension12345", true /same part count/, true /* should match */);
634	assertCamelCase("IPL3", "IPerspectiveListener", false /no prefix match/, false /* should not match */);	634	assertCamelCase("IPL3", "IPerspectiveListener", true /same part count/, false /* should not match */);
635	assertCamelCase("IPL3", "IPerspectiveListener2", false /no prefix match/, false /* should not match */);	635	assertCamelCase("IPL3", "IPerspectiveListener2", true /same part count/, false /* should not match */);
636	assertCamelCase("IPL3", "IPerspectiveListener3", false /no prefix match/, true /* should match */);	636	assertCamelCase("IPL3", "IPerspectiveListener3", true /same part count/, true /* should match */);
637	assertCamelCase("IPS2", "IPropertySource", false /no prefix match/, false /* should not match */);	637	assertCamelCase("IPS2", "IPropertySource", true /same part count/, false /* should not match */);
638	assertCamelCase("IPS2", "IPropertySource2", false /no prefix match/, true /* should match */);	638	assertCamelCase("IPS2", "IPropertySource2", true /same part count/, true /* should match */);
639	assertCamelCase("IWWPD2", "IWorkbenchWindowPulldownDelegate", false /no prefix match/, false /* should not match */);	639	assertCamelCase("IWWPD2", "IWorkbenchWindowPulldownDelegate", true /same part count/, false /* should not match */);
640	assertCamelCase("IWWPD2", "IWorkbenchWindowPulldownDelegate2", false /no prefix match/, true /* should match */);	640	assertCamelCase("IWWPD2", "IWorkbenchWindowPulldownDelegate2", true /same part count/, true /* should match */);
641	assertCamelCase("UTF16DSS", "UTF16DocumentScannerSupport", false /no prefix match/, true /* should match */);	641	assertCamelCase("UTF16DSS", "UTF16DocumentScannerSupport", true /same part count/, true /* should match */);
642	assertCamelCase("UTF16DSS", "UTF1DocScannerSupport", false /no prefix match/, false /* should not match */);	642	assertCamelCase("UTF16DSS", "UTF1DocScannerSupport", true /same part count/, false /* should not match */);
643	assertCamelCase("UTF16DSS", "UTF6DocScannerSupport", false /no prefix match/, false /* should not match */);	643	assertCamelCase("UTF16DSS", "UTF6DocScannerSupport", true /same part count/, false /* should not match */);
644	assertCamelCase("UTF16DSS", "UTFDocScannerSupport", false /no prefix match/, false /* should not match */);	644	assertCamelCase("UTF16DSS", "UTFDocScannerSupport", true /same part count/, false /* should not match */);
645	assertCamelCase("UTF1DSS", "UTF16DocumentScannerSupport", false /no prefix match/, true /* should match */);	645	assertCamelCase("UTF1DSS", "UTF16DocumentScannerSupport", true /same part count/, true /* should match */);
646	assertCamelCase("UTF1DSS", "UTF1DocScannerSupport", false /no prefix match/, true /* should match */);	646	assertCamelCase("UTF1DSS", "UTF1DocScannerSupport", true /same part count/, true /* should match */);
647	assertCamelCase("UTF1DSS", "UTF6DocScannerSupport", false /no prefix match/, false /* should not match */);	647	assertCamelCase("UTF1DSS", "UTF6DocScannerSupport", true /same part count/, false /* should not match */);
648	assertCamelCase("UTF1DSS", "UTFDocScannerSupport", false /no prefix match/, false /* should not match */);	648	assertCamelCase("UTF1DSS", "UTFDocScannerSupport", true /same part count/, false /* should not match */);
649	assertCamelCase("UTF6DSS", "UTF16DocumentScannerSupport", false /no prefix match/, true /* should match */);	649	assertCamelCase("UTF6DSS", "UTF16DocumentScannerSupport", true /same part count/, true /* should match */);
650	assertCamelCase("UTF6DSS", "UTF1DocScannerSupport", false /no prefix match/, false /* should not match */);	650	assertCamelCase("UTF6DSS", "UTF1DocScannerSupport", true /same part count/, false /* should not match */);
651	assertCamelCase("UTF6DSS", "UTF6DocScannerSupport", false /no prefix match/, true /* should match */);	651	assertCamelCase("UTF6DSS", "UTF6DocScannerSupport", true /same part count/, true /* should match */);
652	assertCamelCase("UTF6DSS", "UTFDocScannerSupport", false /no prefix match/, false /* should not match */);	652	assertCamelCase("UTF6DSS", "UTFDocScannerSupport", true /same part count/, false /* should not match */);
653	assertCamelCase("UTFDSS", "UTF16DocumentScannerSupport", false /no prefix match/, true /* should match */);	653	assertCamelCase("UTFDSS", "UTF16DocumentScannerSupport", true /same part count/, true /* should match */);
654	assertCamelCase("UTFDSS", "UTF1DocScannerSupport", false /no prefix match/, true /* should match */);	654	assertCamelCase("UTFDSS", "UTF1DocScannerSupport", true /same part count/, true /* should match */);
655	assertCamelCase("UTFDSS", "UTF6DocScannerSupport", false /no prefix match/, true /* should match */);	655	assertCamelCase("UTFDSS", "UTF6DocScannerSupport", true /same part count/, true /* should match */);
656	assertCamelCase("UTFDSS", "UTFDocScannerSupport", false /no prefix match/, true /* should match */);	656	assertCamelCase("UTFDSS", "UTFDocScannerSupport", true /same part count/, true /* should match */);
657	// Verify that there were no unexpected results	657	// Verify that there were no unexpected results
658	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);	658	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
659	}	659	}
660	// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=124624	660	// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=124624
661	public void test71() {	661	public void test71() {
662	assertCamelCase("HM", "HashMap", false /no prefix match/, true /should match/);	662	assertCamelCase("HM", "HashMap", true /same count of parts expected/, true /should match/);
663	assertCamelCase("HM", "HtmlMapper", false /no prefix match/, true /should match/);	663	assertCamelCase("HM", "HtmlMapper", true /same count of parts expected/, true /should match/);
664	assertCamelCase("HM", "HashMapEntry", false /no prefix match/, false /* should not match */);	664	assertCamelCase("HM", "HashMapEntry", true /same count of parts expected/, false /* should not match */);
665	assertCamelCase("HaM", "HashMap", false /no prefix match/, true /* should match */);	665	assertCamelCase("HaM", "HashMap", true /same count of parts expected/, true /* should match */);
666	assertCamelCase("HaM", "HtmlMapper", false /no prefix match/, false /* should not match */);	666	assertCamelCase("HaM", "HtmlMapper", true /same count of parts expected/, false /* should not match */);
667	assertCamelCase("HaM", "HashMapEntry", false /no prefix match/, false /* should not match */);	667	assertCamelCase("HaM", "HashMapEntry", true /same count of parts expected/, false /* should not match */);
668	assertCamelCase("HashM", "HashMap", false /no prefix match/, true /* should match */);	668	assertCamelCase("HashM", "HashMap", true /same count of parts expected/, true /* should match */);
669	assertCamelCase("HashM", "HtmlMapper", false /no prefix match/, false /* should not match */);	669	assertCamelCase("HashM", "HtmlMapper", true /same count of parts expected/, false /* should not match */);
670	assertCamelCase("HashM", "HashMapEntry", false /no prefix match/, false /* should not match */);	670	assertCamelCase("HashM", "HashMapEntry", true /same count of parts expected/, false /* should not match */);
671	// Verify that there were no unexpected results	671	// Verify that there were no unexpected results
672	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);	672	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
673	}	673	}
Lines 686-700 Link Here
686	}	686	}
687	// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=124624	687	// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=124624
688	public void test72() {	688	public void test72() {
689	assertCamelCase("HMa", "HashMap", false /no prefix match/, false /* should not match */);	689	assertCamelCase("HMa", "HashMap", true /same count of parts expected/, true /* should match */);
690	assertCamelCase("HMa", "HtmlMapper", false /no prefix match/, false /* should not match */);	690	assertCamelCase("HMa", "HtmlMapper", true /same count of parts expected/, true /* should match */);
691	assertCamelCase("HMa", "HashMapEntry", false /no prefix match/, false /* should not match */);	691	assertCamelCase("HMa", "HashMapEntry", true /same count of parts expected/, false /* should not match */);
692	assertCamelCase("HaMa", "HashMap", false /no prefix match/, false /* should not match */);	692	assertCamelCase("HaMa", "HashMap", true /same count of parts expected/, true /* should match */);
693	assertCamelCase("HaMa", "HtmlMapper", false /no prefix match/, false /* should not match */);	693	assertCamelCase("HaMa", "HtmlMapper", true /same count of parts expected/, false /* should not match */);
694	assertCamelCase("HaMa", "HashMapEntry", false /no prefix match/, false /* should not match */);	694	assertCamelCase("HaMa", "HashMapEntry", true /same count of parts expected/, false /* should not match */);
695	assertCamelCase("HashMa", "HashMap", false /no prefix match/, false /* should not match */);	695	assertCamelCase("HashMa", "HashMap", true /same count of parts expected/, true /* should match */);
696	assertCamelCase("HashMa", "HtmlMapper", false /no prefix match/, false /* should not match */);	696	assertCamelCase("HashMa", "HtmlMapper", true /same count of parts expected/, false /* should not match */);
697	assertCamelCase("HashMa", "HashMapEntry", false /no prefix match/, false /* should not match */);	697	assertCamelCase("HashMa", "HashMapEntry", true /same count of parts expected/, false /* should not match */);
698	// Verify that there were no unexpected results	698	// Verify that there were no unexpected results
699	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);	699	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
700	}	700	}
Lines 713-727 Link Here
713	}	713	}
714	// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=124624	714	// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=124624
715	public void test73() {	715	public void test73() {
716	assertCamelCase("HMap", "HashMap", false /no prefix match/, true /should match/);	716	assertCamelCase("HMap", "HashMap", true /same count of parts expected/, true /should match/);
717	assertCamelCase("HMap", "HtmlMapper", false /no prefix match/, false /* should not match */);	717	assertCamelCase("HMap", "HtmlMapper", true /same count of parts expected/, true /* should not match */);
718	assertCamelCase("HMap", "HashMapEntry", false /no prefix match/, false /* should not match */);	718	assertCamelCase("HMap", "HashMapEntry", true /same count of parts expected/, false /* should not match */);
719	assertCamelCase("HaMap", "HashMap", false /no prefix match/, true /* should match */);	719	assertCamelCase("HaMap", "HashMap", true /same count of parts expected/, true /* should match */);
720	assertCamelCase("HaMap", "HtmlMapper", false /no prefix match/, false /* should not match */);	720	assertCamelCase("HaMap", "HtmlMapper", true /same count of parts expected/, false /* should not match */);
721	assertCamelCase("HaMap", "HashMapEntry", false /no prefix match/, false /* should not match */);	721	assertCamelCase("HaMap", "HashMapEntry", true /same count of parts expected/, false /* should not match */);
722	assertCamelCase("HashMap", "HashMap", false /no prefix match/, true /* should match */);	722	assertCamelCase("HashMap", "HashMap", true /same count of parts expected/, true /* should match */);
723	assertCamelCase("HashMap", "HtmlMapper", false /no prefix match/, false /* should not match */);	723	assertCamelCase("HashMap", "HtmlMapper", true /same count of parts expected/, false /* should not match */);
724	assertCamelCase("HashMap", "HashMapEntry", false /no prefix match/, false /* should not match */);	724	assertCamelCase("HashMap", "HashMapEntry", true /same count of parts expected/, false /* should not match */);
725	// Verify that there were no unexpected results	725	// Verify that there were no unexpected results
726	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);	726	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
727	}	727	}