Attachment #75758 for bug #109695





		// If characters are not equals, then it's not a match if patternChar is lowercase
		if (patternChar < 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;
		}



			nameChar = name[iName];
			if (nameChar < ScannerHelper.MAX_OBVIOUS) {
				int charNature = ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar];
				if ((charNature & (ScannerHelper.C_LOWER_LETTER | ScannerHelper.C_SPECIAL)) != 0) {
					// nameChar is lowercase    
					iName++;
				} else if ((charNature & ScannerHelper.C_DIGIT) != 0) {
					// nameChar is digit => break if the digit is current pattern character otherwise consume it
					if (patternChar == nameChar) break;
					iName++;
				// nameChar is uppercase...
				} else  if (patternChar != nameChar) {
					//.. and it does not match patternChar, so it's not a match

					break;
				}
			}
			// Same tests for non-obvious characters
			else if (Character.isJavaIdentifierPart(nameChar) && !Character.isUpperCase(nameChar)) {
				// nameChar is lowercase    
				iName++;
			} else if (Character.isDigit(nameChar)) {
				if (patternChar == nameChar) break;
				iName++;
			} else  if (patternChar != nameChar) {
				//.. and it does not match patternChar, so it's not a match
				return false;
			} else {
				//.. and it matched patternChar. Back to the big loop
				break;
			}
		}




/**
 * Answers true if the pattern matches the given name using CamelCase rules, or false otherwise. 
 * CamelCase matching does NOT accept explicit wild-cards '*' and '?' and is inherently case sensitive.
 * 
 * CamelCase denotes the convention of writing compound names without spaces, and capitalizing every term.
 * This function recognizes both upper and lower CamelCase, depending whether the leading character is capitalized
 * or not. The leading part of an upper CamelCase pattern is assumed to contain a sequence of capitals which are appearing
 * in the matching name; e.g. 'NPE' will match 'NullPointerException', but not 'NewPerfData'. A lower CamelCase pattern
 * uses a lowercase first character. In Java, type names follow the upper CamelCase convention, whereas method or field
 * names follow the lower CamelCase convention.
 * <br>
 * The pattern may contain lowercase characters, which will be match in a case sensitive way. These characters must
 * appear in sequence in the name. For instance, 'NPExcep' will match 'NullPointerException', but not 'NullPointerExCEPTION'
 * or 'NuPoEx' will match 'NullPointerException', but not 'NoPointerException'.
 * <br><br>
 * Examples:
 * <ol>
 * <li><pre>
 *    pattern = "NPE"
 *    name = NullPointerException / NoPermissionException
 *    result => true
 * </pre>
 * </li>
 * <li><pre>
 *    pattern = "NuPoEx"
 *    name = NullPointerException
 *    result => true
 * </pre>
 * </li>
 * <li><pre>
 *    pattern = "npe"
 *    name = NullPointerException
 *    result => false
 * </pre>
 * </li>
 * </ol>
 * @see CharOperation#camelCaseMatch(char[], char[])
 * 	Implementation has been entirely copied from this method except for array lengthes
 * 	which were obviously replaced with calls to {@link String#length()}.
 * 
 * @param pattern the given pattern
 * @param name the given name

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

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

/**
 * Answers true if a sub-pattern matches the subpart of the given name using CamelCase rules, or false otherwise.  
 * char[] CamelCase matching does NOT accept explicit wild-cards '*' and '?' and is inherently case sensitive. 
 * Can match only subset of name/pattern, considering end positions as non-inclusive.
 * The subpattern is defined by the patternStart and patternEnd positions.
 * 
 * @see CharOperation#camelCaseMatch(char[], int, int, char[], int, int) for specification
 * and implementation of this algorithm.
 * or not. The leading part of an upper CamelCase pattern is assumed to contain a sequence of capitals which are appearing
 * in the matching name; e.g. 'NPE' will match 'NullPointerException', but not 'NewPerfData'. A lower CamelCase pattern
 * uses a lowercase first character. In Java, type names follow the upper CamelCase convention, whereas method or field
 * names follow the lower CamelCase convention.
 * <br>
 * The pattern may contain lowercase characters, which will be match in a case sensitive way. These characters must
 * appear in sequence in the name. For instance, 'NPExcep' will match 'NullPointerException', but not 'NullPointerExCEPTION'
 * or 'NuPoEx' will match 'NullPointerException', but not 'NoPointerException'.
 * <br><br>
 * Examples:
 * <ol>
 * <li><pre>
 *    pattern = "NPE"
 *    patternStart = 0
 *    patternEnd = 3
 *    name = NullPointerException
 *    nameStart = 0
 *    nameEnd = 20
 *    result => true
 * </pre>
 * </li>
 * <li><pre>
 *    pattern = "NPE"
 *    patternStart = 0
 *    patternEnd = 3
 *    name = NoPermissionException
 *    nameStart = 0
 *    nameEnd = 21
 *    result => true
 * </pre>
 * </li>
 * <li><pre>
 *    pattern = "NuPoEx"
 *    patternStart = 0
 *    patternEnd = 6
 *    name = NullPointerException
 *    nameStart = 0
 *    nameEnd = 20
 *    result => true
 * </pre>
 * </li>
 * <li><pre>
 *    pattern = "NuPoEx"
 *    patternStart = 0
 *    patternEnd = 6
 *    name = NoPermissionException
 *    nameStart = 0
 *    nameEnd = 21
 *    result => false
 * </pre>
 * </li>
 * <li><pre>
 *    pattern = "npe"
 *    patternStart = 0
 *    patternEnd = 3
 *    name = NullPointerException
 *    nameStart = 0
 *    nameEnd = 20
 *    result => false
 * </pre>
 * </li>
 * </ol>
 * @see CharOperation#camelCaseMatch(char[], int, int, char[], int, int)
 * 	Implementation has been entirely copied from this method except for array lengthes
 * 	which were obviously replaced with calls to {@link String#length()} and
 * 	for array direct access which were replaced with calls to {@link String#charAt(int)}.
 * 
 * @param pattern the given pattern
 * @param patternStart the start index of the pattern, inclusive

 * @since 3.2
 */
public static final boolean camelCaseMatch(String pattern, int patternStart, int patternEnd, String name, int nameStart, int nameEnd) {
	return CharOperation.camelCaseMatch(pattern.toCharArray(), patternStart, patternEnd, name.toCharArray(), nameStart, nameEnd);
		return false; // null name cannot match
	if (pattern == null)
		return true; // null pattern is equivalent to '*'
	if (patternEnd < 0) 	patternEnd = pattern.length();
	if (nameEnd < 0) nameEnd = name.length();

	if (patternEnd <= patternStart) return nameEnd <= nameStart;
	if (nameEnd <= nameStart) return false;
	// check first pattern char
	if (name.charAt(nameStart) != pattern.charAt(patternStart)) {
		// first char must strictly match (upper/lower)
		return false;
	}

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

	// Main loop is on pattern characters
	while (true) {

		iPattern++;
		iName++;

		if (iPattern == patternEnd) {
			// We have exhausted pattern, so it's a match
			return true;
		}

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

		// For as long as we're exactly matching, bring it on (even if it's a lower case character)
		if ((patternChar = pattern.charAt(iPattern)) == name.charAt(iName)) {
			continue;
		}

		// If characters are not equals, then it's not a match if patternChar is lowercase
		if (patternChar < ScannerHelper.MAX_OBVIOUS) {
			if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[patternChar] & ScannerHelper.C_UPPER_LETTER) == 0) {
				return false;
			}
		}
		else if (Character.isJavaIdentifierPart(patternChar) && !Character.isUpperCase(patternChar)) {
			return false;
		}

		// patternChar is uppercase, so let's find the next uppercase in name
		while (true) {
			if (iName == nameEnd){
	            //	We have exhausted name (and not pattern), so it's not a match
				return false;
			}

			nameChar = name.charAt(iName);

			if (nameChar < ScannerHelper.MAX_OBVIOUS) {
				if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar] & (ScannerHelper.C_LOWER_LETTER | ScannerHelper.C_SPECIAL | ScannerHelper.C_DIGIT)) != 0) {
					// nameChar is lowercase    
					iName++;
				// nameChar is uppercase...
				} else  if (patternChar != nameChar) {
					//.. and it does not match patternChar, so it's not a match
					return false;
				} else {
					//.. and it matched patternChar. Back to the big loop
					break;
				}
			}
			else if (Character.isJavaIdentifierPart(nameChar) && !Character.isUpperCase(nameChar)) {
				// nameChar is lowercase    
				iName++;
			// nameChar is uppercase...
			} else  if (patternChar != nameChar) {
				//.. and it does not match patternChar, so it's not a match
				return false;
			} else {
				//.. and it matched patternChar. Back to the big loop
				break;
			}
		}
		// At this point, either name has been exhausted, or it is at an uppercase letter.
		// Since pattern is also at an uppercase letter
	}
}	

/**




	}
}

IJavaSearchScope getJavaSearchScope() {
	return SearchEngine.createJavaSearchScope(new IJavaProject[] {getJavaProject("JavaSearchBugs")});
}
IJavaSearchScope getJavaSearchScopeBugs(String packageName, boolean addSubpackages) throws JavaModelException {
	if (packageName == null) return getJavaSearchScope();
	return getJavaSearchPackageScope("JavaSearchBugs", packageName, addSubpackages);
}
public ICompilationUnit getWorkingCopy(String path, String source) throws JavaModelException {

	return getWorkingCopy(path, source, this.wcOwner);
}
protected void search(IJavaElement element, int limitTo) throws CoreException {
	search(element, limitTo, EXACT_RULE, getJavaSearchScope(), resultCollector);
}
protected void search(IJavaElement element, int limitTo, int matchRule) throws CoreException {
	search(element, limitTo, matchRule, getJavaSearchScope(), resultCollector);
}
protected void search(String patternString, int searchFor, int limitTo) throws CoreException {
	search(patternString, searchFor, limitTo, EXACT_RULE, getJavaSearchScope(), resultCollector);
}
protected void search(String patternString, int searchFor, int limitTo, int matchRule) throws CoreException {
	search(patternString, searchFor, limitTo, matchRule, getJavaSearchScope(), resultCollector);
}
/* (non-Javadoc)
 * @see org.eclipse.jdt.core.tests.model.SuiteOfTestCases#setUpSuite()

	new SearchEngine(workingCopies).search(
		pattern,
		new SearchParticipant[] {SearchEngine.getDefaultSearchParticipant()},
		getJavaSearchScope(),
		resultCollector,
		null
	);

	new SearchEngine(workingCopies).search(
		pattern,
		new SearchParticipant[] {SearchEngine.getDefaultSearchParticipant()},
		getJavaSearchScope(),
		resultCollector,
		null
	);

		IIndexConstants.ONE_STAR,
		SearchPattern.R_PATTERN_MATCH, // case insensitive
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null

		"*tion".toCharArray(),
		SearchPattern.R_PATTERN_MATCH, // case insensitive
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null

		IIndexConstants.ONE_STAR,
		SearchPattern.R_PATTERN_MATCH, // case insensitive
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null

		new char[] { 'X' },
		SearchPattern.R_PREFIX_MATCH, // case insensitive
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null

	);
	IType type = selectType(workingCopies[0], "Annot");
	IMethod method = type.getMethod("value", new String[0]);
	search(method, REFERENCES, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/b93392/Test.java b93392.Test [41] EXACT_MATCH\n" +
		"src/b93392/Test.java b93392.Test.bar [21] EXACT_MATCH\n" +

	int methodsLength = methods.length;

	// Perform search on each duplicate method
	IJavaSearchScope scope = getJavaSearchScope();
	for (int m=0; m<methodsLength; m++) {

		// Search method declaration

	// Verify matches
	TestCollector occurencesCollector = new TestCollector();
	occurencesCollector.showAccuracy = true;
	search(type, ALL_OCCURRENCES, getJavaSearchScope(), occurencesCollector);
	assertSearchResults(
		"src/b95794/Test.java [b95794.Test] EXACT_MATCH\n" +
		"src/b95794/Test.java [b95794.Test] EXACT_MATCH\n" +


	// Verify with references matches
	TestCollector referencesCollector = new TestCollector();
	search(type, REFERENCES, getJavaSearchScope(), referencesCollector);
	assertEquals("Problem with occurences or references number of matches: ", occurencesCollector.matches.size()-1, referencesCollector.matches.size());
}
public void testBug95794b() throws CoreException {

	// Verify matches
	TestCollector occurencesCollector = new TestCollector();
	occurencesCollector.showAccuracy = true;
	search(type, ALL_OCCURRENCES, getJavaSearchScope(), occurencesCollector);
	assertSearchResults(
		"src/b95794/Test.java [b95794.Test.Color] EXACT_MATCH\n" +
		"src/b95794/Test.java [b95794.Test.Color] EXACT_MATCH\n" +


	// Verify with references matches
	TestCollector referencesCollector = new TestCollector();
	search(type, REFERENCES, getJavaSearchScope(), referencesCollector);
	assertEquals("Problem with occurences or references number of matches: ", occurencesCollector.matches.size()-1, referencesCollector.matches.size());
}
public void testBug95794c() throws CoreException {

	// Verify matches
	TestCollector occurencesCollector = new TestCollector();
	occurencesCollector.showAccuracy = true;
	search(field, ALL_OCCURRENCES, getJavaSearchScope(), occurencesCollector);
	assertSearchResults(
		"src/b95794/Test.java [WHITE] EXACT_MATCH\n" +
		"src/b95794/Test.java void b95794.Test.main(String[]) [WHITE] EXACT_MATCH\n" +


	// Verify with references matches
	TestCollector referencesCollector = new TestCollector();
	search(field, REFERENCES, getJavaSearchScope(), referencesCollector);
	assertEquals("Problem with occurences or references number of matches: ", occurencesCollector.matches.size()-1, referencesCollector.matches.size());
}


	IMethod method = type.getMethod("subroutine", new String[] { "F" });
	SearchPattern pattern = SearchPattern.createPattern(method, REFERENCES, EXACT_RULE);
	assertNotNull("Pattern should not be null", pattern);
	search(pattern, getJavaSearchScope(), resultCollector);
	assertSearchResults(
		"src/b108088/B108088.java void b108088.B108088.doit(A108088, String) [subroutine(1.2f)] EXACT_MATCH"
	);
}

/**
 * Bug 109695: [search] Inaccurate search match for method invocations with literal arguments
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=109695"
 */
public void testBug109695() throws CoreException {
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/IDocumentExtension.java",
		"public interface IDocumentExtension {}\n" + 
		"interface IDocumentExtension2 {}\n" + 
		"interface IDocumentExtension3 {}\n" + 
		"interface IDocumentExtension135 {}\n" + 
		"interface IDocumentExtension315 {}\n"
	);
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("IDE3", SearchPattern.R_CAMELCASE_MATCH, requestor);
	assertSearchResults(
		"IDocumentExtension135\n" + 
		"IDocumentExtension3\n" + 
		"IDocumentExtension315",
		requestor
	);
}
public void testBug109695b() throws CoreException {
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/IDocumentProviderExtension.java",
		"public interface IDocumentProviderExtension {}\n" + 
		"interface IDocumentProviderExtension2 {}\n" + 
		"interface IDocumentProviderExtension3 {}\n" + 
		"interface IDocumentProviderExtension4 {}\n" + 
		"interface IDocumentProviderExtension5 {}\n" + 
		"interface IDocumentProviderExtension12345 {}\n" + 
		"interface IDocumentProviderExtension54321 {}\n"
	);
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("IDPE3", SearchPattern.R_CAMELCASE_MATCH, requestor);
	assertSearchResults(
		"IDocumentProviderExtension12345\n" + 
		"IDocumentProviderExtension3\n" + 
		"IDocumentProviderExtension54321",
		requestor
	);
}
public void testBug109695c() throws CoreException {
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/IPerspectiveListener.java",
		"public interface IPerspectiveListener {}\n" + 
		"interface IPerspectiveListener2 {}\n" + 
		"interface IPerspectiveListener3 {}\n"
	);
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("IPL3", SearchPattern.R_CAMELCASE_MATCH, requestor);
	assertSearchResults(
		"IPerspectiveListener3",
		requestor
	);
}
public void testBug109695d() throws CoreException {
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/IPropertySource.java",
		"public interface IPropertySource {}\n" + 
		"interface IPropertySource2 {}\n"
	);
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("IPS2", SearchPattern.R_CAMELCASE_MATCH, requestor);
	assertSearchResults(
		"IPropertySource2",
		requestor
	);
}
public void testBug109695e() throws CoreException {
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/IWorkbenchWindowPulldownDelegate.java",
		"public interface IWorkbenchWindowPulldownDelegate {}\n" + 
		"interface IWorkbenchWindowPulldownDelegate1 {}\n" + 
		"interface IWorkbenchWindowPulldownDelegate2 {}\n" + 
		"interface IWorkbenchWindowPulldownDelegate3 {}\n" + 
		"interface IWorkbenchWindowPulldownDelegate4 {}\n"
	);
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("IWWPD2", SearchPattern.R_CAMELCASE_MATCH, requestor);
	assertSearchResults(
		"IWorkbenchWindowPulldownDelegate2",
		requestor
	);
}
public void testBug109695f() throws CoreException {
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/UTF16DocumentScannerSupport.java",
		"public class UTF16DocumentScannerSupport {}\n" + 
		"class UTF1DocScannerSupport {}\n" +
		"class UTF6DocScannerSupport {}\n" +
		"class UTFDocScannerSupport {}\n"
	);
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("UTF16DSS", SearchPattern.R_CAMELCASE_MATCH, requestor);
	assertSearchResults(
		"UTF16DocumentScannerSupport",
		requestor
	);
}
public void testBug109695g() throws CoreException {
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/UTF16DocumentScannerSupport.java",
		"public class UTF16DocumentScannerSupport {}\n" + 
		"class UTF1DocScannerSupport {}\n" +
		"class UTF6DocScannerSupport {}\n" +
		"class UTFDocScannerSupport {}\n"
	);
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("UTF1DSS", SearchPattern.R_CAMELCASE_MATCH, requestor);
	assertSearchResults(
		"UTF16DocumentScannerSupport\n" + 
		"UTF1DocScannerSupport",
		requestor
	);
}
public void testBug109695h() throws CoreException {
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/UTF16DocumentScannerSupport.java",
		"public class UTF16DocumentScannerSupport {}\n" + 
		"class UTF1DocScannerSupport {}\n" +
		"class UTF6DocScannerSupport {}\n" +
		"class UTFDocScannerSupport {}\n"
	);
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("UTF6DSS", SearchPattern.R_CAMELCASE_MATCH, requestor);
	assertSearchResults(
		"UTF16DocumentScannerSupport\n" + 
		"UTF6DocScannerSupport",
		requestor
	);
}
public void testBug109695i() throws CoreException {
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/UTF16DocumentScannerSupport.java",
		"public class UTF16DocumentScannerSupport {}\n" + 
		"class UTF1DocScannerSupport {}\n" +
		"class UTF6DocScannerSupport {}\n" +
		"class UTFDocScannerSupport {}\n"
	);
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("UTFDSS", SearchPattern.R_CAMELCASE_MATCH, requestor);
	assertSearchResults(
		"UTF16DocumentScannerSupport\n" + 
		"UTF1DocScannerSupport\n" + 
		"UTF6DocScannerSupport\n" + 
		"UTFDocScannerSupport",
		requestor
	);
}

/**
 * To get these tests search matches in a workspace, do NOT forget to modify files
 * to set them as working copies.
 *

		"AA".toCharArray(),
		SearchPattern.R_CAMELCASE_MATCH,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null

		"AA".toCharArray(),
		SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_PREFIX_MATCH,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null

		"AA".toCharArray(),
		SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null

		"AA".toCharArray(),
		SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null

		"AA".toCharArray(),
		SearchPattern.R_PREFIX_MATCH,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null

		"AA".toCharArray(),
		SearchPattern.R_CASE_SENSITIVE,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null

		"AA".toCharArray(),
		SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null

		"aa".toCharArray(),
		SearchPattern.R_CAMELCASE_MATCH,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null

		"aa".toCharArray(),
		SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_PREFIX_MATCH,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null

		"aa".toCharArray(),
		SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null

		"aa".toCharArray(),
		SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null

		"aa".toCharArray(),
		SearchPattern.R_PREFIX_MATCH,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null

		"aa".toCharArray(),
		SearchPattern.R_CASE_SENSITIVE,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null

		"aa".toCharArray(),
		SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null

	);
	IType type = this.workingCopies[0].getType("Test");
	TypeReferencesCollector collector = new TypeReferencesCollector();
	search(type, REFERENCES, EXACT_RULE, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/b110336/Test.java void b110336.Test.method(Class<Test>).TP [Test]\n" +
		"src/b110336/Test.java void b110336.Test.method(Class<Test>).clazz [Test]\n" +

	);
	IType type = this.workingCopies[0].getType("Test");
	TypeReferencesCollector collector = new TypeReferencesCollector();
	search(type, REFERENCES, EXACT_RULE, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/b110336/Test.java void b110336.Test.method1(Test):<anonymous>#1 [Test]\n" +
		"src/b110336/Test.java void b110336.Test.method1(Test):<anonymous>#1.c [Test]\n" +

	);
	IType type = this.workingCopies[0].getType("X");
	TypeReferencesCollector collector = new TypeReferencesCollector();
	search(type, REFERENCES, EXACT_RULE, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/b110336/Test.java b110336.Test.TP [X]\n" +
		"src/b110336/Test.java b110336.Test.x [X]",

	);
	IType type = this.workingCopies[0].getType("Test");
	TypeReferencesCollector collector = new TypeReferencesCollector();
	search(type, REFERENCES, EXACT_RULE, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/b110336/Test.java b110336.Test.a1Test [Test]+[b1Test,c1Test]\n" +
		"src/b110336/Test.java b110336.Test.b1Test [Test]\n" +

	);
	IType type = this.workingCopies[0].getType("Test");
	TypeReferencesCollector collector = new TypeReferencesCollector();
	search(type, REFERENCES, EXACT_RULE, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/b110336/Test.java void b110336.Test.foo().lv1 [Test]+[lv2,lv3]\n" +
		"src/b110336/Test.java void b110336.Test.foo().lv2 [Test]\n" +

	);
	IType type = this.workingCopies[0].getType("Test");
	TypeReferencesCollector collector = new TypeReferencesCollector();
	search(type, REFERENCES, EXACT_RULE, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/b110336/Test.java void b110336.Test.foo(Test).test1 [Test]\n" +
		"src/b110336/Test.java void b110336.Test.foo(Test).test2 [Test]\n" +

	);
	IType type = this.workingCopies[0].getType("Test");
	TypeReferencesCollector collector = new TypeReferencesCollector();
	search(type, REFERENCES, EXACT_RULE, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/b110336/Test.java b110336.Test.{}.lv1 [Test]+[lv2,lv3]\n" +
		"src/b110336/Test.java b110336.Test.{}.lv2 [Test]\n" +

	);
	IType type = this.workingCopies[0].getType("Test");
	TypeReferencesCollector collector = new TypeReferencesCollector();
	search(type, REFERENCES, EXACT_RULE, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/b110336/Test.java b110336.Test.static {}.lv1 [Test]+[lv2,lv3]\n" +
		"src/b110336/Test.java b110336.Test.static {}.lv2 [Test]\n" +

		CharOperation.NO_CHAR,
		SearchPattern.R_PREFIX_MATCH,
		IJavaSearchConstants.TYPE,
		getJavaSearchScope(),
		requestor,
		WAIT_UNTIL_READY_TO_SEARCH,
		null

	new SearchEngine(workingCopies).search(
		SearchPattern.createPattern(type, REFERENCES),
		new SearchParticipant[] {SearchEngine.getDefaultSearchParticipant()},
		getJavaSearchScope(),
		this.resultCollector,
		null
	);

		null,
		SearchPattern.R_PATTERN_MATCH, // case insensitive
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null

	SearchPattern leftPattern = SearchPattern.createPattern(type1, IMPLEMENTORS);
	IType type2 = getCompilationUnit("JavaSearchBugs", "src", "b142044", "I142044_B.java").getType("I142044_B");
	SearchPattern rightPattern = SearchPattern.createPattern(type2, IMPLEMENTORS);
	search(SearchPattern.createAndPattern(leftPattern, rightPattern), getJavaSearchScope(), this.resultCollector);
	assertSearchResults("");
}
/**

	SearchPattern leftPattern = SearchPattern.createPattern(type1, IMPLEMENTORS);
	IType type2 = getCompilationUnit("JavaSearchBugs", "src", "b142044", "I142044_A.java").getType("I142044_A");
	SearchPattern rightPattern = SearchPattern.createPattern(type2, IMPLEMENTORS);
	search(SearchPattern.createAndPattern(leftPattern, rightPattern), getJavaSearchScope(), this.resultCollector);
	assertSearchResults(
		"src/b142044/X142044.java b142044.X142044$XX1 [I142044_A] EXACT_MATCH\n" +
		"src/b142044/X142044.java b142044.X142044$XX12 [I142044_A] EXACT_MATCH\n" +

	SearchPattern leftPattern = createPattern("X*", CLASS, DECLARATIONS, true);
	IType iType = getCompilationUnit("JavaSearchBugs", "src", "b142044", "I142044_A.java").getType("I142044_A");
	SearchPattern rightPattern = SearchPattern.createPattern(iType, IMPLEMENTORS);
	search(SearchPattern.createAndPattern(leftPattern, rightPattern), getJavaSearchScope(), this.resultCollector);
	assertSearchResults(""); // currently no results as only same kind of pattern are ANDoable...
}
/**

	IType type1 = getCompilationUnit("JavaSearchBugs", "src", "b142044", "I142044_A.java").getType("I142044_A");
	SearchPattern leftPattern = SearchPattern.createPattern(type1, IMPLEMENTORS);
	SearchPattern rightPattern = createPattern("I*", CLASS, IMPLEMENTORS, true);
	search(SearchPattern.createAndPattern(leftPattern, rightPattern), getJavaSearchScope(), this.resultCollector);
	assertSearchResults(
		"src/b142044/X142044.java b142044.X142044$XX1 [I142044_A] EXACT_MATCH\n" +
		"src/b142044/X142044.java b142044.X142044$XX12 [I142044_A] EXACT_MATCH\n" +

	SearchPattern leftPattern = SearchPattern.createPattern(type1, IMPLEMENTORS);
	IType type2 = getCompilationUnit("JavaSearchBugs", "src", "b142044", "I142044_B.java").getType("I142044_B");
	SearchPattern rightPattern = SearchPattern.createPattern(type2, IMPLEMENTORS);
	search(SearchPattern.createOrPattern(leftPattern, rightPattern), getJavaSearchScope(), this.resultCollector);
	assertSearchResults(
		"src/b142044/X142044.java b142044.X142044$XX1 [I142044_A] EXACT_MATCH\n" +
		"src/b142044/X142044.java b142044.X142044$XX2 [I142044_B] EXACT_MATCH\n" +

		"package b148380;\n" +
		"public class Y {}\n"
	);
	IJavaSearchScope scope = getJavaSearchScope();
	TypeNameMatchCollector requestor1 = new TypeNameMatchCollector();
	new SearchEngine(this.workingCopies).searchAllTypeNames(
		"b148380".toCharArray(),

	assertSearchResults(expected, requestor2);
}
public void testBug148380_SearchAllTypes_cu() throws CoreException, JavaModelException {
	IJavaSearchScope scope = getJavaSearchScope();
	TypeNameMatchCollector requestor = new TypeNameMatchCollector();
	new SearchEngine().searchAllTypeNames(
		null,

		null,
		SearchPattern.R_PREFIX_MATCH,
		IJavaSearchConstants.TYPE,
		getJavaSearchScope(),
		collector,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null);

		null,
		SearchPattern.R_PREFIX_MATCH,
		IJavaSearchConstants.TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null);

	new SearchEngine().searchAllTypeNames(
		null,
		null,
		getJavaSearchScope(),
		collector,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null);

	new SearchEngine().searchAllTypeNames(
		null,
		null,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null);

	new SearchEngine().searchAllTypeNames(
		null,
		new char[][] { "Test".toCharArray() },
		getJavaSearchScope(),
		collector,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null);

	new SearchEngine().searchAllTypeNames(
		null,
		new char[][] { "Test".toCharArray() },
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null);

	new SearchEngine().searchAllTypeNames(
		packagesList,
		typesList,
		getJavaSearchScope(),
		collector,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null);

	new SearchEngine().searchAllTypeNames(
		packagesList,
		typesList,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null);

	new SearchEngine().searchAllTypeNames(
		packagesList,
		null,
		getJavaSearchScope(),
		collector,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null);

	new SearchEngine().searchAllTypeNames(
		packagesList,
		null,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null);

	new SearchEngine().searchAllTypeNames(
		packagesList,
		null,
		getJavaSearchScope(),
		collector,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null);

	new SearchEngine().searchAllTypeNames(
		packagesList,
		null,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null);

		}
	};
	collector.showAccuracy = true;
	search(type, REFERENCES, getJavaSearchScope(), collector);
	assertSearchResults(
		"lib/b164791.jar test.<anonymous> EXACT_MATCH\n" +
		"lib/b164791.jar test.<anonymous> EXACT_MATCH",

 */
public void testBug167190() throws CoreException, JavaModelException {
	IJavaSearchScope scope = new AbstractSearchScope() {
		IJavaSearchScope jsScope = getJavaSearchScope();
		public void processDelta(IJavaElementDelta delta) {
			// we should have no delta on this test case
		}

		}
		
	};
	search("Foo196339", IJavaSearchConstants.TYPE, IJavaSearchConstants.IMPLEMENTORS, getJavaSearchScope(), collector);
	assertSearchResults(
		"src/b196339/x/y/z/Test1.java b196339.x.y.z.Test1 [Foo196339]\n" + 
		"src/b196339/x/y/z/Test2.java b196339.x.y.z.Test2 [Foo196339]\n" + 

Lines 11795-11801 Link Here

(-)src/org/eclipse/jdt/core/tests/model/CompletionTests.java (-1 / +2 lines)
11795		11795
11796	assertEquals(	11796	assertEquals(
11797	"element:CT1 completion:CT1 relevance:"+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED)+"\n"+	11797	"element:CT1 completion:CT1 relevance:"+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_EXACT_NAME + R_UNQUALIFIED + R_NON_RESTRICTED)+"\n"+
11798	"element:CT1 completion:q2.CT1 relevance:"+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_EXACT_NAME+ R_NON_RESTRICTED),	11798	"element:CT1 completion:q2.CT1 relevance:"+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CASE + R_EXACT_NAME+ R_NON_RESTRICTED)+"\n"+
		11799	"element:CompletionType1 completion:CompletionType1 relevance:"+(R_DEFAULT + R_RESOLVED + R_INTERESTING + R_CAMEL_CASE + R_UNQUALIFIED + R_NON_RESTRICTED),
11799	requestor.getResults());	11800	requestor.getResults());
11800	}	11801	}
11801	public void testCompletionUnaryOperator1() throws JavaModelException {	11802	public void testCompletionUnaryOperator1() throws JavaModelException {




			requestor,
			null);
	}
	protected void searchAllTypeNames(String pattern, int matchRule, TypeNameRequestor requestor) throws JavaModelException {
		new SearchEngine(this.workingCopies).searchAllTypeNames(
			null,
			SearchPattern.R_EXACT_MATCH,
			pattern.toCharArray(),
			matchRule,
			TYPE,
			getJavaSearchScope(),
			requestor,
			IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
			null
		);
	}
	protected void searchDeclarationsOfAccessedFields(IJavaElement enclosingElement, SearchRequestor requestor) throws JavaModelException {
		new SearchEngine().searchDeclarationsOfAccessedFields(enclosingElement, requestor, null);
	}

Return to bug 109695

Lines 363-373 Link Here

(-)compiler/org/eclipse/jdt/core/compiler/CharOperation.java (-7 / +12 lines)
363		363
364	// If characters are not equals, then it's not a match if patternChar is lowercase	364	// If characters are not equals, then it's not a match if patternChar is lowercase
365	if (patternChar < ScannerHelper.MAX_OBVIOUS) {	365	if (patternChar < ScannerHelper.MAX_OBVIOUS) {
366	if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[patternChar] & ScannerHelper.C_UPPER_LETTER) == 0) {	366	if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[patternChar] & (ScannerHelper.C_UPPER_LETTER \| ScannerHelper.C_DIGIT)) == 0) {
367	return false;	367	return false;
368	}	368	}
369	}	369	}
370	else if (Character.isJavaIdentifierPart(patternChar) && !Character.isUpperCase(patternChar)) {	370	else if (Character.isJavaIdentifierPart(patternChar) && !Character.isUpperCase(patternChar) && !Character.isDigit(patternChar)) {
371	return false;	371	return false;
372	}	372	}
373		373
Lines 380-388 Link Here
380		380
381	nameChar = name[iName];	381	nameChar = name[iName];
382	if (nameChar < ScannerHelper.MAX_OBVIOUS) {	382	if (nameChar < ScannerHelper.MAX_OBVIOUS) {
383	if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar] & (ScannerHelper.C_LOWER_LETTER \| ScannerHelper.C_SPECIAL \| ScannerHelper.C_DIGIT)) != 0) {	383	int charNature = ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar];
		384	if ((charNature & (ScannerHelper.C_LOWER_LETTER \| ScannerHelper.C_SPECIAL)) != 0) {
384	// nameChar is lowercase	385	// nameChar is lowercase
385	iName++;	386	iName++;
		387	} else if ((charNature & ScannerHelper.C_DIGIT) != 0) {
		388	// nameChar is digit => break if the digit is current pattern character otherwise consume it
		389	if (patternChar == nameChar) break;
		390	iName++;
386	// nameChar is uppercase...	391	// nameChar is uppercase...
387	} else if (patternChar != nameChar) {	392	} else if (patternChar != nameChar) {
388	//.. and it does not match patternChar, so it's not a match	393	//.. and it does not match patternChar, so it's not a match
Lines 392-406 Link Here
392	break;	397	break;
393	}	398	}
394	}	399	}
		400	// Same tests for non-obvious characters
395	else if (Character.isJavaIdentifierPart(nameChar) && !Character.isUpperCase(nameChar)) {	401	else if (Character.isJavaIdentifierPart(nameChar) && !Character.isUpperCase(nameChar)) {
396	// nameChar is lowercase
397	iName++;	402	iName++;
398	// nameChar is uppercase...	403	} else if (Character.isDigit(nameChar)) {
		404	if (patternChar == nameChar) break;
		405	iName++;
399	} else if (patternChar != nameChar) {	406	} else if (patternChar != nameChar) {
400	//.. and it does not match patternChar, so it's not a match
401	return false;	407	return false;
402	} else {	408	} else {
403	//.. and it matched patternChar. Back to the big loop
404	break;	409	break;
405	}	410	}
406	}	411	}

Lines 632-637 Link Here

(-)src/org/eclipse/jdt/core/tests/model/AbstractJavaSearchTests.java (+13 lines)
632	requestor,	632	requestor,
633	null);	633	null);
634	}	634	}
		635	protected void searchAllTypeNames(String pattern, int matchRule, TypeNameRequestor requestor) throws JavaModelException {
		636	new SearchEngine(this.workingCopies).searchAllTypeNames(
		637	null,
		638	SearchPattern.R_EXACT_MATCH,
		639	pattern.toCharArray(),
		640	matchRule,
		641	TYPE,
		642	getJavaSearchScope(),
		643	requestor,
		644	IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		645	null
		646	);
		647	}
635	protected void searchDeclarationsOfAccessedFields(IJavaElement enclosingElement, SearchRequestor requestor) throws JavaModelException {	648	protected void searchDeclarationsOfAccessedFields(IJavaElement enclosingElement, SearchRequestor requestor) throws JavaModelException {
636	new SearchEngine().searchDeclarationsOfAccessedFields(enclosingElement, requestor, null);	649	new SearchEngine().searchDeclarationsOfAccessedFields(enclosingElement, requestor, null);
637	}	650	}

Lines 199-240 Link Here

(-)search/org/eclipse/jdt/core/search/SearchPattern.java (-193 / +7 lines)
199	/**	199	/**
200	* Answers true if the pattern matches the given name using CamelCase rules, or false otherwise.	200	* Answers true if the pattern matches the given name using CamelCase rules, or false otherwise.
201	* CamelCase matching does NOT accept explicit wild-cards '*' and '?' and is inherently case sensitive.	201	* CamelCase matching does NOT accept explicit wild-cards '*' and '?' and is inherently case sensitive.
202	* <br>	202	*
203	* CamelCase denotes the convention of writing compound names without spaces, and capitalizing every term.
204	* This function recognizes both upper and lower CamelCase, depending whether the leading character is capitalized
205	* or not. The leading part of an upper CamelCase pattern is assumed to contain a sequence of capitals which are appearing
206	* in the matching name; e.g. 'NPE' will match 'NullPointerException', but not 'NewPerfData'. A lower CamelCase pattern
207	* uses a lowercase first character. In Java, type names follow the upper CamelCase convention, whereas method or field
208	* names follow the lower CamelCase convention.
209	* <br>
210	* The pattern may contain lowercase characters, which will be match in a case sensitive way. These characters must
211	* appear in sequence in the name. For instance, 'NPExcep' will match 'NullPointerException', but not 'NullPointerExCEPTION'
212	* or 'NuPoEx' will match 'NullPointerException', but not 'NoPointerException'.
213	* <br><br>
214	* Examples:
215	* <ol>
216	* <li><pre>
217	* pattern = "NPE"
218	* name = NullPointerException / NoPermissionException
219	* result => true
220	* </pre>
221	* </li>
222	* <li><pre>
223	* pattern = "NuPoEx"
224	* name = NullPointerException
225	* result => true
226	* </pre>
227	* </li>
228	* <li><pre>
229	* pattern = "npe"
230	* name = NullPointerException
231	* result => false
232	* </pre>
233	* </li>
234	* </ol>
235	* @see CharOperation#camelCaseMatch(char[], char[])	203	* @see CharOperation#camelCaseMatch(char[], char[])
236	* Implementation has been entirely copied from this method except for array lengthes
237	* which were obviously replaced with calls to {@link String#length()}.
238	*	204	*
239	* @param pattern the given pattern	205	* @param pattern the given pattern
240	* @param name the given name	206	* @param name the given name
Lines 247-329 Link Here
247	if (name == null)	213	if (name == null)
248	return false; // null name cannot match	214	return false; // null name cannot match
249		215
250	return camelCaseMatch(pattern, 0, pattern.length(), name, 0, name.length());	216	return CharOperation.camelCaseMatch(pattern.toCharArray(), 0, pattern.length(), name.toCharArray(), 0, name.length());
251	}	217	}
252		218
253	/**	219	/**
254	* Answers true if a sub-pattern matches the subpart of the given name using CamelCase rules, or false otherwise.	220	* Answers true if a sub-pattern matches the subpart of the given name using CamelCase rules, or false otherwise.
255	* CamelCase matching does NOT accept explicit wild-cards '*' and '?' and is inherently case sensitive.	221	* char[] CamelCase matching does NOT accept explicit wild-cards '*' and '?' and is inherently case sensitive.
256	* Can match only subset of name/pattern, considering end positions as non-inclusive.	222	* Can match only subset of name/pattern, considering end positions as non-inclusive.
257	* The subpattern is defined by the patternStart and patternEnd positions.	223	* The subpattern is defined by the patternStart and patternEnd positions.
258	* <br>	224	*
259	* CamelCase denotes the convention of writing compound names without spaces, and capitalizing every term.	225	* @see CharOperation#camelCaseMatch(char[], int, int, char[], int, int) for specification
260	* This function recognizes both upper and lower CamelCase, depending whether the leading character is capitalized	226	* and implementation of this algorithm.
261	* or not. The leading part of an upper CamelCase pattern is assumed to contain a sequence of capitals which are appearing
262	* in the matching name; e.g. 'NPE' will match 'NullPointerException', but not 'NewPerfData'. A lower CamelCase pattern
263	* uses a lowercase first character. In Java, type names follow the upper CamelCase convention, whereas method or field
264	* names follow the lower CamelCase convention.
265	* <br>
266	* The pattern may contain lowercase characters, which will be match in a case sensitive way. These characters must
267	* appear in sequence in the name. For instance, 'NPExcep' will match 'NullPointerException', but not 'NullPointerExCEPTION'
268	* or 'NuPoEx' will match 'NullPointerException', but not 'NoPointerException'.
269	* <br><br>
270	* Examples:
271	* <ol>
272	* <li><pre>
273	* pattern = "NPE"
274	* patternStart = 0
275	* patternEnd = 3
276	* name = NullPointerException
277	* nameStart = 0
278	* nameEnd = 20
279	* result => true
280	* </pre>
281	* </li>
282	* <li><pre>
283	* pattern = "NPE"
284	* patternStart = 0
285	* patternEnd = 3
286	* name = NoPermissionException
287	* nameStart = 0
288	* nameEnd = 21
289	* result => true
290	* </pre>
291	* </li>
292	* <li><pre>
293	* pattern = "NuPoEx"
294	* patternStart = 0
295	* patternEnd = 6
296	* name = NullPointerException
297	* nameStart = 0
298	* nameEnd = 20
299	* result => true
300	* </pre>
301	* </li>
302	* <li><pre>
303	* pattern = "NuPoEx"
304	* patternStart = 0
305	* patternEnd = 6
306	* name = NoPermissionException
307	* nameStart = 0
308	* nameEnd = 21
309	* result => false
310	* </pre>
311	* </li>
312	* <li><pre>
313	* pattern = "npe"
314	* patternStart = 0
315	* patternEnd = 3
316	* name = NullPointerException
317	* nameStart = 0
318	* nameEnd = 20
319	* result => false
320	* </pre>
321	* </li>
322	* </ol>
323	* @see CharOperation#camelCaseMatch(char[], int, int, char[], int, int)
324	* Implementation has been entirely copied from this method except for array lengthes
325	* which were obviously replaced with calls to {@link String#length()} and
326	* for array direct access which were replaced with calls to {@link String#charAt(int)}.
327	*	227	*
328	* @param pattern the given pattern	228	* @param pattern the given pattern
329	* @param patternStart the start index of the pattern, inclusive	229	* @param patternStart the start index of the pattern, inclusive
Lines 335-427 Link Here
335	* @since 3.2	235	* @since 3.2
336	*/	236	*/
337	public static final boolean camelCaseMatch(String pattern, int patternStart, int patternEnd, String name, int nameStart, int nameEnd) {	237	public static final boolean camelCaseMatch(String pattern, int patternStart, int patternEnd, String name, int nameStart, int nameEnd) {
338	if (name == null)	238	return CharOperation.camelCaseMatch(pattern.toCharArray(), patternStart, patternEnd, name.toCharArray(), nameStart, nameEnd);
339	return false; // null name cannot match
340	if (pattern == null)
341	return true; // null pattern is equivalent to '*'
342	if (patternEnd < 0) patternEnd = pattern.length();
343	if (nameEnd < 0) nameEnd = name.length();
344
345	if (patternEnd <= patternStart) return nameEnd <= nameStart;
346	if (nameEnd <= nameStart) return false;
347	// check first pattern char
348	if (name.charAt(nameStart) != pattern.charAt(patternStart)) {
349	// first char must strictly match (upper/lower)
350	return false;
351	}
352
353	char patternChar, nameChar;
354	int iPattern = patternStart;
355	int iName = nameStart;
356
357	// Main loop is on pattern characters
358	while (true) {
359
360	iPattern++;
361	iName++;
362
363	if (iPattern == patternEnd) {
364	// We have exhausted pattern, so it's a match
365	return true;
366	}
367
368	if (iName == nameEnd){
369	// We have exhausted name (and not pattern), so it's not a match
370	return false;
371	}
372
373	// For as long as we're exactly matching, bring it on (even if it's a lower case character)
374	if ((patternChar = pattern.charAt(iPattern)) == name.charAt(iName)) {
375	continue;
376	}
377
378	// If characters are not equals, then it's not a match if patternChar is lowercase
379	if (patternChar < ScannerHelper.MAX_OBVIOUS) {
380	if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[patternChar] & ScannerHelper.C_UPPER_LETTER) == 0) {
381	return false;
382	}
383	}
384	else if (Character.isJavaIdentifierPart(patternChar) && !Character.isUpperCase(patternChar)) {
385	return false;
386	}
387
388	// patternChar is uppercase, so let's find the next uppercase in name
389	while (true) {
390	if (iName == nameEnd){
391	// We have exhausted name (and not pattern), so it's not a match
392	return false;
393	}
394
395	nameChar = name.charAt(iName);
396
397	if (nameChar < ScannerHelper.MAX_OBVIOUS) {
398	if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar] & (ScannerHelper.C_LOWER_LETTER \| ScannerHelper.C_SPECIAL \| ScannerHelper.C_DIGIT)) != 0) {
399	// nameChar is lowercase
400	iName++;
401	// nameChar is uppercase...
402	} else if (patternChar != nameChar) {
403	//.. and it does not match patternChar, so it's not a match
404	return false;
405	} else {
406	//.. and it matched patternChar. Back to the big loop
407	break;
408	}
409	}
410	else if (Character.isJavaIdentifierPart(nameChar) && !Character.isUpperCase(nameChar)) {
411	// nameChar is lowercase
412	iName++;
413	// nameChar is uppercase...
414	} else if (patternChar != nameChar) {
415	//.. and it does not match patternChar, so it's not a match
416	return false;
417	} else {
418	//.. and it matched patternChar. Back to the big loop
419	break;
420	}
421	}
422	// At this point, either name has been exhausted, or it is at an uppercase letter.
423	// Since pattern is also at an uppercase letter
424	}
425	}	239	}
426		240
427	/**	241	/**