Attachment #76871 for bug #124624




 *
 * 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() 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 testCamelCaseTypePattern01b() 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"
	);
}
/** @deprecated As using a depreciated constant */
public void testCamelCaseTypePattern03() throws CoreException {
	search("RuntimeException", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		""+ getExternalJCLPathString() + " java.lang.RuntimeException"
	);
}
/** @deprecated As using a depreciated constant */
public void testCamelCaseTypePattern04() throws CoreException {
	search("RUNTIMEEXCEPTION", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		""+ getExternalJCLPathString() + " java.lang.RuntimeException"
	);
}
/**
 * @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"
	);
}
/** @deprecated As using a depreciated constant */
public void testCamelCaseTypePattern06() throws CoreException {
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	new SearchEngine().searchAllTypeNames(

		"java.lang.CloneNotSupportedException",
		requestor);
}
/** @deprecated As using a depreciated constant */
public void testCamelCaseTypePattern07() throws CoreException {
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	new SearchEngine().searchAllTypeNames(

		"q1.AA",
		requestor);
}
/** @deprecated As using a depreciated constant */
public void testCamelCaseTypePattern08() throws CoreException {
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	new SearchEngine().searchAllTypeNames(

		"q1.AA",
		requestor);
}
/** @deprecated As using a depreciated constant */
public void testCamelCaseTypePattern09() throws CoreException {
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	new SearchEngine().searchAllTypeNames(

		"q1.AA",
		requestor);
}
/** @deprecated As using a depreciated constant */
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"
	);
	search("Null", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"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]"
	);
}
/** @deprecated As using a depreciated constant */
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"
	);
	search("Null", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_PREFIX_MATCH);
	assertSearchResults(
		"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]"
	);
}
/** @deprecated As using a depreciated constant */
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"
	);
	search("Null", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE);
	assertSearchResults(
		"src/Test.java Null [Null]"
	);
}
/** @deprecated As using a depreciated constant */
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"
	);
	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 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]"
	);
}
public void testCamelCaseTypePattern14() 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"
	);
	search("Null", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults(
		"src/Test.java Null [Null]\n" +
		"src/Test.java NULL [NULL]"
	);
}
public void testCamelCaseTypePattern15() 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"
	);
	search("Null", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH | SearchPattern.R_PREFIX_MATCH);
	assertSearchResults(
		"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]"
	);
}
public void testCamelCaseTypePattern16() 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"
	);
	search("Null", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH | SearchPattern.R_CASE_SENSITIVE);
	assertSearchResults(
		"src/Test.java Null [Null]"
	);
}
public void testCamelCaseTypePattern17() 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"
	);
	search("Null", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH | SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE);
	assertSearchResults(
		"src/Test.java Null [Null]\n" +
		"src/Test.java NullPointerException [NullPointerException]"
	);
}

/**
 * @bug 160323: [search] TypeNameMatch: support hashCode/equals




	}
	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()
 */

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

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

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

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

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

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

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

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

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

 */
// Types search
private void setUpBug110060_TypePattern() throws CoreException {
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b110060/Test.java",
		"package b110060;\n" +
		"public class AA {\n" +
		"}\n"
	);
	workingCopies[1] = getWorkingCopy("/JavaSearchBugs/src/b110060/AAxx.java",
		"package b110060;\n" +
		"public class AAxx {\n" +
		"}\n"
	);
	workingCopies[2] = getWorkingCopy("/JavaSearchBugs/src/b110060/AxxAyy.java",
		"package b110060;\n" +
		"public class AxxAyy {\n" +
		"}\n"
	);
	workingCopies[3] = getWorkingCopy("/JavaSearchBugs/src/b110060/AxA.java",
		"package b110060;\n" +
		"public class AxA {\n" +
		"}\n"
	);
	workingCopies[4] = getWorkingCopy("/JavaSearchBugs/src/b110060/Test.java",
		"package b110060;\n" +
		"public class Test {\n" +
		"	Aaa a1;\n" +
		"	AAa a2;\n" +
		"	AaAaAa a3;\n" +
		"	AAxx a4;\n" +
		"	AxA a5;\n" +
		"	AxxAyy a6;\n" +
		"}\n" +
		"class AAa {}\n" +
		"class Aaa {}\n" +
		"class AaAaAa {}\n" +
		"class AAxx {}\n" +
		"class AxA {}\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);
	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\n" + 
		"src/b110060/Test.java b110060.Test.a4 [AAxx] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.a5 [AxA] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.a6 [AxxAyy] EXACT_MATCH"
	);
}
public void testBug110060_TypePattern01new() throws CoreException {
	setUpBug110060_TypePattern();
	search("AA", TYPE, REFERENCES, SearchPattern.R_CAMEL_CASE_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.a5 [AxA] 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);
	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\n" + 
		"src/b110060/Test.java b110060.Test.a4 [AAxx] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.a5 [AxA] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.a6 [AxxAyy] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.AAa [AAa] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Aaa [Aaa] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.AaAaAa [AaAaAa] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.AAxx [AAxx] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.AxA [AxA] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.AxxAyy [AxxAyy] EXACT_MATCH"
	);
}
public void testBug110060_TypePattern02new() throws CoreException {
	setUpBug110060_TypePattern();
	search("AA", TYPE, ALL_OCCURRENCES, SearchPattern.R_CAMEL_CASE_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.a5 [AxA] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.a6 [AxxAyy] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.AAa [AAa] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.AAxx [AAxx] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.AxA [AxA] 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);
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.a4 [AAxx] EXACT_MATCH"
		"src/b110060/Test.java b110060.Test.aaxx [AAxx] EXACT_MATCH"
	);
}
public void testBug110060_TypePattern03new() throws CoreException {
	setUpBug110060_TypePattern();
	search("AAx", TYPE, REFERENCES, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults(
		"" // no result as camel case does not allow prefix match
	);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_TypePattern04() throws CoreException {
	setUpBug110060_TypePattern();
	search("Axx", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.a6 [AxxAyy] EXACT_MATCH"
		"src/b110060/Test.java b110060.Test.axxayy [AxxAyy] EXACT_MATCH"
	);
}
public void testBug110060_TypePattern04new() throws CoreException {
	setUpBug110060_TypePattern();
	search("Axx", TYPE, REFERENCES, SearchPattern.R_CAMEL_CASE_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);
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.a5 [AxA] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.a6 [AxxAyy] EXACT_MATCH"
		"src/b110060/Test.java b110060.Test.axa [AxA] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.axxayy [AxxAyy] EXACT_MATCH"
	);
}
public void testBug110060_TypePattern05new() throws CoreException {
	setUpBug110060_TypePattern();
	search("Ax", TYPE, ALL_OCCURRENCES, SearchPattern.R_CAMEL_CASE_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);
	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\n" + 
		"src/b110060/Test.java b110060.Test.a4 [AAxx] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.a5 [AxA] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.a6 [AxxAyy] EXACT_MATCH"
		"src/b110060/Test.java b110060.Test.axa [AxA] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.axxayy [AxxAyy] EXACT_MATCH\n" +
		""+ getExternalJCLPathString("1.5") + " java.lang.annotation.Annotation EXACT_MATCH"
	);
}
public void testBug110060_TypePattern06new() throws CoreException {
	setUpBug110060_TypePattern();
	search("A*A*", TYPE, REFERENCES, SearchPattern.R_CAMEL_CASE_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\n" + 
		"src/b110060/Test.java b110060.Test.a4 [AAxx] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.a5 [AxA] 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("aa", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"" // no result because it's an invalid camel case pattern which is replaced with 
			// prefix case sensitive match bu SearchPatter.validateMatchRule(...) (old behavior)
	);
}
public void testBug110060_TypePattern07new() throws CoreException {
	setUpBug110060_TypePattern();
	search("aa", TYPE, REFERENCES, SearchPattern.R_CAMEL_CASE_MATCH);
	// Not a valid camel case pattern => changed to prefix
	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\n" + 
		"src/b110060/Test.java b110060.Test.a4 [AAxx] EXACT_MATCH"
	);
}

public void testBug110060_TypePattern08() throws CoreException {
	setUpBug110060_TypePattern();
	search("aa", TYPE, REFERENCES, SearchPattern.R_CAMEL_CASE_MATCH | SearchPattern.R_PREFIX_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\n" + 
		"src/b110060/Test.java b110060.Test.a4 [AAxx] EXACT_MATCH"
	);
}

public void testBug110060_TypePattern09() throws CoreException {
	setUpBug110060_TypePattern();
	search("AA", TYPE, REFERENCES, SearchPattern.R_CAMEL_CASE_MATCH | SearchPattern.R_CASE_SENSITIVE);
	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.a5 [AxA] EXACT_MATCH\n" + 
		"src/b110060/Test.java b110060.Test.a6 [AxxAyy] EXACT_MATCH"
		"src/b110060/Test.java b110060.Test.aa [AA] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.aaxx [AAxx] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.axa [AxA] EXACT_MATCH\n" +
		"src/b110060/Test.java b110060.Test.axxayy [AxxAyy] 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_TypePattern10new() throws CoreException {
	setUpBug110060_TypePattern();
	search("AxAx", TYPE, REFERENCES, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults("");
}
/** @deprecated As using a depreciated constant */
public void testBug110060_TypePattern11() throws CoreException {
	setUpBug110060_TypePattern();
	search("AxxA", TYPE, REFERENCES, SearchPattern.R_CAMELCASE_MATCH);
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.a6 [AxxAyy] EXACT_MATCH"
		"src/b110060/Test.java b110060.Test.axxayy [AxxAyy] EXACT_MATCH"
	);
}
public void testBug110060_TypePattern11new() throws CoreException {
	setUpBug110060_TypePattern();
	search("AxxA", TYPE, REFERENCES, SearchPattern.R_CAMEL_CASE_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);
	assertSearchResults(
		"src/b110060/Test.java b110060.Test.a6 [AxxAyy] EXACT_MATCH"
		"src/b110060/Test.java b110060.Test.axxayy [AxxAyy] EXACT_MATCH"
	);
}
public void testBug110060_TypePattern12new() throws CoreException {
	setUpBug110060_TypePattern();
	search("AxXA", TYPE, REFERENCES, SearchPattern.R_CAMEL_CASE_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);
		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",
		"b110060.AAa\n" + 
		"b110060.AAxx\n" + 
		"b110060.AaAaAa\n" + 
		"b110060.Aaa\n" + 
		"b110060.AxA\n" + 
		"b110060.AxxAyy",
		requestor);
}
public void testBug110060_AllTypeNames01new() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("AA", SearchPattern.R_CAMEL_CASE_MATCH, requestor);
	assertSearchResults(
		"Unexpected all type names",
		"b110060.AAa\n" + 
		"b110060.AAxx\n" + 
		"b110060.AxA\n" + 
		"b110060.AxxAyy",
		requestor);
}

public void testBug110060_AllTypeNames02() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("AA", SearchPattern.R_CAMEL_CASE_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",
		"b110060.AAa\n" + 
		"b110060.AAxx\n" + 
		"b110060.AaAaAa\n" + 
		"b110060.Aaa\n" + 
		"b110060.AxA\n" + 
		"b110060.AxxAyy",
		requestor);
}

public void testBug110060_AllTypeNames03() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("AAA", SearchPattern.R_CAMEL_CASE_MATCH | SearchPattern.R_CASE_SENSITIVE, requestor);
		null,
		SearchPattern.R_EXACT_MATCH,
		"AA".toCharArray(),
		SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null
	);
	assertSearchResults(
		"Unexpected all type names",
		"b110060.AaAaAa",
		"b110060.AAxx\n" +
		"b110060.AxA\n" +
		"b110060.AxxAyy",
		requestor);
}

public void testBug110060_AllTypeNames04() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("AA", SearchPattern.R_CAMEL_CASE_MATCH | SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE, requestor);
		null,
		SearchPattern.R_EXACT_MATCH,
		"AA".toCharArray(),
		SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null
	);
	assertSearchResults(
		"Unexpected all type names",
		"b110060.AAa\n" + 
		"b110060.AAxx\n" + 
		"b110060.AaAaAa\n" + 
		"b110060.AxA\n" + 
		"b110060.AxxAyy",
		requestor);
}

public void testBug110060_AllTypeNames05() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("AA", SearchPattern.R_PREFIX_MATCH, requestor);
		null,
		SearchPattern.R_EXACT_MATCH,
		"AA".toCharArray(),
		SearchPattern.R_PREFIX_MATCH,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null
	);
	assertSearchResults(
		"Unexpected all type names",
		"b110060.AAa\n" + 
		"b110060.AAxx\n" + 
		"b110060.AaAaAa\n" + 
		"b110060.Aaa",
		requestor);
}

public void testBug110060_AllTypeNames06() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("AAA", SearchPattern.R_CASE_SENSITIVE, requestor);
		null,
		SearchPattern.R_EXACT_MATCH,
		"AA".toCharArray(),
		SearchPattern.R_CASE_SENSITIVE,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null
	);
	assertSearchResults(
		"Unexpected all type names",
		"",
		requestor);
}

public void testBug110060_AllTypeNames07() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("AA", SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE, requestor);
		null,
		SearchPattern.R_EXACT_MATCH,
		"AA".toCharArray(),
		SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null
	);
	assertSearchResults(
		"Unexpected all type names",
		"b110060.AAa\n" + 
		"b110060.AAxx",
		requestor);
}
/** @deprecated As using a depreciated constant */
public void testBug110060_AllTypeNames08() throws CoreException {
	setUpBug110060_TypePattern();
	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",
		"b110060.AAa\n" + 
		"b110060.AAxx\n" + 
		"b110060.AaAaAa\n" + 
		"b110060.Aaa",
		requestor);
}
public void testBug110060_AllTypeNames08new() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("aa", SearchPattern.R_CAMEL_CASE_MATCH, requestor);
	assertSearchResults(
		"Unexpected all type names",
		"", // no match as pattern is not a valid camel case
		requestor);
}

public void testBug110060_AllTypeNames09() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("aa", SearchPattern.R_CAMEL_CASE_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",
		"b110060.AAa\n" + 
		"b110060.AAxx\n" + 
		"b110060.AaAaAa\n" + 
		"b110060.Aaa",
		requestor);
}

public void testBug110060_AllTypeNames10() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("aa", SearchPattern.R_CAMEL_CASE_MATCH | SearchPattern.R_CASE_SENSITIVE, requestor);
		null,
		SearchPattern.R_EXACT_MATCH,
		"aa".toCharArray(),
		SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null
	);
	assertSearchResults(
		"Unexpected all type names",
		"", // no match as pattern is not a valid camel case
		requestor);
}

public void testBug110060_AllTypeNames11() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("aa", SearchPattern.R_CAMEL_CASE_MATCH | SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE, requestor);
		null,
		SearchPattern.R_EXACT_MATCH,
		"aa".toCharArray(),
		SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null
	);
	assertSearchResults(
		"Unexpected all type names",
		"",
		requestor);
}

public void testBug110060_AllTypeNames12() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("aa", SearchPattern.R_PREFIX_MATCH, requestor);
		null,
		SearchPattern.R_EXACT_MATCH,
		"aa".toCharArray(),
		SearchPattern.R_PREFIX_MATCH,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null
	);
	assertSearchResults(
		"Unexpected all type names",
		"b110060.AAa\n" + 
		"b110060.AAxx\n" + 
		"b110060.AaAaAa\n" + 
		"b110060.Aaa",
		requestor);
}

public void testBug110060_AllTypeNames13() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("aa", SearchPattern.R_CASE_SENSITIVE, requestor);
		null,
		SearchPattern.R_EXACT_MATCH,
		"aa".toCharArray(),
		SearchPattern.R_CASE_SENSITIVE,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null
	);
	assertSearchResults(
		"Unexpected all type names",
		"",
		requestor);
}

public void testBug110060_AllTypeNames14() throws CoreException {
	setUpBug110060_TypePattern();
	TypeNameRequestor requestor =  new SearchTests.SearchTypeNameRequestor();
	searchAllTypeNames("aa", SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE, requestor);
		null,
		SearchPattern.R_EXACT_MATCH,
		"aa".toCharArray(),
		SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE,
		TYPE,
		getJavaSearchScope(),
		requestor,
		IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		null
	);
	assertSearchResults(
		"Unexpected all type names",
		"",

}
public void testBug110060_ConstructorPattern01() throws CoreException {
	setUpBug110060_ConstructorPattern();
	search("AA", CONSTRUCTOR, REFERENCES, SearchPattern.R_CAMEL_CASE_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.axxayy [new AxxAyy()] EXACT_MATCH"
	);
}

public void testBug110060_ConstructorPattern02() throws CoreException {
	setUpBug110060_ConstructorPattern();
	search("AA", CONSTRUCTOR, ALL_OCCURRENCES, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults(
		"src/b110060/AA.java b110060.AA() [AA] EXACT_MATCH\n" +
		"src/b110060/AAxx.java b110060.AAxx() [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_CAMEL_CASE_MATCH);
	assertSearchResults(
		"" // no match as prefix is not set
		"src/b110060/Test.java b110060.Test.aaxx [new AAxx()] EXACT_MATCH"
	);
}

public void testBug110060_ConstructorPattern04() throws CoreException {
	setUpBug110060_ConstructorPattern();
	search("Axx", CONSTRUCTOR, ALL_OCCURRENCES, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults(
		"" // no match as prefix is not set
		"src/b110060/Test.java b110060.Test.axxayy [new AxxAyy()] EXACT_MATCH"
	);
}

public void testBug110060_ConstructorPattern05() throws CoreException {
	setUpBug110060_ConstructorPattern();
	search("Ax", CONSTRUCTOR, ALL_OCCURRENCES, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults(
		"" // no match as prefix is not set
		"src/b110060/AxxAyy.java b110060.AxxAyy() [AxxAyy] 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_ConstructorPattern06() throws CoreException {
	setUpBug110060_ConstructorPattern();
	search("A*A*", CONSTRUCTOR, ALL_OCCURRENCES, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults(
		"src/b110060/AA.java b110060.AA() [AA] EXACT_MATCH\n" +
		"src/b110060/AAxx.java b110060.AAxx() [AAxx] EXACT_MATCH\n" +

		"}\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_MethodPattern01new() throws CoreException {
	setUpBug110060_MethodPattern();
	search("MWD", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMEL_CASE_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_MethodPattern02new() throws CoreException {
	setUpBug110060_MethodPattern();
	search("AMWD", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMEL_CASE_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_MethodPattern03new() throws CoreException {
	setUpBug110060_MethodPattern();
	search("aMWD", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMEL_CASE_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_MethodPattern04new() throws CoreException {
	setUpBug110060_MethodPattern();
	search("aMW", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults(
		"" // no result as prefix match is not set
	);
}
/** @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_MethodPattern05new() throws CoreException {
	setUpBug110060_MethodPattern();
	search("aMethod", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMEL_CASE_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_MethodPattern06new() throws CoreException {
	setUpBug110060_MethodPattern();
	search("aMethodWith1", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMEL_CASE_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);

		"src/b110060/Test.java void b110060.Test.testReferences() [otherMethodWhichStartsWithAnotherLetter()] EXACT_MATCH"
	);
}
public void testBug110060_MethodPattern07new() throws CoreException {
	setUpBug110060_MethodPattern();
	search("*Method*With*A*", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMEL_CASE_MATCH);
	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.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.otherMethodWhichStartsWithAnotherLetter() [otherMethodWhichStartsWithAnotherLetter] EXACT_MATCH\n" +
		"src/b110060/Test.java void b110060.Test.testReferences() [aMethodWith1DigitAnd_AnUnderscore()] EXACT_MATCH\n" +
		"src/b110060/Test.java void b110060.Test.testReferences() [aMethodWith1Or2_Or_3_Or__4__DigitsAnd_Several_Underscores()] EXACT_MATCH\n" +
		"src/b110060/Test.java void b110060.Test.testReferences() [aMethodWithNothingSpecial()] 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_MethodPattern08new() throws CoreException {
	setUpBug110060_MethodPattern();
	search("aMW1D", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMEL_CASE_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_MethodPattern09new() throws CoreException {
	setUpBug110060_MethodPattern();
	search("aMWOOODASU", METHOD, ALL_OCCURRENCES, SearchPattern.R_CAMEL_CASE_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"
	);
}

// Fields search
private void setUpBug110060_FieldPattern() throws CoreException {

		"}\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_FieldPattern01new() throws CoreException {
	setUpBug110060_FieldPattern();
	search("aFWSD", FIELD, ALL_OCCURRENCES, SearchPattern.R_CAMEL_CASE_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_FieldPattern02new() throws CoreException {
	setUpBug110060_FieldPattern();
	search("afwsd", FIELD, ALL_OCCURRENCES, SearchPattern.R_CAMEL_CASE_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_FieldPattern03new() throws CoreException {
	setUpBug110060_FieldPattern();
	search("aFWS$", FIELD, ALL_OCCURRENCES, SearchPattern.R_CAMEL_CASE_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_FieldPattern04new() throws CoreException {
	setUpBug110060_FieldPattern();
	search("aSFWSCD", FIELD, ALL_OCCURRENCES, SearchPattern.R_CAMEL_CASE_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);

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

/**
 * @test Bug 110291: [search] BasicSearchEngine return constructor declarations that doesn't exist in source

}

/**
 *	@bug 124624: [search] Camel case matching routines should support end character
 *	@test Ensure that camel case pattern may use end character
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=124624"
 */
public void testBug124624_HM_new() throws CoreException {
	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_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"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug124624_HM_old() throws CoreException {
	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 HatMappage [HatMappage] EXACT_MATCH"
	);
}
public void testBug124624_HaM_new() throws CoreException {
	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_CAMEL_CASE_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH\n" + 
		"src/Test.java HatMappage [HatMappage] EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug124624_HaM_old() throws CoreException {
	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 HatMappage [HatMappage] EXACT_MATCH"
	);
}
public void testBug124624_HashM_new() throws CoreException {
	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_CAMEL_CASE_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug124624_HashM_old() throws CoreException {
	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_HMa_new() throws CoreException {
	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_CAMEL_CASE_MATCH);
	assertSearchResults("");
}
/** @deprecated As using a depreciated constant */
public void testBug124624_HMa_old() throws CoreException {
	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 HatMappage [HatMappage] EXACT_MATCH"
	);
}
public void testBug124624_HaMa_new() throws CoreException {
	workingCopies = new ICompilationUnit[1];
	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/Test.java",
		"class HashMap {}\n" + 
		"class HtmlMapper {}\n" + 
		"class HashMapEntry {}\n" + 
		"class HatMappage {}\n"
	);
	search("HaMa", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults("");
}
/** @deprecated As using a depreciated constant */
public void testBug124624_HaMa_old() throws CoreException {
	workingCopies = new ICompilationUnit[1];
	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"
	);
}
public void testBug124624_HashMa_new() throws CoreException {
	workingCopies = new ICompilationUnit[1];
	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_CAMEL_CASE_MATCH);
	assertSearchResults("");
}
/** @deprecated As using a depreciated constant */
public void testBug124624_HashMa_old() throws CoreException {
	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_HMap_new() throws CoreException {
	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_CAMEL_CASE_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug124624_HMap_old() throws CoreException {
	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 HatMappage [HatMappage] EXACT_MATCH"
	);
}
public void testBug124624_HaMap_new() throws CoreException {
	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_CAMEL_CASE_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug124624_HaMap_old() throws CoreException {
	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 HatMappage [HatMappage] EXACT_MATCH"
	);
}
public void testBug124624_HashMap_new() throws CoreException {
	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_CAMEL_CASE_MATCH);
	assertSearchResults(
		"src/Test.java HashMap [HashMap] EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug124624_HashMap_old() throws CoreException {
	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"
	);
}

/**
 * @test Bug 124645: [search] for implementors does not find subclasses of binary classes
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=124645"
 */

		"}\n"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug130390() throws CoreException {
	setUpBug130390();
	search("NuPoEx", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);

		"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
	);
}
public void testBug130390_new() throws CoreException {
	setUpBug130390();
	search("NuPoEx", TYPE, DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults(
		"" // no result as prefix match is not set
	);
}
/** @deprecated As using a depreciated constant */
public void testBug130390b() throws CoreException {
	setUpBug130390();
	search("NPE", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);

		"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
	);
}
public void testBug130390b_new() throws CoreException {
	setUpBug130390();
	search("NPE", TYPE, DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults(
		"src/b130390/Npe.java b130390.Npe [Npe] EXACT_MATCH\n" +
		"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug130390c() throws CoreException {
	setUpBug130390();
	search("NPE", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE);

		"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
	);
}
public void testBug130390c_new() throws CoreException {
	setUpBug130390();
	search("NPE", TYPE, DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH | SearchPattern.R_CASE_SENSITIVE);
	assertSearchResults(
		"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug130390d() throws CoreException {
	setUpBug130390();
	search("Npe", TYPE, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);

		"src/b130390/Npe.java b130390.Npe [Npe] EXACT_MATCH"
	);
}
public void testBug130390d_new() throws CoreException {
	setUpBug130390();
	search("Npe", TYPE, ALL_OCCURRENCES, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults(
		"src/b130390/Npe.java b130390.Npe [Npe] EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug130390e() throws CoreException {
	setUpBug130390();
	search("Npe", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE);

		"src/b130390/Npe.java b130390.Npe [Npe] EXACT_MATCH"
	);
}
public void testBug130390e_new() throws CoreException {
	setUpBug130390();
	search("Npe", TYPE, DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH | SearchPattern.R_CASE_SENSITIVE);
	assertSearchResults(
		"src/b130390/Npe.java b130390.Npe [Npe] EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug130390f() throws CoreException {
	setUpBug130390();
	search("NullPE", TYPE, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);

		"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
	);
}
public void testBug130390f_new() throws CoreException {
	setUpBug130390();
	search("NullPE", TYPE, ALL_OCCURRENCES, SearchPattern.R_CAMEL_CASE_MATCH);
	assertSearchResults(
		"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug130390g() throws CoreException {
	setUpBug130390();
	search("TZ", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE);

		"src/b130390/TimeZone.java b130390.TimeZone [TimeZone] EXACT_MATCH"
	);
}
public void testBug130390g_new() throws CoreException {
	setUpBug130390();
	search("TZ", TYPE, DECLARATIONS, SearchPattern.R_CAMEL_CASE_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() throws CoreException {
	setUpBug130390();
	search("TiZo", TYPE, DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH | SearchPattern.R_CASE_SENSITIVE);
	assertSearchResults(
		"" // no result as prefix match is not set
	);
}

/**
 * To get these tests search matches in a workspace, do NOT forget to modify files
 * to set them as working copies.
 *
 * @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() throws CoreException {
	// Search CamelCase
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "runtimeEx";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.RuntimeException EXACT_MATCH"
	);
	// Search like UI does (ie. replace it with prefix if it's not a valid CamelCase)
	int validatedRule = SearchPattern.validateMatchRule(pattern, matchRule);
	if (validatedRule != matchRule) {
		matchRule = SearchPattern.R_PREFIX_MATCH;
	}
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.RuntimeException EXACT_MATCH\n" +
		""+ getExternalJCLPathString("1.5") + " java.lang.RuntimeException EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug137087b() throws CoreException {
	// Search CamelCase
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "Runtimeex";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.RuntimeException EXACT_MATCH"
	);
	// Search like UI does (ie. replace it with prefix if it's not a valid CamelCase)
	int validatedRule = SearchPattern.validateMatchRule(pattern, matchRule);
	if (validatedRule != matchRule) {
		matchRule = SearchPattern.R_PREFIX_MATCH;
	}
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.RuntimeException EXACT_MATCH\n" +
		""+ getExternalJCLPathString("1.5") + " java.lang.RuntimeException EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug137087c() throws CoreException {
	// Search CamelCase
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "runtimeexception";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		"" // no result because it's an invalid camel case pattern which is replaced with 
			// prefix case sensitive match bu SearchPatter.validateMatchRule(...) (old behavior)
	// Search like UI does (ie. replace it with prefix if it's not a valid CamelCase)
	int validatedRule = SearchPattern.validateMatchRule(pattern, matchRule);
	if (validatedRule != matchRule) {
		matchRule = SearchPattern.R_PREFIX_MATCH;
	}
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.RuntimeException EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug137087d() throws CoreException {
	// Search CamelCase
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "Runtimexception";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		"" // no match expected as pattern is missing a 'e'
	);
	// Search like UI does (ie. replace it with prefix if it's not a valid CamelCase)
	int validatedRule = SearchPattern.validateMatchRule(pattern, matchRule);
	if (validatedRule != matchRule) {
		matchRule = SearchPattern.R_PREFIX_MATCH;
	}
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		"" // no match expected as pattern is missing a 'e'
	);
}
/** @deprecated As using a depreciated constant */
public void testBug137087e() throws CoreException {
	// Search CamelCase
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "IllegalMSException";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.IllegalMonitorStateException EXACT_MATCH"
	);
	// Search like UI does (ie. replace it with prefix if it's not a valid CamelCase)
	int validatedRule = SearchPattern.validateMatchRule(pattern, matchRule);
	if (validatedRule != matchRule) {
		matchRule = SearchPattern.R_PREFIX_MATCH;
	}
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.IllegalMonitorStateException EXACT_MATCH\n" +
		""+ getExternalJCLPathString("1.5") + " java.lang.IllegalMonitorStateException EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug137087f() throws CoreException {
	// Search CamelCase
	int matchRule = SearchPattern.R_CAMELCASE_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
	);
	// Search like UI does (ie. replace it with prefix if it's not a valid CamelCase)
	int validatedRule = SearchPattern.validateMatchRule(pattern, matchRule);
	if (validatedRule != matchRule) {
		matchRule = SearchPattern.R_PREFIX_MATCH;
	}
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		"" // expected no result as uppercase characters in pattern do not match any camelcase ones in existing types
	);
}
/** @deprecated As using a depreciated constant */
public void testBug137087g() throws CoreException {
	// Search CamelCase
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "clonenotsupportedex";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		"" // no result because it's an invalid camel case pattern which is replaced with 
			// prefix case sensitive match bu SearchPatter.validateMatchRule(...) (old behavior)
	// Search like UI does (ie. replace it with prefix if it's not a valid CamelCase)
	int validatedRule = SearchPattern.validateMatchRule(pattern, matchRule);
	if (validatedRule != matchRule) {
		matchRule = SearchPattern.R_PREFIX_MATCH;
	}
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug137087h() throws CoreException {
	// Search CamelCase
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "CloneNotSupportedEx";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
	// Search like UI does (ie. replace it with prefix if it's not a valid CamelCase)
	int validatedRule = SearchPattern.validateMatchRule(pattern, matchRule);
	if (validatedRule != matchRule) {
		matchRule = SearchPattern.R_PREFIX_MATCH;
	}
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH\n" +
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug137087i() throws CoreException {
	// Search CamelCase
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "cloneNotsupportedEx";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
	// Search like UI does (ie. replace it with prefix if it's not a valid CamelCase)
	int validatedRule = SearchPattern.validateMatchRule(pattern, matchRule);
	if (validatedRule != matchRule) {
		matchRule = SearchPattern.R_PREFIX_MATCH;
	}
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH\n" +
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug137087j() throws CoreException {
	// Search CamelCase
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "ClonenotSupportedexc";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
	// Search like UI does (ie. replace it with prefix if it's not a valid CamelCase)
	int validatedRule = SearchPattern.validateMatchRule(pattern, matchRule);
	if (validatedRule != matchRule) {
		matchRule = SearchPattern.R_PREFIX_MATCH;
	}
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH\n" +
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug137087k() throws CoreException {
	// Search CamelCase
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "cloneNotSupportedExcep";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
	// Search like UI does (ie. replace it with prefix if it's not a valid CamelCase)
	int validatedRule = SearchPattern.validateMatchRule(pattern, matchRule);
	if (validatedRule != matchRule) {
		matchRule = SearchPattern.R_PREFIX_MATCH;
	}
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH\n" +
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug137087l() throws CoreException {
	// Search CamelCase
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "Clonenotsupportedexception";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
	// Search like UI does (ie. replace it with prefix if it's not a valid CamelCase)
	int validatedRule = SearchPattern.validateMatchRule(pattern, matchRule);
	if (validatedRule != matchRule) {
		matchRule = SearchPattern.R_PREFIX_MATCH;
	}
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH\n" +
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
}
/** @deprecated As using a depreciated constant */
public void testBug137087m() throws CoreException {
	// Search CamelCase
	int matchRule = SearchPattern.R_CAMELCASE_MATCH;
	String pattern = "CloneNotSupportedException";
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
	// Search like UI does (ie. replace it with prefix if it's not a valid CamelCase)
	int validatedRule = SearchPattern.validateMatchRule(pattern, matchRule);
	if (validatedRule != matchRule) {
		matchRule = SearchPattern.R_PREFIX_MATCH;
	}
	search(pattern, TYPE, DECLARATIONS, matchRule);
	assertSearchResults(
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH\n" +
		""+ getExternalJCLPathString("1.5") + " java.lang.CloneNotSupportedException EXACT_MATCH"
	);
}

/**
 * Bug 137984: [search] Field references not found when type is a qualified member type [regression]
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=137984"




		}
	}
static {
	TESTS_PREFIX = "testSearchPatternValidateMatchRule";
}
public static Test suite() {
	return buildModelTestSuite(SearchTests.class);

}
protected void assertValidMatchRule(String pattern, int rule, int expected) {
	int validated = SearchPattern.validateMatchRule(pattern, rule);
	String givenRule = BasicSearchEngine.getMatchRuleString(rule);
	String validatedRule = BasicSearchEngine.getMatchRuleString(validated);
	String expectedRule = BasicSearchEngine.getMatchRuleString(expected);
	if (!validatedRule.equals(expectedRule)) {
		System.out.println("Test "+getName());
		System.out.print("	assertValidMatchRule(\"");
		System.out.print(pattern);
		System.out.println("\",");
		System.out.print("		SearchPattern.");
		System.out.print(givenRule);
		System.out.println("\",");
		System.out.print("		SearchPattern.");
		System.out.print(validatedRule);
		System.out.println(");");
		assertEquals(pattern+"' does not match expected match rule!", expectedRule, validatedRule);

		"TypeReferencePattern: qualification<X.*>, type<Y>, exact match, case sensitive, erasure only",
		searchPattern);
}

/**
 * Test pattern  validation
 */
public void testSearchPatternValidMatchRule01() {
	assertValidMatchRule("foo", 
		SearchPattern.R_EXACT_MATCH,
		SearchPattern.R_EXACT_MATCH);
	assertValidMatchRule("foo", SearchPattern.R_PATTERN_MATCH|SearchPattern.R_PREFIX_MATCH, SearchPattern.R_PREFIX_MATCH);
	assertValidMatchRule("foo", SearchPattern.R_CAMELCASE_MATCH, SearchPattern.R_PREFIX_MATCH|SearchPattern.R_CASE_SENSITIVE);
}
public void testSearchPatternValidMatchRule02() {
	assertValidMatchRule("foo",
		SearchPattern.R_PREFIX_MATCH,
		SearchPattern.R_PREFIX_MATCH);
	assertValidMatchRule("CP*P", SearchPattern.R_PATTERN_MATCH|SearchPattern.R_PREFIX_MATCH, SearchPattern.R_PATTERN_MATCH);
	assertValidMatchRule("CP*P", SearchPattern.R_CAMELCASE_MATCH, SearchPattern.R_PATTERN_MATCH);
}
public void testSearchPatternValidMatchRule03() {
	assertValidMatchRule("foo", 
		SearchPattern.R_PATTERN_MATCH,
		SearchPattern.R_EXACT_MATCH);
}
public void testSearchPatternValidMatchRule04() {
	assertValidMatchRule("foo",
		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 | SearchPattern.R_CASE_SENSITIVE);
}
public void testSearchPatternValidMatchRule06() {
	assertValidMatchRule("foo",
		SearchPattern.R_CAMEL_CASE_MATCH,
		SearchPattern.R_PREFIX_MATCH);
}
public void testSearchPatternValidMatchRule10() {
	assertValidMatchRule("CP*P",
		SearchPattern.R_EXACT_MATCH,
		SearchPattern.R_PATTERN_MATCH);
}
public void testSearchPatternValidMatchRule11() {
	assertValidMatchRule("CP*P",
		SearchPattern.R_PREFIX_MATCH,
		SearchPattern.R_PATTERN_MATCH);
}
public void testSearchPatternValidMatchRule12() {
	assertValidMatchRule("CP*P",
		SearchPattern.R_PATTERN_MATCH,
		SearchPattern.R_PATTERN_MATCH);
}
public void testSearchPatternValidMatchRule13() {
	assertValidMatchRule("CP*P",
		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,
		SearchPattern.R_PATTERN_MATCH);
}
public void testSearchPatternValidMatchRule15() {
	assertValidMatchRule("CP*P",
		SearchPattern.R_CAMEL_CASE_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);
	assertValidMatchRule("nPE", SearchPattern.R_CAMELCASE_MATCH);
	assertValidMatchRule("NuPoEx", SearchPattern.R_CAMELCASE_MATCH);
	assertValidMatchRule("oF", SearchPattern.R_CAMELCASE_MATCH);
}
/** @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_CAMEL_CASE_MATCH);
}
public void testSearchPatternValidMatchRule31() {
	assertValidMatchRule("NPE",
		SearchPattern.R_CAMEL_CASE_MATCH | SearchPattern.R_PREFIX_MATCH);
}
public void testSearchPatternValidMatchRule32() {
	assertValidMatchRule("NPE",
		SearchPattern.R_CAMEL_CASE_MATCH | SearchPattern.R_CASE_SENSITIVE);
}
public void testSearchPatternValidMatchRule33() {
	assertValidMatchRule("NPE",
		SearchPattern.R_CAMEL_CASE_MATCH | SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE);
}
public void testSearchPatternValidMatchRule34() {
	assertValidMatchRule("nPE",
		SearchPattern.R_CAMEL_CASE_MATCH);
}
public void testSearchPatternValidMatchRule35() {
	assertValidMatchRule("NuPoEx", 
		SearchPattern.R_CAMEL_CASE_MATCH);
}
public void testSearchPatternValidMatchRule36() {
	assertValidMatchRule("oF",
		SearchPattern.R_CAMEL_CASE_MATCH);
}
/** @deprecated As using a depreciated constant */
public void testSearchPatternValidMatchRule40() {
	assertValidMatchRule("Nu/Po/Ex",
		SearchPattern.R_CAMELCASE_MATCH,
		SearchPattern.R_PREFIX_MATCH | SearchPattern.R_CASE_SENSITIVE);
}
/** @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);
}
public void testSearchPatternValidMatchRule44() {
	assertValidMatchRule("Nu/Po/Ex",
		SearchPattern.R_CAMEL_CASE_MATCH,
		SearchPattern.R_PREFIX_MATCH);
}
public void testSearchPatternValidMatchRule45() {
	assertValidMatchRule("Nu.Po.Ex",
		SearchPattern.R_CAMEL_CASE_MATCH | SearchPattern.R_PREFIX_MATCH,
		SearchPattern.R_PREFIX_MATCH);
}
public void testSearchPatternValidMatchRule46() {
	assertValidMatchRule("hashMap",
		SearchPattern.R_CAMEL_CASE_MATCH);
}
public void testSearchPatternValidMatchRule47() {
	assertValidMatchRule("Hashmap",
		SearchPattern.R_CAMEL_CASE_MATCH);
}

/**




 * @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 {

			collector,
			IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
			null);
		// Should have same types with these 2 searches
		assertEquals("Invalid number of types found!", 1, collector.size());
		assertEquals("Found types sounds not to be correct", 
			"test.MyClass",
			collector.toString()

		deleteProject("Test.jar");
	}
}
public void testBug199392_Jar_new() throws CoreException {
	try {
		IJavaProject project = createJavaProject("Test.jar");
		createFolder("/Test.jar/test");
		createFile(
			"/Test.jar/test/MyClass.java",
			"package test;\n" + 
			"public class MyClass {\n" + 
			"}\n"
		);

		// Search all type names with TypeNameMatchRequestor
		AbstractJavaSearchTests.TypeNameMatchCollector collector = new AbstractJavaSearchTests.TypeNameMatchCollector() {
			public String toString(){
				return toFullyQualifiedNamesString();
			}
		};
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { project });
		new SearchEngine().searchAllTypeNames(
			null,
			SearchPattern.R_EXACT_MATCH,
			new char[] { 'M', 'y' },
			SearchPattern.R_CAMEL_CASE_MATCH,
			IJavaSearchConstants.TYPE,
			scope,
			collector,
			IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
			null);
		assertEquals("Found types sounds not to be correct", 
			"", // no result as prefix match is not set
			collector.toString()
		);
	} finally {
		deleteProject("Test.jar");
	}
}
/** @deprecated As using a depreciated constant */
public void testBug199392_Zip() throws CoreException {
	try {
		IJavaProject project = createJavaProject("Test.zip");

			collector,
			IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
			null);
		// Should have same types with these 2 searches
		assertEquals("Invalid number of types found!", 1, collector.size());
		assertEquals("Found types sounds not to be correct", 
			"test.MyClass",
			collector.toString()

		deleteProject("Test.zip");
	}
}
public void testBug199392_Zip_new() throws CoreException {
	try {
		IJavaProject project = createJavaProject("Test.zip");
		createFolder("/Test.zip/test");
		createFile(
			"/Test.zip/test/MyClass.java",
			"package test;\n" + 
			"public class MyClass {\n" + 
			"}\n"
		);

		// Search all type names with TypeNameMatchRequestor
		AbstractJavaSearchTests.TypeNameMatchCollector collector = new AbstractJavaSearchTests.TypeNameMatchCollector() {
			public String toString(){
				return toFullyQualifiedNamesString();
			}
		};
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { project });
		new SearchEngine().searchAllTypeNames(
			null,
			SearchPattern.R_EXACT_MATCH,
			new char[] { 'M', 'y' },
			SearchPattern.R_CAMEL_CASE_MATCH,
			IJavaSearchConstants.TYPE,
			scope,
			collector,
			IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
			null);
		assertEquals("Found types sounds not to be correct", 
			"", // no result as prefix match is not set
			collector.toString()
		);
	} finally {
		deleteProject("Test.zip");
	}
}
}




					}
				}
				System.out.println("--------------------------------------------------------------------------------");
				length *= 2;
				for (int i=0; i<length; i+=2) {
					System.out.println(sources[i]);
					System.out.println(sources[i+1]);

			requestor,
			null);
	}
	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);
	}
	protected void searchAllTypeNames(String pattern, int matchRule, TypeNameRequestor requestor) throws JavaModelException {
		new SearchEngine(this.workingCopies).searchAllTypeNames(
			null,

Lines 13-18 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/UtilTest.java (-1 / +131 lines)
13	import java.io.File;	13	import java.io.File;
14		14
15	//import org.apache.tools.ant.types.selectors.SelectorUtils;	15	//import org.apache.tools.ant.types.selectors.SelectorUtils;
		16	import org.eclipse.core.runtime.CoreException;
16	import org.eclipse.jdt.core.compiler.CharOperation;	17	import org.eclipse.jdt.core.compiler.CharOperation;
17		18
18	//import junit.framework.AssertionFailedError;	19	//import junit.framework.AssertionFailedError;
Lines 36-42 Link Here
36	* 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.
37	*/	38	*/
38	void assertCamelCase(String pattern, String name, boolean match) {	39	void assertCamelCase(String pattern, String name, boolean match) {
39	boolean camelCase = CharOperation.camelCaseMatch(pattern==null?null:pattern.toCharArray(), name==null?null:name.toCharArray());	40	assertCamelCase(pattern, name, true /prefix match/, match);
		41	}
		42	/**
		43	* Assert that a pattern and a name matches or not.
		44	* If result is invalid then store warning in buffer and display it.
		45	*/
		46	void assertCamelCase(String pattern, String name, boolean prefixMatch, boolean match) {
		47	boolean camelCase = CharOperation.camelCaseMatch(pattern==null?null:pattern.toCharArray(), name==null?null:name.toCharArray(), prefixMatch);
40	if (match != camelCase) {	48	if (match != camelCase) {
41	StringBuffer line = new StringBuffer("'");	49	StringBuffer line = new StringBuffer("'");
42	line.append(name);	50	line.append(name);
Lines 608-613 Link Here
608	// Verify that there were no unexpected results	616	// Verify that there were no unexpected results
609	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);	617	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
610	}	618	}
		619
		620	// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=109695
		621	public void test70() throws CoreException {
		622	assertCamelCase("IDE3", "IDocumentExtension", false /no prefix match/, false /* should not match */);
		623	assertCamelCase("IDE3", "IDocumentExtension2", false /no prefix match/, false /* should not match */);
		624	assertCamelCase("IDE3", "IDocumentExtension3", false /no prefix match/, true /* should match */);
		625	assertCamelCase("IDE3", "IDocumentExtension135", false /no prefix match/, true /* should match */);
		626	assertCamelCase("IDE3", "IDocumentExtension315", false /no prefix match/, true /* should match */);
		627	assertCamelCase("IDPE3", "IDocumentProviderExtension", false /no prefix match/, false /* should not match */);
		628	assertCamelCase("IDPE3", "IDocumentProviderExtension2", false /no prefix match/, false /* should not match */);
		629	assertCamelCase("IDPE3", "IDocumentProviderExtension4", false /no prefix match/, false /* should not match */);
		630	assertCamelCase("IDPE3", "IDocumentProviderExtension3", false /no prefix match/, true /* should match */);
		631	assertCamelCase("IDPE3", "IDocumentProviderExtension5", false /no prefix match/, false /* should not match */);
		632	assertCamelCase("IDPE3", "IDocumentProviderExtension54321", false /no prefix match/, true /* should match */);
		633	assertCamelCase("IDPE3", "IDocumentProviderExtension12345", false /no prefix match/, true /* should match */);
		634	assertCamelCase("IPL3", "IPerspectiveListener", false /no prefix match/, false /* should not match */);
		635	assertCamelCase("IPL3", "IPerspectiveListener2", false /no prefix match/, false /* should not match */);
		636	assertCamelCase("IPL3", "IPerspectiveListener3", false /no prefix match/, true /* should match */);
		637	assertCamelCase("IPS2", "IPropertySource", false /no prefix match/, false /* should not match */);
		638	assertCamelCase("IPS2", "IPropertySource2", false /no prefix match/, true /* should match */);
		639	assertCamelCase("IWWPD2", "IWorkbenchWindowPulldownDelegate", false /no prefix match/, false /* should not match */);
		640	assertCamelCase("IWWPD2", "IWorkbenchWindowPulldownDelegate2", false /no prefix match/, true /* should match */);
		641	assertCamelCase("UTF16DSS", "UTF16DocumentScannerSupport", false /no prefix match/, true /* should match */);
		642	assertCamelCase("UTF16DSS", "UTF1DocScannerSupport", false /no prefix match/, false /* should not match */);
		643	assertCamelCase("UTF16DSS", "UTF6DocScannerSupport", false /no prefix match/, false /* should not match */);
		644	assertCamelCase("UTF16DSS", "UTFDocScannerSupport", false /no prefix match/, false /* should not match */);
		645	assertCamelCase("UTF1DSS", "UTF16DocumentScannerSupport", false /no prefix match/, true /* should match */);
		646	assertCamelCase("UTF1DSS", "UTF1DocScannerSupport", false /no prefix match/, true /* should match */);
		647	assertCamelCase("UTF1DSS", "UTF6DocScannerSupport", false /no prefix match/, false /* should not match */);
		648	assertCamelCase("UTF1DSS", "UTFDocScannerSupport", false /no prefix match/, false /* should not match */);
		649	assertCamelCase("UTF6DSS", "UTF16DocumentScannerSupport", false /no prefix match/, true /* should match */);
		650	assertCamelCase("UTF6DSS", "UTF1DocScannerSupport", false /no prefix match/, false /* should not match */);
		651	assertCamelCase("UTF6DSS", "UTF6DocScannerSupport", false /no prefix match/, true /* should match */);
		652	assertCamelCase("UTF6DSS", "UTFDocScannerSupport", false /no prefix match/, false /* should not match */);
		653	assertCamelCase("UTFDSS", "UTF16DocumentScannerSupport", false /no prefix match/, true /* should match */);
		654	assertCamelCase("UTFDSS", "UTF1DocScannerSupport", false /no prefix match/, true /* should match */);
		655	assertCamelCase("UTFDSS", "UTF6DocScannerSupport", false /no prefix match/, true /* should match */);
		656	assertCamelCase("UTFDSS", "UTFDocScannerSupport", false /no prefix match/, true /* should match */);
		657	// Verify that there were no unexpected results
		658	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
		659	}
		660	// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=124624
		661	public void test71() {
		662	assertCamelCase("HM", "HashMap", false /no prefix match/, true /should match/);
		663	assertCamelCase("HM", "HtmlMapper", false /no prefix match/, true /should match/);
		664	assertCamelCase("HM", "HashMapEntry", false /no prefix match/, false /* should not match */);
		665	assertCamelCase("HaM", "HashMap", false /no prefix match/, true /* should match */);
		666	assertCamelCase("HaM", "HtmlMapper", false /no prefix match/, false /* should not match */);
		667	assertCamelCase("HaM", "HashMapEntry", false /no prefix match/, false /* should not match */);
		668	assertCamelCase("HashM", "HashMap", false /no prefix match/, true /* should match */);
		669	assertCamelCase("HashM", "HtmlMapper", false /no prefix match/, false /* should not match */);
		670	assertCamelCase("HashM", "HashMapEntry", false /no prefix match/, false /* should not match */);
		671	// Verify that there were no unexpected results
		672	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
		673	}
		674	public void test71b() { // previous test cases but with 3.3 behavior
		675	assertCamelCase("HM", "HashMap", true /should match/);
		676	assertCamelCase("HM", "HtmlMapper", true /should match/);
		677	assertCamelCase("HM", "HashMapEntry", true /should match/);
		678	assertCamelCase("HaM", "HashMap", true /* should match */);
		679	assertCamelCase("HaM", "HtmlMapper", false /should not match/);
		680	assertCamelCase("HaM", "HashMapEntry", true /should match/);
		681	assertCamelCase("HashM", "HashMap", true /* should match */);
		682	assertCamelCase("HashM", "HtmlMapper", false /should not match/);
683	assertCamelCase("HashM", "HashMapEntry", true /should match/);
684	// Verify that there were no unexpected results
685	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
686	}
687	// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=124624
688	public void test72() {
689	assertCamelCase("HMa", "HashMap", false /no prefix match/, false /* should not match */);
690	assertCamelCase("HMa", "HtmlMapper", false /no prefix match/, false /* should not match */);
691	assertCamelCase("HMa", "HashMapEntry", false /no prefix match/, false /* should not match */);
692	assertCamelCase("HaMa", "HashMap", false /no prefix match/, false /* should not match */);
693	assertCamelCase("HaMa", "HtmlMapper", false /no prefix match/, false /* should not match */);
694	assertCamelCase("HaMa", "HashMapEntry", false /no prefix match/, false /* should not match */);
695	assertCamelCase("HashMa", "HashMap", false /no prefix match/, false /* should not match */);
696	assertCamelCase("HashMa", "HtmlMapper", false /no prefix match/, false /* should not match */);
697	assertCamelCase("HashMa", "HashMapEntry", false /no prefix match/, false /* should not match */);
698	// Verify that there were no unexpected results
699	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
700	}
701	public void test72b() { // previous test cases but with 3.3 behavior
702	assertCamelCase("HMa", "HashMap", true /should match/);
703	assertCamelCase("HMa", "HtmlMapper", true /should match/);
704	assertCamelCase("HMa", "HashMapEntry", true /should match/);
705	assertCamelCase("HaMa", "HashMap", true /* should match */);
706	assertCamelCase("HaMa", "HtmlMapper", false /should not match/);
707	assertCamelCase("HaMa", "HashMapEntry", true /should match/);
708	assertCamelCase("HashMa", "HashMap", true /* should match */);
709	assertCamelCase("HashMa", "HtmlMapper", false /should not match/);
710	assertCamelCase("HashMa", "HashMapEntry", true /should match/);
711	// Verify that there were no unexpected results
712	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
713	}
714	// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=124624
715	public void test73() {
716	assertCamelCase("HMap", "HashMap", false /no prefix match/, true /should match/);
717	assertCamelCase("HMap", "HtmlMapper", false /no prefix match/, false /* should not match */);
718	assertCamelCase("HMap", "HashMapEntry", false /no prefix match/, false /* should not match */);
719	assertCamelCase("HaMap", "HashMap", false /no prefix match/, true /* should match */);
720	assertCamelCase("HaMap", "HtmlMapper", false /no prefix match/, false /* should not match */);
721	assertCamelCase("HaMap", "HashMapEntry", false /no prefix match/, false /* should not match */);
722	assertCamelCase("HashMap", "HashMap", false /no prefix match/, true /* should match */);
723	assertCamelCase("HashMap", "HtmlMapper", false /no prefix match/, false /* should not match */);
724	assertCamelCase("HashMap", "HashMapEntry", false /no prefix match/, false /* should not match */);
725	// Verify that there were no unexpected results
726	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
727	}
728	public void test73b() { // previous test cases but with 3.3 behavior
729	assertCamelCase("HMap", "HashMap", true /should match/);
730	assertCamelCase("HMap", "HtmlMapper", true /should match/);
731	assertCamelCase("HMap", "HashMapEntry", true /should match/);
732	assertCamelCase("HaMap", "HashMap", true /* should match */);
733	assertCamelCase("HaMap", "HtmlMapper", false /should not match/);
734	assertCamelCase("HaMap", "HashMapEntry", true /should match/);
735	assertCamelCase("HashMap", "HashMap", true /* should match */);
736	assertCamelCase("HashMap", "HtmlMapper", false /should not match/);
737	assertCamelCase("HashMap", "HashMapEntry", true /should match/);
738	// Verify that there were no unexpected results
739	assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
740	}
611	public static Class testClass() {	741	public static Class testClass() {
612	return UtilTest.class;	742	return UtilTest.class;
613	}	743	}

Lines 32-39 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/TypeReferencePattern.java (-2 / +2 lines)
32	public TypeReferencePattern(char[] qualification, char[] simpleName, int matchRule) {	32	public TypeReferencePattern(char[] qualification, char[] simpleName, int matchRule) {
33	this(matchRule);	33	this(matchRule);
34		34
35	this.qualification = isCaseSensitive() ? qualification : CharOperation.toLowerCase(qualification);	35	this.qualification = this.isCaseSensitive ? qualification : CharOperation.toLowerCase(qualification);
36	this.simpleName = (isCaseSensitive() \|\| isCamelCase()) ? simpleName : CharOperation.toLowerCase(simpleName);	36	this.simpleName = (this.isCaseSensitive \|\| this.isCamelCase) ? simpleName : CharOperation.toLowerCase(simpleName);
37		37
38	if (simpleName == null)	38	if (simpleName == null)
39	this.segments = this.qualification == null ? ONE_STAR_CHAR : CharOperation.splitOn('.', this.qualification);	39	this.segments = this.qualification == null ? ONE_STAR_CHAR : CharOperation.splitOn('.', this.qualification);

Lines 23-30 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/QualifiedTypeDeclarationPattern.java (-2 / +2 lines)
23	public QualifiedTypeDeclarationPattern(char[] qualification, char[] simpleName, char typeSuffix, int matchRule) {	23	public QualifiedTypeDeclarationPattern(char[] qualification, char[] simpleName, char typeSuffix, int matchRule) {
24	this(matchRule);	24	this(matchRule);
25		25
26	this.qualification = isCaseSensitive() ? qualification : CharOperation.toLowerCase(qualification);	26	this.qualification = this.isCaseSensitive ? qualification : CharOperation.toLowerCase(qualification);
27	this.simpleName = (isCaseSensitive() \|\| isCamelCase()) ? simpleName : CharOperation.toLowerCase(simpleName);	27	this.simpleName = (this.isCaseSensitive \|\| this.isCamelCase) ? simpleName : CharOperation.toLowerCase(simpleName);
28	this.typeSuffix = typeSuffix;	28	this.typeSuffix = typeSuffix;
29		29
30	((InternalSearchPattern)this).mustResolve = this.qualification != null \|\| typeSuffix != TYPE_SUFFIX;	30	((InternalSearchPattern)this).mustResolve = this.qualification != null \|\| typeSuffix != TYPE_SUFFIX;




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

	this.declaringQualification = this.isCaseSensitive ? declaringQualification : CharOperation.toLowerCase(declaringQualification);
	this.declaringSimpleName = (this.isCaseSensitive || this.isCamelCase) ? declaringSimpleName : CharOperation.toLowerCase(declaringSimpleName);
	if (parameterSimpleNames != null) {
		this.parameterCount = parameterSimpleNames.length;
		boolean synthetic = this.parameterCount>0 && declaringQualification != null && CharOperation.equals(CharOperation.concat(parameterQualifications[0], parameterSimpleNames[0], '.'), declaringQualification);

		this.parameterQualifications = new char[this.parameterCount][];
		this.parameterSimpleNames = new char[this.parameterCount][];
		for (int i = 0; i < this.parameterCount; i++) {
			this.parameterQualifications[i] = this.isCaseSensitive ? parameterQualifications[i+offset] : CharOperation.toLowerCase(parameterQualifications[i+offset]);
			this.parameterSimpleNames[i] = this.isCaseSensitive ? parameterSimpleNames[i+offset] : CharOperation.toLowerCase(parameterSimpleNames[i+offset]);
		}
	} else {
		this.parameterCount = -1;

Lines 30-36 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/PackageReferencePattern.java (-1 / +1 lines)
30	this.segments = new char[][] {CharOperation.NO_CHAR};	30	this.segments = new char[][] {CharOperation.NO_CHAR};
31	((InternalSearchPattern)this).mustResolve = false;	31	((InternalSearchPattern)this).mustResolve = false;
32	} else {	32	} else {
33	this.pkgName = (isCaseSensitive() \|\| isCamelCase()) ? pkgName : CharOperation.toLowerCase(pkgName);	33	this.pkgName = (this.isCaseSensitive \|\| this.isCamelCase) ? pkgName : CharOperation.toLowerCase(pkgName);
34	this.segments = CharOperation.splitOn('.', this.pkgName);	34	this.segments = CharOperation.splitOn('.', this.pkgName);
35	((InternalSearchPattern)this).mustResolve = true;	35	((InternalSearchPattern)this).mustResolve = true;
36	}	36	}

Lines 48-54 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/MultiTypeDeclarationPattern.java (-1 / +1 lines)
48	}	48	}
49	// null simple names are allowed (should return all names)	49	// null simple names are allowed (should return all names)
50	if (simpleNames != null) {	50	if (simpleNames != null) {
51	if ((isCaseSensitive() \|\| isCamelCase()) ) {	51	if (this.isCaseSensitive \|\| this.isCamelCase) {
52	this.simpleNames = simpleNames;	52	this.simpleNames = simpleNames;
53	} else {	53	} else {
54	int length = simpleNames.length;	54	int length = simpleNames.length;




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

	this.selector = (this.isCaseSensitive || this.isCamelCase) ? selector : CharOperation.toLowerCase(selector);
	this.declaringQualification = this.isCaseSensitive ? declaringQualification : CharOperation.toLowerCase(declaringQualification);
	this.declaringSimpleName = this.isCaseSensitive ? declaringSimpleName : CharOperation.toLowerCase(declaringSimpleName);
	this.returnQualification = this.isCaseSensitive ? returnQualification : CharOperation.toLowerCase(returnQualification);
	this.returnSimpleName = this.isCaseSensitive ? returnSimpleName : CharOperation.toLowerCase(returnSimpleName);
	if (parameterSimpleNames != null) {
		this.parameterCount = parameterSimpleNames.length;
		this.parameterQualifications = new char[this.parameterCount][];
		this.parameterSimpleNames = new char[this.parameterCount][];
		for (int i = 0; i < this.parameterCount; i++) {
			this.parameterQualifications[i] = this.isCaseSensitive ? parameterQualifications[i] : CharOperation.toLowerCase(parameterQualifications[i]);
			this.parameterSimpleNames[i] = this.isCaseSensitive ? parameterSimpleNames[i] : CharOperation.toLowerCase(parameterSimpleNames[i]);
		}
	} else {
		this.parameterCount = -1;




public VariablePattern(int patternKind, boolean findDeclarations, boolean readAccess, boolean writeAccess, char[] name, int matchRule) {
	super(patternKind, matchRule);

	this.findDeclarations = findDeclarations; // set to find declarations & all occurrences
	this.readAccess = readAccess; // set to find any reference, read only references & all occurrences
	this.writeAccess = writeAccess; // set to find any reference, write only references & all occurrences
	this.findReferences = readAccess || writeAccess;

	this.name = (this.isCaseSensitive || this.isCamelCase) ? name : CharOperation.toLowerCase(name);
}
/*
 * Returns whether a method declaration or message send will need to be resolved to 

Lines 112-119 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/TypeReferenceLocator.java (-2 / +5 lines)
112	return IMPOSSIBLE_MATCH;	112	return IMPOSSIBLE_MATCH;
113	}	113	}
114	boolean matchFirstChar = !this.isCaseSensitive \|\| (qualifiedPattern[0] == qualifiedTypeName[0]);	114	boolean matchFirstChar = !this.isCaseSensitive \|\| (qualifiedPattern[0] == qualifiedTypeName[0]);
115	if (this.isCamelCase && matchFirstChar && CharOperation.camelCaseMatch(qualifiedPattern, qualifiedTypeName)) {	115	if (this.isCamelCase) {
116	return POSSIBLE_MATCH;	116	if (matchFirstChar && CharOperation.camelCaseMatch(qualifiedPattern, qualifiedTypeName, (this.matchMode & SearchPattern.R_PREFIX_MATCH) != 0)) {
		117	return POSSIBLE_MATCH;
		118	}
		119	if (this.isCaseSensitive) return IMPOSSIBLE_MATCH;
117	}	120	}
118	switch (this.matchMode) {	121	switch (this.matchMode) {
119	case SearchPattern.R_EXACT_MATCH:	122	case SearchPattern.R_EXACT_MATCH:

Lines 150-157 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/SuperTypeReferencePattern.java (-2 / +2 lines)
150		150
151	this(matchRule);	151	this(matchRule);
152		152
153	this.superQualification = isCaseSensitive() ? superQualification : CharOperation.toLowerCase(superQualification);	153	this.superQualification = this.isCaseSensitive ? superQualification : CharOperation.toLowerCase(superQualification);
154	this.superSimpleName = (isCaseSensitive() \|\| isCamelCase()) ? superSimpleName : CharOperation.toLowerCase(superSimpleName);	154	this.superSimpleName = (this.isCaseSensitive \|\| this.isCamelCase) ? superSimpleName : CharOperation.toLowerCase(superSimpleName);
155	((InternalSearchPattern)this).mustResolve = superQualification != null;	155	((InternalSearchPattern)this).mustResolve = superQualification != null;
156	this.superRefKind = superRefKind;	156	this.superRefKind = superRefKind;
157	}	157	}




	 *		<li>{@link #R_PREFIX_MATCH}</li>
	 *		<li>{@link #R_PATTERN_MATCH}</li>
	 *		<li>{@link #R_REGEXP_MATCH}</li>
	 *		<li>{@link #R_CAMEL_CASE_MATCH}</li>
	 * </ul>
	 */
	int matchMode;

		// see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=81377
		int rule = getMatchRule();
		this.isCaseSensitive = (rule & R_CASE_SENSITIVE) != 0;
		this.isCamelCase = (rule & R_CAMEL_CASE_MATCH) != 0;
		this.matchCompatibility = rule & MATCH_COMPATIBILITY_MASK;
		this.matchMode = rule & MATCH_MODE_MASK;
	}

		return null;
	}

	final int getMatchMode() {
		return this.matchMode;
	}

	final boolean isCamelCase() {
		return this.isCamelCase;
	}

	final boolean isCaseSensitive () {
		return this.isCaseSensitive;
	}

	final boolean isErasureMatch() {
		return (this.matchCompatibility & R_ERASURE_MATCH) != 0;
	}

	final boolean isEquivalentMatch() {
		return (this.matchCompatibility & R_EQUIVALENT_MATCH) != 0;
	}


Lines 98-106 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/PackageReferenceLocator.java (-1 / +2 lines)
98	char[] packageName = null;	98	char[] packageName = null;
99	if (this.isCamelCase) {	99	if (this.isCamelCase) {
100	packageName = CharOperation.concatWith(tokens, '.');	100	packageName = CharOperation.concatWith(tokens, '.');
101	if (CharOperation.camelCaseMatch(this.pattern.pkgName, packageName)) {	101	if (CharOperation.camelCaseMatch(this.pattern.pkgName, packageName, (this.matchMode & SearchPattern.R_PREFIX_MATCH) != 0)) {
102	return POSSIBLE_MATCH;	102	return POSSIBLE_MATCH;
103	}	103	}
		104	if (this.isCaseSensitive) return IMPOSSIBLE_MATCH;
104	}	105	}
105	switch (this.matchMode) {	106	switch (this.matchMode) {
106	case SearchPattern.R_EXACT_MATCH:	107	case SearchPattern.R_EXACT_MATCH:

Lines 140-147 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/TypeDeclarationPattern.java (-3 / +3 lines)
140		140
141	this(matchRule);	141	this(matchRule);
142		142
143	this.pkg = isCaseSensitive() ? pkg : CharOperation.toLowerCase(pkg);	143	this.pkg = this.isCaseSensitive ? pkg : CharOperation.toLowerCase(pkg);
144	if (isCaseSensitive() \|\| enclosingTypeNames == null) {	144	if (this.isCaseSensitive \|\| enclosingTypeNames == null) {
145	this.enclosingTypeNames = enclosingTypeNames;	145	this.enclosingTypeNames = enclosingTypeNames;
146	} else {	146	} else {
147	int length = enclosingTypeNames.length;	147	int length = enclosingTypeNames.length;
Lines 149-155 Link Here
149	for (int i = 0; i < length; i++)	149	for (int i = 0; i < length; i++)
150	this.enclosingTypeNames[i] = CharOperation.toLowerCase(enclosingTypeNames[i]);	150	this.enclosingTypeNames[i] = CharOperation.toLowerCase(enclosingTypeNames[i]);
151	}	151	}
152	this.simpleName = (isCaseSensitive() \|\| isCamelCase()) ? simpleName : CharOperation.toLowerCase(simpleName);	152	this.simpleName = (this.isCaseSensitive \|\| this.isCamelCase) ? simpleName : CharOperation.toLowerCase(simpleName);
153	this.typeSuffix = typeSuffix;	153	this.typeSuffix = typeSuffix;
154		154
155	((InternalSearchPattern)this).mustResolve = (this.pkg != null && this.enclosingTypeNames != null) \|\| typeSuffix != TYPE_SUFFIX;	155	((InternalSearchPattern)this).mustResolve = (this.pkg != null && this.enclosingTypeNames != null) \|\| typeSuffix != TYPE_SUFFIX;




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;
					return POSSIBLE_MATCH | EXACT_FLAVOR;
				}
				break;
			}
			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) {
				pattern = CharOperation.toLowerCase(pattern);
			}

		}
	}
	if (this.isCamelCase) {
		if ((qualifiedPattern.length>0 && sourceName.length>0 && qualifiedPattern[0] == sourceName[0])) {
			if (CharOperation.camelCaseMatch(qualifiedPattern, sourceName, (this.matchMode & SearchPattern.R_PREFIX_MATCH) != 0)) {
				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;
		}
	}

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_CAMELCASE_MATCH);	34	\| (combined & R_CAMEL_CASE_MATCH);
35	}	35	}
36		36
37	public AndPattern(SearchPattern leftPattern, SearchPattern rightPattern) {	37	public AndPattern(SearchPattern leftPattern, SearchPattern rightPattern) {





	super(FIELD_PATTERN, findDeclarations, readAccess, writeAccess, name, matchRule);

	this.declaringQualification = this.isCaseSensitive ? declaringQualification : CharOperation.toLowerCase(declaringQualification);
	this.declaringSimpleName = this.isCaseSensitive ? declaringSimpleName : CharOperation.toLowerCase(declaringSimpleName);
	this.typeQualification = this.isCaseSensitive ? typeQualification : CharOperation.toLowerCase(typeQualification);
	this.typeSimpleName = (this.isCaseSensitive || this.isCamelCase) ? typeSimpleName : CharOperation.toLowerCase(typeSimpleName);

	((InternalSearchPattern)this).mustResolve = mustResolve();
}
/*
 * Instantiate a field pattern with additional information for generic search
 */
public FieldPattern(
	boolean findDeclarations,




<br>Project org.eclipse.jdt.core v_809
(<a href="http://dev.eclipse.org/viewcvs/index.cgi/org.eclipse.jdt.core/?only_with_tag=v_809">cvs</a>).
<h2>What's new in this drop</h2>
<ul>
<li>Prefix matching can be disabled while using Camel Case API methods. (see 
<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=124624">bug 124624</a>).<br>
Following API methods have been added on <code>org.eclipse.jdt.core.compiler.CharOperation</code>:
<pre>
/**
 * Answers true if the pattern matches the given name using CamelCase rules, or
 * false otherwise. char[] 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.
 *
 * 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'.
 *
 * Digit characters are treated in a special way. They can be used in the pattern
 * but are not always considered as leading character. For instance, both
 * 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
 *
 * CamelCase may or may not match prefixes depending on the given parameter.
 * When the prefix match parameter is <code>true</code>, the given pattern can
 * match only a prefix of the given name. For instance, 'HM' , 'HaMa' and  'HMap'
 * patterns will all match 'HashMap', 'HatMapper' <b>and</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'.
 *
 * Examples:
 *  1.	pattern = { 'N', 'P', 'E' }
 *  	name = { 'N', 'u','l', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 *  	result => true
 *  2.	pattern = { 'N', 'P', 'E' }
 *  	name = { 'N', 'o', 'P', 'e', 'r', 'm', 'i', 's', 's', 'i', 'o', 'n', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 *  	result => true
 *  3.	pattern = { 'N', 'u', 'P', 'o', 'E', 'x' }
 *  	name = { 'N', 'u','l', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 *  	result => true
 *  4.	pattern = { 'N', 'u', 'P', 'o', 'E', 'x' }
 *  	name = { 'N', 'o', 'P', 'e', 'r', 'm', 'i', 's', 's', 'i', 'o', 'n', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 *  	result => false
 *  5.	pattern = { 'n', p', 'e' }
 *  	name = { 'N', 'u','l', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 *  	result => false
 *  6.	pattern = { 'I', 'P', 'L', '3' }
 *  	name = { 'I', 'P', 'e', 'r', 's', 'p', 'e', 'c', 't', 'i', 'v', 'e', 'L', 'i', 's', 't', 'e', 'n', 'e', 'r', '3' }
 *  	result => true
 *  7.	pattern = { 'H', M' }
 *  	name = { 'H', 'a', 's', 'h', 'M', 'a', 'p', 'E', 'n', 't', 'r', 'y' }
 *  	result => (prefixMatch == true)
 *  8.	pattern = { 'H', M', 'a', 'p' }
 *  	name = { 'H', 'a', 't', 'M', 'a', 'p', 'p', 'e', 'r' }
 *  	result => (prefixMatch == true)
 * 
 * @param pattern the given pattern
 * @param name the given name
 * @param prefixMatch flag telling whether the pattern can match name prefix or not.
 * 		. For example, when it's <code>true</code>:
 * 			- 'HM' type string pattern will match  'HashMap' and 'HtmlMapper' types,
 * 			  but not 'HashMapEntry'
 * 			- 'HMap' type string pattern will match  'HashMap' type but not 'HtmlMapper'.
 * 		. and, when it's <code>false</code>:
 * 			- 'HM' type string pattern will match both   'HashMap' and 'HtmlMapper'
 * 			  and 'HashMapEntry'
 * 			- 'HMap' type string pattern will match both 'HashMap' and 'HtmlMapper'
 * 			  types.
 *
 * @return true if the pattern matches the given name, false otherwise
 * @since 3.4
 */
public static final boolean camelCaseMatch(char[] pattern, char[] name, boolean prefixMatch) {
...
}

/**
 * Answers true if a sub-pattern matches the sub-part 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 sub-pattern is defined by the patternStart and patternEnd
 * positions.
 *
 * 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.
 *
 * 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'.
 *
 * Digit characters are treated in a special way. They can be used in the pattern
 * but are not always considered as leading character. For instance, both
 * 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
 *
 * CamelCase may or may not match prefixes depending on the given parameter.
 * When the prefix match parameter is <code>true</code>, the given pattern can
 * match only a prefix of the given name. For instance, 'HM' , 'HaMa' and  'HMap'
 * patterns will all match 'HashMap', 'HatMapper' <b>and</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'.
 *
 * Examples:
 *  1.	pattern = { 'N', 'P', 'E' }
 *  	patternStart = 0
 *  	patternEnd = 3
 *  	name = { 'N', 'u','l', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 *  	nameStart = 0
 *  	nameEnd = 20
 *  	result => true
 *  2.	pattern = { 'N', 'P', 'E' }
 *  	patternStart = 0
 *  	patternEnd = 3
 *  	name = { 'N', 'o', 'P', 'e', 'r', 'm', 'i', 's', 's', 'i', 'o', 'n', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 *  	nameStart = 0
 *  	nameEnd = 21
 *  	result => true
 *  3.	pattern = { 'N', 'u', 'P', 'o', 'E', 'x' }
 *  	patternStart = 0
 *  	patternEnd = 6
 *  	name = { 'N', 'u','l', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 *  	nameStart = 0
 *  	nameEnd = 20
 *  	result => true
 *  4.	pattern = { 'N', 'u', 'P', 'o', 'E', 'x' }
 *  	patternStart = 0
 *  	patternEnd = 6
 *  	name = { 'N', 'o', 'P', 'e', 'r', 'm', 'i', 's', 's', 'i', 'o', 'n', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 *  	nameStart = 0
 *  	nameEnd = 21
 *  	result => false
 *  5.	pattern = { 'n', p', 'e' }
 *  	patternStart = 0
 *  	patternEnd = 3
 *  	name = { 'N', 'u','l', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 *  	nameStart = 20
 *  	nameEnd = 9
 *  	result => false
 *  6.	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
 *  7.	pattern = { 'H', M' }
 *  	patternStart = 0
 *  	patternEnd = 2
 *  	name = { 'H', 'a', 's', 'h', 'M', 'a', 'p', 'E', 'n', 't', 'r', 'y' }
 *  	nameStart = 0
 *  	nameEnd = 12
 *  	result => (prefixMatch == true)
 *  8.	pattern = { 'H', M', 'a', 'p' }
 *  	patternStart = 0
 *  	patternEnd = 4
 *  	name = { 'H', 'a', 't', 'M', 'a', 'p', 'p', 'e', 'r' }
 *  	nameStart = 0
 *  	nameEnd = 9
 *  	result => (prefixMatch == true)
 * 
 * @param pattern the given pattern
 * @param patternStart the start index of the pattern, inclusive
 * @param patternEnd the end index of the pattern, exclusive
 * @param name the given name
 * @param nameStart the start index of the name, inclusive
 * @param nameEnd the end index of the name, exclusive
 * @param prefixMatch flag telling whether the pattern can match name prefix or not.
 * 		. For example, when it's <code>true</code>:
 * 			- 'HM' type string pattern will match  'HashMap' and 'HtmlMapper' types,
 * 			  but not 'HashMapEntry'
 * 			- 'HMap' type string pattern will match  'HashMap' type but not 'HtmlMapper'.
 * 		. and, when it's <code>false</code>:
 * 			- 'HM' type string pattern will match both   'HashMap' and 'HtmlMapper'
 * 			  and 'HashMapEntry'
 * 			- 'HMap' type string pattern will match both 'HashMap' and 'HtmlMapper'
 * 			  types.
 *
 * @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 same methods have been added on <code>SearchPattern</code> but with
<code>String</code> parameters instead of <code>char[]</code> ones (javadoc comments
are identical):
<pre>
public static final boolean camelCaseMatch(String pattern, String name, boolean prefixMatch) {
...
}
public static final boolean camelCaseMatch(String pattern, int patternStart, int patternEnd, String name, int nameStart, int nameEnd, boolean prefixMatch) {
...
}
</pre>
Note also that methods <code>camelCaseMatch(String, int, int, String, int, int)</code>
of <code>CharOperation</code> and <code>SearchPattern</code> classes have been
depreciated to avoid too many 'camelCaseMatch*' methods on these classes.
</li>
<li>Search Engine has been modified to better handle additional <code>SearchPattern</code>
constants while using Camel Case one (see <a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=200400">bug 200400</a>).<br>
Existing <code>SearchPattern#R_CAMELCASE_MATCH</code> constant has been depreciated and<br>
is <b>now replaced by <code>SearchPattern#R_CAMEL_CASE_MATCH</code></b>:<pre>
	/**
	 * Match rule: The search pattern contains a Camel Case expression with
	 * a strict number of parts and preventing automatic prefix matching for the last
	 * part (if it consists of multiple letters).
	 * 
	 * Examples:
	 * 	. 'HM' type string pattern will match 'HashMap' and 'HtmlMapper' types,
	 * 		but not 'HashMapEntry'
	 * 	. 'HMap' type string pattern will match 'HashMap' type but not 'HtmlMapper'.
	 *
	 * This Camel Case match rule does not allow prefix match but accept insensitive
	 * case. For instance, 'HashMap' or 'HASHMAP' patterns using this Camel Case
	 * rule will match both 'HashMap' but not 'HashMapEntry'.
	 *
	 * 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).
	 *
	 * 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.
	 * 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.
	 *
	 * @see CharOperation#camelCaseMatch(char[], char[], boolean) for a detailed
	 * explanation of Camel Case matching.
	 *
	 * @since 3.4
	 */
	public static final int R_CAMEL_CASE_MATCH = 0x0100;
</pre>
This change was necessary has the obsolete <code>R_CAMELCASE_MATCH</code> could
not support correctly additional constants as <code>R_PREFIX_MATCH</code> or 
<code>R_CASE_SENSITIVE</code>.<br>
However, this depreciated constant is still accepted for backward compatibility
but user is advised to replace it with <code>R_CAMEL_CASE_MATCH | R_PREFIX_MATCH</code>
</li>
</ul>

<h3>Problem Reports Fixed</h3>
<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=200400">200400</a>
[search] Camel Case match prefix insensitive although spec says prefix sensitive
<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=124624">124624</a>
[search] Camelcase matching routines should support end character
<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=191739">191739</a>
"Duplicate nested type" bogus error on static class of abstract class or interface
<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=200931">200931</a>
GENERATED_BY references still exist in some javadoc comments




 * </pre></li>
 * </ol>
 * 
 * @param array the array that is concatenated with the suffix character
 * @param suffix the suffix character
 * @return the new array
 */

}

/**
 * Append the given sub-array to the target array starting at the given index in the target array.
 * The start of the sub-array is inclusive, the end is exclusive.
 * Answers a new target array if it needs to grow, otherwise answers the same target array.
 * <br>
 * For example:<br>

}

/**
 * Answers true if the pattern matches the given name using CamelCase rules, or
 * false otherwise. char[] CamelCase matching does NOT accept explicit wild-cards
 * '*' and '?' and is inherently case sensitive.
 * <p>
 * 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.
 * <p>
 * The pattern may contain lowercase characters, which will be matched 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'.
 * <p>
 * Digit characters are treated in a special way. They can be used in the pattern
 * but are not always considered as leading character. For instance, both
 * 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
 * <p>
 * This method allows prefix match in Camel Case (see
 * {@link #camelCaseMatch(char[], char[], boolean)}).
 * <p>
 * <pre>
 * Examples:<ol>
 * <li> pattern = { 'N', 'P', 'E' }
 * name = { 'N', 'u','l', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 * result => true</li>
 * <li> pattern = { 'N', 'P', 'E' }
 * name = { 'N', 'o', 'P', 'e', 'r', 'm', 'i', 's', 's', 'i', 'o', 'n', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 * result => true</li>
 * <li> pattern = { 'N', 'u', 'P', 'o', 'E', 'x' }
 * name = { 'N', 'u','l', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 * result => true</li>
 * <li> pattern = { 'N', 'u', 'P', 'o', 'E', 'x' }
 * name = { 'N', 'o', 'P', 'e', 'r', 'm', 'i', 's', 's', 'i', 'o', 'n', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 * result => false</li>
 * <li> pattern = { 'n', p', 'e' }
 * name = { 'N', 'u','l', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 * result => false</li>
 * <li> pattern = { 'I', 'P', 'L', '3' }
 * name = { 'I', 'P', 'e', 'r', 's', 'p', 'e', 'c', 't', 'i', 'v', 'e', 'L', 'i', 's', 't', 'e', 'n', 'e', 'r', '3' }
 * result => true</li>
 * <li> pattern = { 'H', M' }
 * name = { 'H', 'a', 's', 'h', 'M', 'a', 'p', 'E', 'n', 't', 'r', 'y' }
 * result => true</li>
 * <li>pattern = { 'H', M', 'a', 'p' }
 * name = { 'H', 'a', 't', 'M', 'a', 'p', 'p', 'e', 'r' }
 * result => true</li>
 * </ol></pre>
 * 
 * @param pattern the given pattern
 * @param name the given name

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

	return camelCaseMatch(pattern, 0, pattern.length, name, 0, name.length, true/*prefix match*/);
}

/**
 * Answers true if the pattern matches the given name using CamelCase rules, or
 * false otherwise. char[] CamelCase matching does NOT accept explicit wild-cards
 * '*' and '?' and is inherently case sensitive.
 * <p>
 * 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.
 * <p>
 * The pattern may contain lowercase characters, which will be matched 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'.
 * <p>
 * Digit characters are treated in a special way. They can be used in the pattern
 * but are not always considered as leading character. For instance, both
 * 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
 * <p>
 * CamelCase may or may not match prefixes depending on the given parameter.
 * When the prefix match parameter is <code>true</code>, the given pattern can
 * match only a prefix of the given name. For instance, 'HM' , 'HaMa' and  'HMap'
 * patterns will all match 'HashMap', 'HatMapper' <b>and</b> 'HashMapEntry'.
 * <br>
 * 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 = { 'N', 'P', 'E' }
 * name = { 'N', 'u','l', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 * result => true</li>
 * <li> pattern = { 'N', 'P', 'E' }
 * name = { 'N', 'o', 'P', 'e', 'r', 'm', 'i', 's', 's', 'i', 'o', 'n', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 * result => true</li>
 * <li> pattern = { 'N', 'u', 'P', 'o', 'E', 'x' }
 * name = { 'N', 'u','l', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 * result => true</li>
 * <li> pattern = { 'N', 'u', 'P', 'o', 'E', 'x' }
 * name = { 'N', 'o', 'P', 'e', 'r', 'm', 'i', 's', 's', 'i', 'o', 'n', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 * result => false</li>
 * <li> pattern = { 'n', p', 'e' }
 * name = { 'N', 'u','l', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 * result => false</li>
 * <li> pattern = { 'I', 'P', 'L', '3' }
 * name = { 'I', 'P', 'e', 'r', 's', 'p', 'e', 'c', 't', 'i', 'v', 'e', 'L', 'i', 's', 't', 'e', 'n', 'e', 'r', '3' }
 * result => true</li>
 * <li> pattern = { 'H', M' }
 * name = { 'H', 'a', 's', 'h', 'M', 'a', 'p', 'E', 'n', 't', 'r', 'y' }
 * result => (prefixMatch == true)</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 prefixMatch flag telling whether the pattern can match name prefix or not.
 * 	<ul>
 * 		<li>For example, when it's <code>true</code>:<br>
 * 			- 'HM' type string pattern will match  'HashMap' and 'HtmlMapper' types,
 * 			  but not 'HashMapEntry'<br>
 * 			- 'HMap' type string pattern will match  'HashMap' type but not 'HtmlMapper'.
 * 		</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 prefixMatch) {
	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, prefixMatch);
}

/**
 * Answers true if a sub-pattern matches the sub-part 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 sub-pattern is defined by the patternStart and patternEnd positions.
 * <p>
 * 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.
 * <p>
 * The pattern may contain lowercase characters, which will be matched 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'.
 * <p>
 * Digit characters are treated in a special way. They can be used in the pattern
 * but are not always considered as leading character. For instance, both
 * 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
 * <p>
 * Digit characters are treated in a special way. They can be used in the pattern
 * but are not always considered as leading character. For instance, both
 * 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
 * <p>
 * This method allows prefix match in Camel Case (see
 * {@link #camelCaseMatch(char[], int, int, char[], int, int, boolean)}).
 * <p>
 * Examples:
 * <ol>
 * <li><pre>

 *    result => false
 * </pre>
 * </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

 * @param name the given name
 * @param nameStart the start index of the name, inclusive
 * @param nameEnd the end index of the name, exclusive
 * @return true if a sub-pattern matches the sub-part of the given name, false otherwise
 * @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, true/*prefix match*/);
}

/**
 * Answers true if a sub-pattern matches the sub-part 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 sub-pattern is defined by the patternStart and patternEnd
 * positions.
 * <p>
 * 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.
 * <p>
 * The pattern may contain lowercase characters, which will be matched 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'.
 * <p>
 * Digit characters are treated in a special way. They can be used in the pattern
 * but are not always considered as leading character. For instance, both
 * 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
 * <p>
 * CamelCase may or may not match prefixes depending on the given parameter.
 * When the prefix match parameter is <code>true</code>, the given pattern can
 * match only a prefix of the given name. For instance, 'HM' , 'HaMa' and  'HMap'
 * patterns will all match 'HashMap', 'HatMapper' <b>and</b> 'HashMapEntry'.
 * <br>
 * 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 = { 'N', 'P', 'E' }
 * patternStart = 0
 * patternEnd = 3
 * name = { 'N', 'u','l', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 * nameStart = 0
 * nameEnd = 20
 * result => true</li>
 * <li> pattern = { 'N', 'P', 'E' }
 * patternStart = 0
 * patternEnd = 3
 * name = { 'N', 'o', 'P', 'e', 'r', 'm', 'i', 's', 's', 'i', 'o', 'n', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 * nameStart = 0
 * nameEnd = 21
 * result => true</li>
 * <li> pattern = { 'N', 'u', 'P', 'o', 'E', 'x' }
 * patternStart = 0
 * patternEnd = 6
 * name = { 'N', 'u','l', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 * nameStart = 0
 * nameEnd = 20
 * result => true</li>
 * <li> pattern = { 'N', 'u', 'P', 'o', 'E', 'x' }
 * patternStart = 0
 * patternEnd = 6
 * name = { 'N', 'o', 'P', 'e', 'r', 'm', 'i', 's', 's', 'i', 'o', 'n', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 * nameStart = 0
 * nameEnd = 21
 * result => false</li>
 * <li> pattern = { 'n', p', 'e' }
 * patternStart = 0
 * patternEnd = 3
 * name = { 'N', 'u','l', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
 * nameStart = 0
 * nameEnd = 20
 * result => false</li>
 * <li> 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</li>
 * <li> pattern = { 'H', M' }
 * patternStart = 0
 * patternEnd = 2
 * name = { 'H', 'a', 's', 'h', 'M', 'a', 'p', 'E', 'n', 't', 'r', 'y' }
 * nameStart = 0
 * nameEnd = 12
 * result => (exactMode == 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 pattern the given pattern
 * @param patternStart the start index of the pattern, inclusive
 * @param patternEnd the end index of the pattern, exclusive
 * @param name the given name
 * @param nameStart the start index of the name, inclusive
 * @param nameEnd the end index of the name, exclusive
 * @param prefixMatch flag telling whether the pattern can match name prefix or not.
 * 	<ul>
 * 		<li>For example, when it's <code>true</code>:<br>
 * 			- 'HM' type string pattern will match  'HashMap' and 'HtmlMapper' types,
 * 			  but not 'HashMapEntry'<br>
 * 			- 'HMap' type string pattern will match  'HashMap' type but not 'HtmlMapper'.
 * 		</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 prefixMatch) {
	if (name == null)
		return false; // null name cannot match
	if (pattern == null)

		iPattern++;
		iName++;

		if (iPattern == patternEnd) { // we have exhausted pattern...
			// it's a match if not exact mode or name is also exhausted
			if (prefixMatch || 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;
			}

			// it's a match only if name has no more uppercase characters (exact mode)
			while (true) {
				if (iName == nameEnd) {
					// we have exhausted name, so it's a match
					return true;
				}
				nameChar = name[iName];
				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;
					}
				}
				else if (!Character.isJavaIdentifierPart(nameChar) || Character.isUpperCase(nameChar)) {
					return false;
				}
				iName++;
			}
		}

		if (iName == nameEnd){

 * </ol>
 * 
 * @param prefix the prefix character
 * @param array the array that is concatenated with the prefix and suffix characters
 * @param suffix the suffix character
 * @return the new array
 */


/**
 * Answers a new array removing a given character. Answers the given array if there is
 * no occurrence of the character to remove.
 * <br>
 * <br>
 * For example:

}

/**
 * Replace all occurrence of the character to be replaced with the replacement character in the
 * given array.
 * <br>
 * <br>

}

/**
 * Replace all occurrences of characters to be replaced with the replacement character in the
 * given array.
 * <br>
 * <br>

}

/**
 * Replace all occurrences of characters to be replaced with the replacement character in the
 * given array from the start position (inclusive) to the end position (exclusive).
 * <br>
 * <br>

}

/**
 * Replace all occurrence of the character to be replaced with the replacement character 
 * in a copy of the given array. Returns the given array if no occurrences of the character
 * to be replaced are found.
 * <br>

}

/**
 * Return a new array which is the split of the given array using the given divider and trimming each subarray to remove
 * whitespaces equals to ' '.
 * <br>
 * <br>

 * 
 * @param divider the given divider
 * @param array the given array
 * @return a new array which is the split of the given array using the given divider and trimming each subarray to remove
 * whitespaces equals to ' '
 */
public static final char[][] splitAndTrimOn(char divider, char[] array) {




 * then created (see {@link #getBlankPattern()}). This blank pattern is used as a record as follows.
 * For each index entry in the given index categories and that starts with the given key, the blank pattern is fed using 
 * {@link #decodeIndexKey(char[])}. The original pattern is then asked if it matches the decoded key using
 * {@link #matchesDecodedKey(SearchPattern)}. If it matches, a search document is created for this index entry
 * using {@link SearchParticipant#getDocument(String)}.
 * 
 * </p><p>
 * This class is intended to be sub-classed by clients. A default behavior is provided for each of the methods above, that
 * clients can override if they wish.
 * </p>
 * @see #createPattern(org.eclipse.jdt.core.IJavaElement, int)
 * @see #createPattern(String, int, int, int)


	/**
	 * Match rule: The search pattern contains a Camel Case expression.
	 * <p>
	 * Examples:
	 * <ul>
	 * 	<li>'NPE' type string pattern will match
	 * 		'NullPointerException' and 'NoPermissionException' types,</li>
	 * 	<li>'NuPoEx' type string pattern will only match
	 * 		'NullPointerException' type.</li>
	 * </ul>
	 *
	 * This Camel Case match rule also accepts both prefix and case insensitive
	 * matches. For instance 'HashMap' or 'HASHMAP' pattern using Camel Case rule will match
	 * both 'HashMap' and 'HashMapEntry'.
	 *<p>
	 * <code>"nPE"</code> pattern will match <code>nPException</code>.
	 *<br>
	 * 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.
	 * 
	 * @since 3.2
	 * @deprecated Use <code>{@link #R_CAMEL_CASE_MATCH} | 
	 * 	{@link #R_PREFIX_MATCH}</code> instead.
	 */
	public static final int R_CAMELCASE_MATCH = 0x0080;

	/**
	 * Match rule: The search pattern contains a Camel Case expression with
	 * a strict number of parts and preventing automatic prefix matching for the last
	 * 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 match 'HashMap' type but not 'HtmlMapper'.
	 * 	</li>
	 * </ul>
	 *
	 * This Camel Case match rule does not allow prefix match but accept insensitive
	 * case. For instance, 'HashMap' or 'HASHMAP' patterns using this Camel Case
	 * rule will match both 'HashMap' but not 'HashMapEntry'.
	 * <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
	 */
	public static final int R_CAMEL_CASE_MATCH = 0x0100;

	private static final int MODE_MASK = R_EXACT_MATCH | R_PREFIX_MATCH | R_PATTERN_MATCH | R_REGEXP_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 {@link #R_EXACT_MATCH}, {@link #R_PREFIX_MATCH},
 * 	{@link #R_PATTERN_MATCH}, {@link #R_REGEXP_MATCH} combined with
 * 	one of following values: {@link #R_CASE_SENSITIVE}, {@link #R_ERASURE_MATCH},
 * 	{@link #R_EQUIVALENT_MATCH} or {@link #R_CAMEL_CASE_MATCH}.
 *		e.g. {@link #R_EXACT_MATCH} | {@link #R_CASE_SENSITIVE} if an exact
 *		and case sensitive match is requested, {@link #R_PREFIX_MATCH} if a prefix
 *		non case sensitive match is requested or {@link #R_EXACT_MATCH} | {@link #R_ERASURE_MATCH}
 *		if a non case sensitive and erasure match is requested.<br>
 * 	Note that {@link #R_ERASURE_MATCH} or {@link #R_EQUIVALENT_MATCH} have no effect
 * 	on non-generic types/methods search.<br>

	if ((matchRule & (R_EQUIVALENT_MATCH | R_ERASURE_MATCH )) == 0) {
		this.matchRule |= R_FULL_MATCH;
	}
	this.matchRule = updateMatchRule(this.matchRule);
}

/**
 * Answers true if the pattern matches the given name using CamelCase rules, or
 * false otherwise. char[] CamelCase matching does NOT accept explicit wild-cards
 * '*' and '?' and is inherently case sensitive.
 * <p>
 * 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.
 * <p>
 * The pattern may contain lowercase characters, which will be matched 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'.
 * <p>
 * Digit characters are treated in a special way. They can be used in the pattern
 * but are not always considered as leading character. For instance, both
 * 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
 * <p>
 * This method allows prefix match in Camel Case (see
 * {@link #camelCaseMatch(String, String, boolean)}).
 * <p>
 * <pre>
 * Examples:
 * <ol><li>  pattern = "NPE"
 *  name = NullPointerException / NoPermissionException
 *  result => true</li>
 * <li>  pattern = "NuPoEx"
 *  name = NullPointerException
 *  result => true</li>
 * <li>  pattern = "npe"
 *  name = NullPointerException
 *  result => false</li>
 * <li>  pattern = "IPL3"
 *  name = "IPerspectiveListener3"
 *  result => true</li>
 * <li>  pattern = "HM"
 *  name = "HashMapEntry"
 *  result => true</li>
 * <li>  pattern = "HMap"
 *  name = "HatMapper"
 *  result => true</li>
 * </ol></pre>
 * 
 * @see #camelCaseMatch(String, int, int, String, int, int, boolean) for algorithm
 * implementation
 * 
 * @param pattern the given pattern
 * @param name the given name

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

	return camelCaseMatch(pattern, 0, pattern.length(), name, 0, name.length(), true/*prefix match*/);
}

/**
 * Answers true if the pattern matches the given name using CamelCase rules, or
 * false otherwise. char[] CamelCase matching does NOT accept explicit wild-cards
 * '*' and '?' and is inherently case sensitive.
 * <p>
 * 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.
 * <p>
 * The pattern may contain lowercase characters, which will be matched 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'.
 * <p>
 * Digit characters are treated in a special way. They can be used in the pattern
 * but are not always considered as leading character. For instance, both
 * 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
 * <p>
 * CamelCase may or may not match prefixes depending on the given parameter.
 * When the prefix match parameter is <code>true</code>, the given pattern can
 * match only a prefix of the given name. For instance, 'HM' , 'HaMa' and  'HMap'
 * patterns will all match 'HashMap', 'HatMapper' <b>and</b> 'HashMapEntry'.
 * <br>
 * 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 = NullPointerException / NoPermissionException
 *  result => true</li>
 * <li>  pattern = "NuPoEx"
 *  name = NullPointerException
 *  result => true</li>
 * <li>  pattern = "npe"
 *  name = NullPointerException
 *  result => false</li>
 * <li>  pattern = "IPL3"
 *  name = "IPerspectiveListener3"
 *  result => true</li>
 * <li>  pattern = "HM"
 *  name = "HashMapEntry"
 *  result => (prefixMatch == true)</li>
 * <li>  pattern = "HMap"
 *  name = "HatMapper"
 *  result => (prefixMatch == true)</li>
 * </ol></pre>
 * 
 * @see #camelCaseMatch(String, int, int, String, int, int, boolean) for algorithm
 * 	implementation
 * 
 * @param pattern the given pattern
 * @param name the given name
 * @param prefixMatch flag telling whether the pattern can match name prefix or not.
 * 	<ul>
 * 		<li>For example, when it's <code>true</code>:<br>
 * 			- <code>HM</code> type string pattern will match
 * 			  <code>HashMap</code> and <code>HtmlMapper</code> types,
 * 			  but not <code>HashMapEntry</code><br>
 * 			- <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 prefixMatch) {
	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(), prefixMatch);
}

/**
 * Answers true if a sub-pattern matches the sub-part 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 sub-pattern is defined by the patternStart and patternEnd positions.
 * <p>
 * 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.
 * <p>
 * The pattern may contain lowercase characters, which will be matched 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'.
 * <p>
 * Digit characters are treated in a special way. They can be used in the pattern
 * but are not always considered as leading character. For instance, both
 * 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
 * <p>
 * Digit characters are treated in a special way. They can be used in the pattern
 * but are not always considered as leading character. For instance, both
 * 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
 * <p>
 * This method allows prefix match in Camel Case (see
 * {@link #camelCaseMatch(String, int, int, String, int, int, boolean)}).
 * <p>
 * <pre>Examples:<ol>
 * <li>  pattern = "NPE"
 *  patternStart = 0
 *  patternEnd = 3
 *  name = NullPointerException
 *  nameStart = 0
 *  nameEnd = 20
 *  result => true</li>
 * <li>  pattern = "NPE"
 *  patternStart = 0
 *  patternEnd = 3
 *  name = NoPermissionException
 *  nameStart = 0
 *  nameEnd = 21
 *  result => true</li>
 * <li>  pattern = "NuPoEx"
 *  patternStart = 0
 *  patternEnd = 6
 *  name = NullPointerException
 *  nameStart = 0
 *  nameEnd = 20
 *  result => true</li>
 * <li>  pattern = "NuPoEx"
 *  patternStart = 0
 *  patternEnd = 6
 *  name = NoPermissionException
 *  nameStart = 0
 *  nameEnd = 21
 *  result => false</li>
 * <li>  pattern = "npe"
 *  patternStart = 0
 *  patternEnd = 3
 *  name = NullPointerException
 *  nameStart = 0
 *  nameEnd = 20
 *  result => false</li>
 * <li>  pattern = "IPL3"
 *  patternStart = 0
 *  patternEnd = 3
 *  name = "IPerspectiveListener3"
 *  nameStart = 0
 *  nameEnd = 21
 *  result => true</li>
 * <li>  pattern = "HM"
 *  patternStart = 0
 *  patternEnd = 2
 *  name = "HashMapEntry"
 *  nameStart = 0
 *  nameEnd = 12
 *  result => true</li>
 * <li>  pattern = "HMap"
 *  patternStart = 0
 *  patternEnd = 4
 *  name = "HatMapper"
 *  nameStart = 0
 *  nameEnd = 9
 *  result => true</li>
 * </ol></pre>
 * 
 * @param pattern the given pattern
 * @param patternStart the start index of the pattern, inclusive

 * @param name the given name
 * @param nameStart the start index of the name, inclusive
 * @param nameEnd the end index of the name, exclusive
 * @return true if a sub-pattern matches the sub-part of the given name, false otherwise
 * @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, true/*prefix match*/);
}

/**
 * Answers true if a sub-pattern matches the sub-part 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 sub-pattern is defined by the patternStart and patternEnd
 * positions.
 * <p>
 * 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.
 * <p>
 * The pattern may contain lowercase characters, which will be matched 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'.
 * <p>
 * Digit characters are treated in a special way. They can be used in the pattern
 * but are not always considered as leading character. For instance, both
 * 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
 * <p>
 * CamelCase may or may not match prefixes depending on the given parameter.
 * When the prefix match parameter is <code>true</code>, the given pattern can
 * match only a prefix of the given name. For instance, 'HM' , 'HaMa' and  'HMap'
 * patterns will all match 'HashMap', 'HatMapper' <b>and</b> 'HashMapEntry'.
 * <br>
 * 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"
 *  patternStart = 0
 *  patternEnd = 3
 *  name = NullPointerException
 *  nameStart = 0
 *  nameEnd = 20
 *  result => true</li>
 * <li>  pattern = "NPE"
 *  patternStart = 0
 *  patternEnd = 3
 *  name = NoPermissionException
 *  nameStart = 0
 *  nameEnd = 21
 *  result => true</li>
 * <li>  pattern = "NuPoEx"
 *  patternStart = 0
 *  patternEnd = 6
 *  name = NullPointerException
 *  nameStart = 0
 *  nameEnd = 20
 *  result => true</li>
 * <li>  pattern = "NuPoEx"
 *  patternStart = 0
 *  patternEnd = 6
 *  name = NoPermissionException
 *  nameStart = 0
 *  nameEnd = 21
 *  result => false</li>
 * <li>  pattern = "npe"
 *  patternStart = 0
 *  patternEnd = 3
 *  name = NullPointerException
 *  nameStart = 0
 *  nameEnd = 20
 *  result => false</li>
 * <li>  pattern = "IPL3"
 *  patternStart = 0
 *  patternEnd = 3
 *  name = "IPerspectiveListener3"
 *  nameStart = 0
 *  nameEnd = 21
 *  result => true</li>
 * <li>  pattern = "HM"
 *  patternStart = 0
 *  patternEnd = 2
 *  name = "HashMapEntry"
 *  nameStart = 0
 *  nameEnd = 12
 *  result => (prefixMatch == true)</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)
 * 	from which algorithm implementation has been entirely copied.
 * 
 * @param pattern the given pattern
 * @param patternStart the start index of the pattern, inclusive
 * @param patternEnd the end index of the pattern, exclusive
 * @param name the given name
 * @param nameStart the start index of the name, inclusive
 * @param nameEnd the end index of the name, exclusive
 * @param prefixMatch flag telling whether the pattern can match name prefix or not.
 * 	<ul>
 * 		<li>For example, when it's <code>true</code>:<br>
 * 			- <code>HM</code> type string pattern will match
 * 			  <code>HashMap</code> and <code>HtmlMapper</code> types,
 * 			  but not <code>HashMapEntry</code><br>
 * 			- <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 prefixMatch) {

	/*
	 * 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)}.
	 * WARNING: Do not change one of these methods without changing the other
	 * the same way otherwise behavior differences may appear while using them...
	 */

	if (name == null)
		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...
			// it's a match if not exact mode or name is also exhausted
			if (prefixMatch || 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;
			}

			// it's a match only if name has no more uppercase characters (exact mode)
			while (true) {
				if (iName == nameEnd) {
					// we have exhausted name, so it's a match
					return true;
				}
				nameChar = name.charAt(iName);
				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;
					}
				}
				else if (!Character.isJavaIdentifierPart(nameChar) || Character.isUpperCase(nameChar)) {
					return false;
				}
				iName++;
			}
		}

		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 | ScannerHelper.C_DIGIT)) == 0) {
				return false;
			}
		}
		else if (Character.isJavaIdentifierPart(patternChar) && !Character.isUpperCase(patternChar) && !Character.isDigit(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) {
				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
					return false;
				} else {
					//.. and it matched patternChar. Back to the big loop
					break;
				}
			}
			// Same tests for non-obvious characters
			else if (Character.isJavaIdentifierPart(nameChar) && !Character.isUpperCase(nameChar)) {
				iName++;
			} else if (Character.isDigit(nameChar)) {
				if (patternChar == nameChar) break;
				iName++;
			} else  if (patternChar != nameChar) {
				return false;
			} else {
				break;
			}
		}
		// At this point, either name has been exhausted, or it is at an uppercase letter.
		// Since pattern is also at an uppercase letter
	}
}	

/**

 *		<li>{@link IJavaSearchConstants#ANNOTATION_TYPE}: only look for annotation type</li>
 * 	<li>{@link IJavaSearchConstants#CLASS_AND_ENUM}: only look for classes and enumerations</li>
 *		<li>{@link IJavaSearchConstants#CLASS_AND_INTERFACE}: only look for classes and interfaces</li>
 * 	<li>{@link IJavaSearchConstants#TYPE}: look for all types (i.e. classes, interfaces, enum and annotation types)</li>
 *		<li>{@link IJavaSearchConstants#FIELD}: look for fields</li>
 *		<li>{@link IJavaSearchConstants#METHOD}: look for methods</li>
 *		<li>{@link IJavaSearchConstants#CONSTRUCTOR}: look for constructors</li>

 *	<ul>
 * 	<li>{@link IJavaSearchConstants#DECLARATIONS}: will search declarations matching
 * 			with the corresponding element. In case the element is a method, declarations of matching
 * 			methods in sub-types will also be found, allowing to find declarations of abstract methods, etc.<br>
 * 			Note that additional flags {@link IJavaSearchConstants#IGNORE_DECLARING_TYPE} and
 * 			{@link IJavaSearchConstants#IGNORE_RETURN_TYPE} are ignored for string patterns.
 * 			This is due to the fact that client may omit to define them in string pattern to have same behavior.

 *				{@link IJavaSearchConstants#INTERFACE} is respectively used instead of {@link IJavaSearchConstants#TYPE}.
 *		</li>
 *	</ul>
 * @param matchRule one of {@link #R_EXACT_MATCH}, {@link #R_PREFIX_MATCH},
 * 	{@link #R_PATTERN_MATCH}, {@link #R_REGEXP_MATCH} combined with
 * 	one of following values: {@link #R_CASE_SENSITIVE}, {@link #R_ERASURE_MATCH},
 * 	{@link #R_EQUIVALENT_MATCH} or {@link #R_CAMEL_CASE_MATCH}.
 *		e.g. {@link #R_EXACT_MATCH} | {@link #R_CASE_SENSITIVE} if an exact
 *		and case sensitive match is requested, {@link #R_PREFIX_MATCH} if a prefix
 *		non case sensitive match is requested or {@link #R_EXACT_MATCH} | {@link #R_ERASURE_MATCH}
 *		if a non case sensitive and erasure match is requested.<br>
 * 	Note that {@link #R_ERASURE_MATCH} or {@link #R_EQUIVALENT_MATCH} have no effect
 * 	on non-generic types/methods search.<br>

 * The pattern is used to trigger the appropriate search.
 * <br>
 * Note that for generic searches, the returned pattern consider {@link #R_ERASURE_MATCH} matches.
 * If other kind of generic matches (i.e. {@link #R_EXACT_MATCH} or {@link #R_EQUIVALENT_MATCH})
 * are expected, {@link #createPattern(IJavaElement, int, int)} method need to be used instead with
 * the explicit match rule specified.
 * <br>

 *	<ul>
 * 	<li>{@link IJavaSearchConstants#DECLARATIONS}: will search declarations matching
 * 			with the corresponding element. In case the element is a method, declarations of matching
 * 			methods in sub-types will also be found, allowing to find declarations of abstract methods, etc.
 *				Some additional flags may be specified while searching declaration:
 *				<ul>
 *					<li>{@link IJavaSearchConstants#IGNORE_DECLARING_TYPE}: declaring type will be ignored

 *	<ul>
 * 	<li>{@link IJavaSearchConstants#DECLARATIONS}: will search declarations matching
 * 			with the corresponding element. In case the element is a method, declarations of matching
 * 			methods in sub-types will also be found, allowing to find declarations of abstract methods, etc.
 *				Some additional flags may be specified while searching declaration:
 *				<ul>
 *					<li>{@link IJavaSearchConstants#IGNORE_DECLARING_TYPE}: declaring type will be ignored

 *				which directly implement/extend a given interface.
 *		</li>
 *	</ul>
 * @param matchRule one of {@link #R_EXACT_MATCH}, {@link #R_PREFIX_MATCH},
 * 	{@link #R_PATTERN_MATCH}, {@link #R_REGEXP_MATCH} combined with
 * 	one of following values: {@link #R_CASE_SENSITIVE}, {@link #R_ERASURE_MATCH},
 * 	{@link #R_EQUIVALENT_MATCH} or {@link #R_CAMEL_CASE_MATCH}.
 *		e.g. {@link #R_EXACT_MATCH} | {@link #R_CASE_SENSITIVE} if an exact
 *		and case sensitive match is requested, {@link #R_PREFIX_MATCH} if a prefix
 *		non case sensitive match is requested or {@link #R_EXACT_MATCH} | {@link #R_ERASURE_MATCH}
 *		if a non case sensitive and erasure match is requested.<br>
 * 	Note that {@link #R_ERASURE_MATCH} or {@link #R_EQUIVALENT_MATCH} have no effect
 * 	on non-generic types/methods search.<br>
 * 	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
 */

 * 	and look as follow: '&lt;' { [ '?' {'extends'|'super'} ] type ( ',' [ '?' {'extends'|'super'} ] type )* | '?' } '&gt;'
 * 	Please note that:
 * 		- '*' is not valid inside type arguments definition &lt;&gt;
 * 		- '?' is treated as a wildcard when it is inside &lt;&gt; (i.e. it must be put on first position of the type argument)
 */
private static SearchPattern createTypePattern(String patternString, int limitTo, int matchRule, char indexSuffix) {
	

	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;
		boolean isPrefix = (this.matchRule & R_PREFIX_MATCH) != 0;
		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);
					if (sameLength && matchFirstChar) {
						return CharOperation.equals(pattern, name, isCaseSensitive);
					}
					break;
				}
				break;
			case R_PREFIX_MATCH :
				if (canBePrefix && matchFirstChar) {
					return CharOperation.prefixEquals(pattern, name, isCaseSensitive);

				break;

			case R_PATTERN_MATCH :
				// TODO_PERFS (frederic) not sure this lowercase was necessary...
				if (!isCaseSensitive)
					pattern = CharOperation.toLowerCase(pattern);
				return CharOperation.match(pattern, name, isCaseSensitive);

/**
 * Validate compatibility between given string pattern and match rule.
 *<br>
 * Returned match rule is modified, when following combinations are observed in the given parameters:
 * <ul>
 * 	<li>{@link #R_PATTERN_MATCH} without any '*' or '?' in string pattern:<br>
 * 		=> <b>pattern match flag is reset</b>,
 * 	</li>
 * 	<li>{@link #R_PATTERN_MATCH} and {@link #R_PREFIX_MATCH}  flags
 * 		simultaneously set:<br>
 * 		&nbsp;=> <b>prefix match flag is reset</b>,
 * 	</li>
 * 	<li>{@link #R_PATTERN_MATCH} and {@link #R_CAMEL_CASE_MATCH} 
 * 		(or <i>deprecated {@link #R_CAMELCASE_MATCH}</i>) flags simultaneously set:<br>
 * 		&nbsp;=> <b>camel case match flag is reset</b>,
 * 	</li>
 * 	<li>{@link #R_CAMEL_CASE_MATCH} (or <i>deprecated {@link #R_CAMELCASE_MATCH}</i>)
 * 		with invalid combination of uppercase and lowercase characters:<br>
 * 		&nbsp;=> <b>camel case match flag is reset and replaced with prefix match pattern</b>,<br>
 * 	</li>
 * 	<li>The <i>deprecated {@link #R_CAMELCASE_MATCH}</i> flag combined with
 * 		{@link #R_PREFIX_MATCH} and {@link #R_CASE_SENSITIVE} flags is
 * 		reduced to <i>deprecated {@link #R_CAMELCASE_MATCH}</i> flag only,
 * 	</li>
 * </ul>
 *<br>
 * Rejected (i.e. returned match rule -1) combinations are:
 * <ul>
 * 	<li>{@link #R_REGEXP_MATCH} with any other match mode flag set,
 * 	</li>
 * </ul>
 *


	// Verify Regexp match rule
	if ((matchRule & R_REGEXP_MATCH) != 0) {
		if ((matchRule & R_PATTERN_MATCH) != 0 || (matchRule & R_PREFIX_MATCH) != 0 || 
			(matchRule & R_CAMEL_CASE_MATCH) != 0 || (matchRule & R_CAMELCASE_MATCH) != 0) {
			return -1;
		}
	}

	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) {
		// remove Camel Case and Prefix match flags if any
		matchRule &= ~R_CAMELCASE_MATCH;
		matchRule &= ~R_CAMEL_CASE_MATCH;
		matchRule &= ~R_PREFIX_MATCH;
	}

	// Verify Camel Case match rule
	if ((matchRule & R_CAMEL_CASE_MATCH) != 0) {
		matchRule &= ~R_CAMELCASE_MATCH; // in case of some user specify both constants
		// Verify sting pattern validity
		int length = stringPattern.length();
		boolean validCamelCase = true;

			if (!uppercase) uppercase = ScannerHelper.isUpperCase(ch);
		}
		validCamelCase = validCamelCase && uppercase;
		// Verify flags compatibility
		if (!validCamelCase) {
			matchRule &= ~R_CAMEL_CASE_MATCH;
			matchRule |= R_PREFIX_MATCH;
		}
	}

	// Verify deprecated Camel Case match rule for backward compatibility
	else if ((matchRule & R_CAMELCASE_MATCH) != 0) {
		// Verify sting pattern validity
		int length = stringPattern.length();
		boolean validCamelCase = true;
		boolean uppercase = false;
		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) {
			if ((matchRule & R_PREFIX_MATCH) != 0) {
				if ((matchRule & R_CASE_SENSITIVE) != 0) {

}

/**
 * Update depreciated flags if necessary in the given match rule.
 * 
 * @param matchRule The match rule to update
 * @return The updated match rule with the updated flags
 */
static int updateMatchRule(int matchRule) {
	if ((matchRule & R_CAMELCASE_MATCH) != 0) {
		matchRule &= ~R_CAMELCASE_MATCH;
		matchRule |= R_CAMEL_CASE_MATCH;
		if ((matchRule & (R_PREFIX_MATCH | R_CASE_SENSITIVE)) == 0) {
			matchRule |= R_PREFIX_MATCH;
		}
	}
	return matchRule;
}

/**
 * @see java.lang.Object#toString()
 */
public String toString() {




	 *		<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_CAMEL_CASE_MATCH} if type name are camel case of the names of the searched types.</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, 

	 *		<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_CAMEL_CASE_MATCH} if type name are camel case of the names of the searched types.</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, 

	 *		<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_CAMEL_CASE_MATCH} if type name are camel case of the names of the searched types.</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, 

		IProgressMonitor progressMonitor)  throws JavaModelException {
		
		TypeNameRequestorWrapper requestorWrapper = new TypeNameRequestorWrapper(nameRequestor);
		this.basicEngine.searchAllTypeNames(packageName,
			packageMatchRule,
			typeName,
			SearchPattern.updateMatchRule(typeMatchRule), 
			searchFor,
			scope,
			requestorWrapper,
			waitingPolicy,
			progressMonitor);
	}

	/**

	 *		<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_CAMEL_CASE_MATCH} if type name are camel case of the names of the searched types.</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, 

	 *		<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_CAMEL_CASE_MATCH} if type name are camel case of the names of the searched types.</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, 

		IProgressMonitor progressMonitor)  throws JavaModelException {
		
		TypeNameMatchRequestorWrapper requestorWrapper = new TypeNameMatchRequestorWrapper(nameMatchRequestor, scope);
		this.basicEngine.searchAllTypeNames(packageName, 
			packageMatchRule, 
			typeName, 
			SearchPattern.updateMatchRule(typeMatchRule), 
			searchFor, 
			scope, 
			requestorWrapper, 
			waitingPolicy, 
			progressMonitor);
	}

	/**




	SearchPattern.R_PATTERN_MATCH |
	SearchPattern.R_REGEXP_MATCH |
	SearchPattern.R_CASE_SENSITIVE |
	SearchPattern.R_CAMEL_CASE_MATCH;

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

	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) {
		if (pattern[0] == word[0] && CharOperation.camelCaseMatch(pattern, word, (matchRule & SearchPattern.R_PREFIX_MATCH) != 0)) {
			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.equals(pattern, word, false);
			}
			// fall through prefix match if camel case failed
		case SearchPattern.R_PREFIX_MATCH :
			return patternLength <= wordLength && CharOperation.prefixEquals(pattern, word, false);
		case SearchPattern.R_PATTERN_MATCH :
			return CharOperation.match(pattern, word, false);
		case SearchPattern.R_EXACT_MATCH | SearchPattern.R_CASE_SENSITIVE :
			return pattern[0] == word[0] && patternLength == wordLength && CharOperation.equals(pattern, word);
				return pattern[0] == word[0] && patternLength == wordLength && CharOperation.equals(pattern, word);
			}
			// fall through prefix match if camel case failed
		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 :

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_CAMELCASE_MATCH;	383	if (camelCaseMatch) matchRule \|= SearchPattern.R_CAMEL_CASE_MATCH \| SearchPattern.R_PREFIX_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,

Lines 246-252 Link Here

(-)search/org/eclipse/jdt/internal/core/search/BasicSearchEngine.java (-10 / +13 lines)
246	return "R_EXACT_MATCH"; //$NON-NLS-1$	246	return "R_EXACT_MATCH"; //$NON-NLS-1$
247	}	247	}
248	StringBuffer buffer = new StringBuffer();	248	StringBuffer buffer = new StringBuffer();
249	for (int i=1; i<=8; i++) {	249	for (int i=1; i<=16; i++) {
250	int bit = matchRule & (1<<(i-1));	250	int bit = matchRule & (1<<(i-1));
251	if (bit != 0 && buffer.length()>0) buffer.append(" \| "); //$NON-NLS-1$	251	if (bit != 0 && buffer.length()>0) buffer.append(" \| "); //$NON-NLS-1$
252	switch (bit) {	252	switch (bit) {
Lines 271-279 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 SearchPattern.R_CAMELCASE_MATCH:	274	case 0x0080: // 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:
		278	buffer.append("R_CAMEL_CASE_MATCH"); //$NON-NLS-1$
		279	break;
277	}	280	}
278	}	281	}
279	return buffer.toString();	282	return buffer.toString();
Lines 454-474 Link Here
454	return false;	457	return false;
455		458
456	if (patternTypeName != null) {	459	if (patternTypeName != null) {
457	boolean isCamelCase = (matchRule & SearchPattern.R_CAMELCASE_MATCH) != 0;	460	boolean isCamelCase = (matchRule & SearchPattern.R_CAMEL_CASE_MATCH) != 0;
458	int matchMode = matchRule & JavaSearchPattern.MATCH_MODE_MASK;	461	int matchMode = matchRule & JavaSearchPattern.MATCH_MODE_MASK;
459	if (!isCaseSensitive && !isCamelCase) {	462	if (!isCaseSensitive && !isCamelCase) {
460	patternTypeName = CharOperation.toLowerCase(patternTypeName);	463	patternTypeName = CharOperation.toLowerCase(patternTypeName);
461	}	464	}
462	boolean matchFirstChar = !isCaseSensitive \|\| patternTypeName[0] == typeName[0];	465	boolean matchFirstChar = !isCaseSensitive \|\| patternTypeName[0] == typeName[0];
463	if (isCamelCase && matchFirstChar && CharOperation.camelCaseMatch(patternTypeName, typeName)) {	466	if (isCamelCase) {
464	return true;	467	if (matchFirstChar && CharOperation.camelCaseMatch(patternTypeName, typeName, (matchRule & SearchPattern.R_PREFIX_MATCH) != 0)) {
		468	return true;
		469	}
		470	if (isCaseSensitive) return false;
465	}	471	}
466	switch(matchMode) {	472	switch(matchMode) {
467	case SearchPattern.R_EXACT_MATCH :	473	case SearchPattern.R_EXACT_MATCH :
468	if (!isCamelCase) {	474	return matchFirstChar && CharOperation.equals(patternTypeName, typeName, isCaseSensitive);
469	return matchFirstChar && CharOperation.equals(patternTypeName, typeName, isCaseSensitive);
470	}
471	// fall through next case to match as prefix if camel case failed
472	case SearchPattern.R_PREFIX_MATCH :	475	case SearchPattern.R_PREFIX_MATCH :
473	return matchFirstChar && CharOperation.prefixEquals(patternTypeName, typeName, isCaseSensitive);	476	return matchFirstChar && CharOperation.prefixEquals(patternTypeName, typeName, isCaseSensitive);
474	case SearchPattern.R_PATTERN_MATCH :	477	case SearchPattern.R_PATTERN_MATCH :
Lines 842-848 Link Here
842	}	845	}
843	public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope classScope) {	846	public boolean visit(TypeDeclaration memberTypeDeclaration, ClassScope classScope) {
844	if (match(typeSuffix, packageName, typeName, typeMatchRule, TypeDeclaration.kind(memberTypeDeclaration.modifiers), packageDeclaration, memberTypeDeclaration.name)) {	847	if (match(typeSuffix, packageName, typeName, typeMatchRule, TypeDeclaration.kind(memberTypeDeclaration.modifiers), packageDeclaration, memberTypeDeclaration.name)) {
845	// compute encloising type names	848	// compute enclosing type names
846	TypeDeclaration enclosing = memberTypeDeclaration.enclosingType;	849	TypeDeclaration enclosing = memberTypeDeclaration.enclosingType;
847	char[][] enclosingTypeNames = CharOperation.NO_CHAR_CHAR;	850	char[][] enclosingTypeNames = CharOperation.NO_CHAR_CHAR;
848	while (enclosing != null) {	851	while (enclosing != null) {

Return to bug 124624

Lines 923-928 Link Here

(-)src/org/eclipse/jdt/core/tests/model/JavaSearchMultipleProjectsTests.java (-4 / +74 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
926	*/	927	*/
927	public void testBug199392_Jar() throws CoreException {	928	public void testBug199392_Jar() throws CoreException {
928	try {	929	try {
Lines 952-959 Link Here
952	collector,	953	collector,
953	IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,	954	IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
954	null);	955	null);
955	// Should have same types with these 2 searches
956	assertEquals("Invalid number of types found!", 1, collector.size());
957	assertEquals("Found types sounds not to be correct",	956	assertEquals("Found types sounds not to be correct",
958	"test.MyClass",	957	"test.MyClass",
959	collector.toString()	958	collector.toString()
Lines 962-967 Link Here
962	deleteProject("Test.jar");	961	deleteProject("Test.jar");
963	}	962	}
964	}	963	}
		964	public void testBug199392_Jar_new() throws CoreException {
		965	try {
		966	IJavaProject project = createJavaProject("Test.jar");
		967	createFolder("/Test.jar/test");
		968	createFile(
		969	"/Test.jar/test/MyClass.java",
		970	"package test;\n" +
		971	"public class MyClass {\n" +
		972	"}\n"
		973	);
		974
		975	// Search all type names with TypeNameMatchRequestor
		976	AbstractJavaSearchTests.TypeNameMatchCollector collector = new AbstractJavaSearchTests.TypeNameMatchCollector() {
		977	public String toString(){
		978	return toFullyQualifiedNamesString();
		979	}
		980	};
		981	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { project });
		982	new SearchEngine().searchAllTypeNames(
		983	null,
		984	SearchPattern.R_EXACT_MATCH,
		985	new char[] { 'M', 'y' },
		986	SearchPattern.R_CAMEL_CASE_MATCH,
		987	IJavaSearchConstants.TYPE,
		988	scope,
		989	collector,
		990	IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		991	null);
		992	assertEquals("Found types sounds not to be correct",
		993	"", // no result as prefix match is not set
		994	collector.toString()
		995	);
		996	} finally {
		997	deleteProject("Test.jar");
		998	}
		999	}
		1000	/** @deprecated As using a depreciated constant */
965	public void testBug199392_Zip() throws CoreException {	1001	public void testBug199392_Zip() throws CoreException {
966	try {	1002	try {
967	IJavaProject project = createJavaProject("Test.zip");	1003	IJavaProject project = createJavaProject("Test.zip");
Lines 990-997 Link Here
990	collector,	1026	collector,
991	IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,	1027	IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
992	null);	1028	null);
993	// Should have same types with these 2 searches
994	assertEquals("Invalid number of types found!", 1, collector.size());
995	assertEquals("Found types sounds not to be correct",	1029	assertEquals("Found types sounds not to be correct",
996	"test.MyClass",	1030	"test.MyClass",
997	collector.toString()	1031	collector.toString()
Lines 1000-1003 Link Here
1000	deleteProject("Test.zip");	1034	deleteProject("Test.zip");
1001	}	1035	}
1002	}	1036	}
		1037	public void testBug199392_Zip_new() throws CoreException {
		1038	try {
		1039	IJavaProject project = createJavaProject("Test.zip");
		1040	createFolder("/Test.zip/test");
		1041	createFile(
		1042	"/Test.zip/test/MyClass.java",
		1043	"package test;\n" +
		1044	"public class MyClass {\n" +
		1045	"}\n"
		1046	);
		1047
		1048	// Search all type names with TypeNameMatchRequestor
		1049	AbstractJavaSearchTests.TypeNameMatchCollector collector = new AbstractJavaSearchTests.TypeNameMatchCollector() {
		1050	public String toString(){
		1051	return toFullyQualifiedNamesString();
		1052	}
		1053	};
		1054	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] { project });
		1055	new SearchEngine().searchAllTypeNames(
		1056	null,
		1057	SearchPattern.R_EXACT_MATCH,
		1058	new char[] { 'M', 'y' },
		1059	SearchPattern.R_CAMEL_CASE_MATCH,
		1060	IJavaSearchConstants.TYPE,
		1061	scope,
		1062	collector,
		1063	IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		1064	null);
		1065	assertEquals("Found types sounds not to be correct",
		1066	"", // no result as prefix match is not set
		1067	collector.toString()
		1068	);
		1069	} finally {
		1070	deleteProject("Test.zip");
		1071	}
		1072	}
1003	}	1073	}

Lines 3715-3758 Link Here

(-)src/org/eclipse/jdt/core/tests/model/JavaSearchTests.java (-13 / +168 lines)
3715	*	3715	*
3716	* These tests are not really duplicates of {@link JavaSearchBugsTests} ones	3716	* These tests are not really duplicates of {@link JavaSearchBugsTests} ones
3717	* as they also test camel case in indexes...	3717	* as they also test camel case in indexes...
		3718	* @deprecated As using a depreciated constant
3718	*/	3719	*/
3719	public void testCamelCaseTypePattern01() throws CoreException {	3720	public void testCamelCaseTypePattern01() throws CoreException {
3720	search("RE", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH, getJavaSearchScope());	3721	search("RE", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
3721	assertSearchResults(	3722	assertSearchResults(
3722	"src/a3/References.java a3.References [References]\n" +	3723	"src/a3/References.java a3.References [References]\n" +
3723	""+ getExternalJCLPathString() + " java.lang.RuntimeException"	3724	""+ getExternalJCLPathString() + " java.lang.RuntimeException"
3724	);	3725	);
3725	}	3726	}
3726		3727	public void testCamelCaseTypePattern01b() throws CoreException {
		3728	search("RE", TYPE, DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH);
		3729	assertSearchResults(
		3730	""+ getExternalJCLPathString() + " java.lang.RuntimeException"
		3731	);
		3732	}
		3733	/** @deprecated As using a depreciated constant */
3727	public void testCamelCaseTypePattern02() throws CoreException {	3734	public void testCamelCaseTypePattern02() throws CoreException {
3728	search("RException", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH, getJavaSearchScope());	3735	search("RException", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
3729	assertSearchResults(	3736	assertSearchResults(
3730	""+ getExternalJCLPathString() + " java.lang.RuntimeException"	3737	""+ getExternalJCLPathString() + " java.lang.RuntimeException"
3731	);	3738	);
3732	}	3739	}
3733		3740	/** @deprecated As using a depreciated constant */
3734	public void testCamelCaseTypePattern03() throws CoreException {	3741	public void testCamelCaseTypePattern03() throws CoreException {
3735	search("RuntimeException", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH, getJavaSearchScope());	3742	search("RuntimeException", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
3736	assertSearchResults(	3743	assertSearchResults(
3737	""+ getExternalJCLPathString() + " java.lang.RuntimeException"	3744	""+ getExternalJCLPathString() + " java.lang.RuntimeException"
3738	);	3745	);
3739	}	3746	}
3740		3747	/** @deprecated As using a depreciated constant */
3741	public void testCamelCaseTypePattern04() throws CoreException {	3748	public void testCamelCaseTypePattern04() throws CoreException {
3742	search("RUNTIMEEXCEPTION", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH, getJavaSearchScope());	3749	search("RUNTIMEEXCEPTION", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
3743	assertSearchResults(	3750	assertSearchResults(
3744	""+ getExternalJCLPathString() + " java.lang.RuntimeException"	3751	""+ getExternalJCLPathString() + " java.lang.RuntimeException"
3745	);	3752	);
3746	}	3753	}
3747		3754	/**
		3755	* @deprecated As using a depreciated constant
		3756	*/
3748	public void testCamelCaseTypePattern05() throws CoreException {	3757	public void testCamelCaseTypePattern05() throws CoreException {
3749	search("RE", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH, getJavaSearchScope());	3758	search("RE", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
3750	assertSearchResults(	3759	assertSearchResults(
3751	"src/a3/References.java a3.References [References]\n" +	3760	"src/a3/References.java a3.References [References]\n" +
3752	""+ getExternalJCLPathString() + " java.lang.RuntimeException"	3761	""+ getExternalJCLPathString() + " java.lang.RuntimeException"
3753	);	3762	);
3754	}	3763	}
3755		3764	/** @deprecated As using a depreciated constant */
3756	public void testCamelCaseTypePattern06() throws CoreException {	3765	public void testCamelCaseTypePattern06() throws CoreException {
3757	TypeNameRequestor requestor = new SearchTests.SearchTypeNameRequestor();	3766	TypeNameRequestor requestor = new SearchTests.SearchTypeNameRequestor();
3758	new SearchEngine().searchAllTypeNames(	3767	new SearchEngine().searchAllTypeNames(
Lines 3771-3777 Link Here
3771	"java.lang.CloneNotSupportedException",	3780	"java.lang.CloneNotSupportedException",
3772	requestor);	3781	requestor);
3773	}	3782	}
3774		3783	/** @deprecated As using a depreciated constant */
3775	public void testCamelCaseTypePattern07() throws CoreException {	3784	public void testCamelCaseTypePattern07() throws CoreException {
3776	TypeNameRequestor requestor = new SearchTests.SearchTypeNameRequestor();	3785	TypeNameRequestor requestor = new SearchTests.SearchTypeNameRequestor();
3777	new SearchEngine().searchAllTypeNames(	3786	new SearchEngine().searchAllTypeNames(
Lines 3794-3800 Link Here
3794	"q1.AA",	3803	"q1.AA",
3795	requestor);	3804	requestor);
3796	}	3805	}
3797		3806	/** @deprecated As using a depreciated constant */
3798	public void testCamelCaseTypePattern08() throws CoreException {	3807	public void testCamelCaseTypePattern08() throws CoreException {
3799	TypeNameRequestor requestor = new SearchTests.SearchTypeNameRequestor();	3808	TypeNameRequestor requestor = new SearchTests.SearchTypeNameRequestor();
3800	new SearchEngine().searchAllTypeNames(	3809	new SearchEngine().searchAllTypeNames(
Lines 3816-3822 Link Here
3816	"q1.AA",	3825	"q1.AA",
3817	requestor);	3826	requestor);
3818	}	3827	}
3819		3828	/** @deprecated As using a depreciated constant */
3820	public void testCamelCaseTypePattern09() throws CoreException {	3829	public void testCamelCaseTypePattern09() throws CoreException {
3821	TypeNameRequestor requestor = new SearchTests.SearchTypeNameRequestor();	3830	TypeNameRequestor requestor = new SearchTests.SearchTypeNameRequestor();
3822	new SearchEngine().searchAllTypeNames(	3831	new SearchEngine().searchAllTypeNames(
Lines 3838-3843 Link Here
3838	"q1.AA",	3847	"q1.AA",
3839	requestor);	3848	requestor);
3840	}	3849	}
		3850	/** @deprecated As using a depreciated constant */
		3851	public void testCamelCaseTypePattern10() throws CoreException {
		3852	workingCopies = new ICompilationUnit[1];
		3853	workingCopies[0] = getWorkingCopy("/JavaSearch/src/Test.java",
		3854	"class Null {}\n" +
		3855	"class NULL {}\n" +
		3856	"class NullPointerException {}\n" +
		3857	"class NULLPointerException {}\n" +
		3858	"class NULLPOINTERException {}\n" +
		3859	"class NULLPOINTEREXCEPTION {}\n"
		3860	);
		3861	search("Null", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
		3862	assertSearchResults(
		3863	"src/Test.java Null [Null]\n" +
		3864	"src/Test.java NULL [NULL]\n" +
		3865	"src/Test.java NullPointerException [NullPointerException]\n" +
		3866	"src/Test.java NULLPointerException [NULLPointerException]\n" +
		3867	"src/Test.java NULLPOINTERException [NULLPOINTERException]\n" +
		3868	"src/Test.java NULLPOINTEREXCEPTION [NULLPOINTEREXCEPTION]"
		3869	);
		3870	}
		3871	/** @deprecated As using a depreciated constant */
		3872	public void testCamelCaseTypePattern11() throws CoreException {
		3873	workingCopies = new ICompilationUnit[1];
		3874	workingCopies[0] = getWorkingCopy("/JavaSearch/src/Test.java",
		3875	"class Null {}\n" +
		3876	"class NULL {}\n" +
		3877	"class NullPointerException {}\n" +
		3878	"class NULLPointerException {}\n" +
		3879	"class NULLPOINTERException {}\n" +
		3880	"class NULLPOINTEREXCEPTION {}\n"
		3881	);
		3882	search("Null", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH \| SearchPattern.R_PREFIX_MATCH);
		3883	assertSearchResults(
		3884	"src/Test.java Null [Null]\n" +
		3885	"src/Test.java NULL [NULL]\n" +
		3886	"src/Test.java NullPointerException [NullPointerException]\n" +
		3887	"src/Test.java NULLPointerException [NULLPointerException]\n" +
		3888	"src/Test.java NULLPOINTERException [NULLPOINTERException]\n" +
		3889	"src/Test.java NULLPOINTEREXCEPTION [NULLPOINTEREXCEPTION]"
		3890	);
		3891	}
		3892	/** @deprecated As using a depreciated constant */
		3893	public void testCamelCaseTypePattern12() throws CoreException {
		3894	workingCopies = new ICompilationUnit[1];
		3895	workingCopies[0] = getWorkingCopy("/JavaSearch/src/Test.java",
		3896	"class Null {}\n" +
		3897	"class NULL {}\n" +
		3898	"class NullPointerException {}\n" +
		3899	"class NULLPointerException {}\n" +
		3900	"class NULLPOINTERException {}\n" +
		3901	"class NULLPOINTEREXCEPTION {}\n"
		3902	);
		3903	search("Null", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH \| SearchPattern.R_CASE_SENSITIVE);
		3904	assertSearchResults(
		3905	"src/Test.java Null [Null]"
		3906	);
		3907	}
		3908	/** @deprecated As using a depreciated constant */
		3909	public void testCamelCaseTypePattern13() throws CoreException {
		3910	workingCopies = new ICompilationUnit[1];
		3911	workingCopies[0] = getWorkingCopy("/JavaSearch/src/Test.java",
		3912	"class Null {}\n" +
		3913	"class NULL {}\n" +
3914	"class NullPointerException {}\n" +
3915	"class NULLPointerException {}\n" +
3916	"class NULLPOINTERException {}\n" +
3917	"class NULLPOINTEREXCEPTION {}\n"
3918	);
3919	search("Null", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH \| SearchPattern.R_PREFIX_MATCH \| SearchPattern.R_CASE_SENSITIVE);
3920	assertSearchResults(
3921	"src/Test.java Null [Null]\n" +
3922	"src/Test.java NULL [NULL]\n" +
3923	"src/Test.java NullPointerException [NullPointerException]\n" +
3924	"src/Test.java NULLPointerException [NULLPointerException]\n" +
3925	"src/Test.java NULLPOINTERException [NULLPOINTERException]\n" +
3926	"src/Test.java NULLPOINTEREXCEPTION [NULLPOINTEREXCEPTION]"
3927	);
3928	}
3929	public void testCamelCaseTypePattern14() throws CoreException {
3930	workingCopies = new ICompilationUnit[1];
3931	workingCopies[0] = getWorkingCopy("/JavaSearch/src/Test.java",
3932	"class Null {}\n" +
3933	"class NULL {}\n" +
3934	"class NullPointerException {}\n" +
3935	"class NULLPointerException {}\n" +
3936	"class NULLPOINTERException {}\n" +
3937	"class NULLPOINTEREXCEPTION {}\n"
3938	);
3939	search("Null", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH);
3940	assertSearchResults(
3941	"src/Test.java Null [Null]\n" +
3942	"src/Test.java NULL [NULL]"
3943	);
3944	}
3945	public void testCamelCaseTypePattern15() throws CoreException {
3946	workingCopies = new ICompilationUnit[1];
3947	workingCopies[0] = getWorkingCopy("/JavaSearch/src/Test.java",
3948	"class Null {}\n" +
3949	"class NULL {}\n" +
3950	"class NullPointerException {}\n" +
3951	"class NULLPointerException {}\n" +
3952	"class NULLPOINTERException {}\n" +
3953	"class NULLPOINTEREXCEPTION {}\n"
3954	);
3955	search("Null", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH \| SearchPattern.R_PREFIX_MATCH);
3956	assertSearchResults(
3957	"src/Test.java Null [Null]\n" +
3958	"src/Test.java NULL [NULL]\n" +
3959	"src/Test.java NullPointerException [NullPointerException]\n" +
3960	"src/Test.java NULLPointerException [NULLPointerException]\n" +
3961	"src/Test.java NULLPOINTERException [NULLPOINTERException]\n" +
3962	"src/Test.java NULLPOINTEREXCEPTION [NULLPOINTEREXCEPTION]"
3963	);
3964	}
3965	public void testCamelCaseTypePattern16() throws CoreException {
3966	workingCopies = new ICompilationUnit[1];
3967	workingCopies[0] = getWorkingCopy("/JavaSearch/src/Test.java",
3968	"class Null {}\n" +
3969	"class NULL {}\n" +
3970	"class NullPointerException {}\n" +
3971	"class NULLPointerException {}\n" +
3972	"class NULLPOINTERException {}\n" +
3973	"class NULLPOINTEREXCEPTION {}\n"
3974	);
3975	search("Null", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH \| SearchPattern.R_CASE_SENSITIVE);
3976	assertSearchResults(
3977	"src/Test.java Null [Null]"
3978	);
3979	}
3980	public void testCamelCaseTypePattern17() throws CoreException {
3981	workingCopies = new ICompilationUnit[1];
3982	workingCopies[0] = getWorkingCopy("/JavaSearch/src/Test.java",
3983	"class Null {}\n" +
3984	"class NULL {}\n" +
3985	"class NullPointerException {}\n" +
3986	"class NULLPointerException {}\n" +
3987	"class NULLPOINTERException {}\n" +
3988	"class NULLPOINTEREXCEPTION {}\n"
3989	);
3990	search("Null", IJavaSearchConstants.TYPE, IJavaSearchConstants.DECLARATIONS, SearchPattern.R_CAMEL_CASE_MATCH \| SearchPattern.R_PREFIX_MATCH \| SearchPattern.R_CASE_SENSITIVE);
3991	assertSearchResults(
3992	"src/Test.java Null [Null]\n" +
3993	"src/Test.java NullPointerException [NullPointerException]"
3994	);
3995	}
3841		3996
3842	/**	3997	/**
3843	* @bug 160323: [search] TypeNameMatch: support hashCode/equals	3998	* @bug 160323: [search] TypeNameMatch: support hashCode/equals

Lines 124-130 Link Here

(-)src/org/eclipse/jdt/core/tests/model/SearchTests.java (-24 / +151 lines)
124	}	124	}
125	}	125	}
126	static {	126	static {
127	// TESTS_NAMES = new String[] { "testSearchPatternCreation25" };	127	TESTS_PREFIX = "testSearchPatternValidateMatchRule";
128	}	128	}
129	public static Test suite() {	129	public static Test suite() {
130	return buildModelTestSuite(SearchTests.class);	130	return buildModelTestSuite(SearchTests.class);
Lines 185-197 Link Here
185	}	185	}
186	protected void assertValidMatchRule(String pattern, int rule, int expected) {	186	protected void assertValidMatchRule(String pattern, int rule, int expected) {
187	int validated = SearchPattern.validateMatchRule(pattern, rule);	187	int validated = SearchPattern.validateMatchRule(pattern, rule);
		188	String givenRule = BasicSearchEngine.getMatchRuleString(rule);
188	String validatedRule = BasicSearchEngine.getMatchRuleString(validated);	189	String validatedRule = BasicSearchEngine.getMatchRuleString(validated);
189	String expectedRule = BasicSearchEngine.getMatchRuleString(expected);	190	String expectedRule = BasicSearchEngine.getMatchRuleString(expected);
190	if (!validatedRule.equals(expectedRule)) {	191	if (!validatedRule.equals(expectedRule)) {
191	System.out.println("Test "+getName());	192	System.out.println("Test "+getName());
192	System.out.print(" assertValidMatchRule(\"");	193	System.out.print(" assertValidMatchRule(\"");
193	System.out.print(pattern);	194	System.out.print(pattern);
194	System.out.print("\", ");	195	System.out.println("\",");
		196	System.out.print(" SearchPattern.");
		197	System.out.print(givenRule);
		198	System.out.println("\",");
		199	System.out.print(" SearchPattern.");
195	System.out.print(validatedRule);	200	System.out.print(validatedRule);
196	System.out.println(");");	201	System.out.println(");");
197	assertEquals(pattern+"' does not match expected match rule!", expectedRule, validatedRule);	202	assertEquals(pattern+"' does not match expected match rule!", expectedRule, validatedRule);
Lines 993-1035 Link Here
993	"TypeReferencePattern: qualification<X.*>, type<Y>, exact match, case sensitive, erasure only",	998	"TypeReferencePattern: qualification<X.*>, type<Y>, exact match, case sensitive, erasure only",
994	searchPattern);	999	searchPattern);
995	}	1000	}
		1001
996	/**	1002	/**
997	* Test CamelCase validation	1003	* Test pattern validation
998	*/	1004	*/
999	public void testSearchPatternValidMatchRule01() {	1005	public void testSearchPatternValidMatchRule01() {
1000	assertValidMatchRule("foo", SearchPattern.R_EXACT_MATCH, SearchPattern.R_EXACT_MATCH);	1006	assertValidMatchRule("foo",
1001	assertValidMatchRule("foo", SearchPattern.R_PREFIX_MATCH, SearchPattern.R_PREFIX_MATCH);	1007	SearchPattern.R_EXACT_MATCH,
1002	assertValidMatchRule("foo", SearchPattern.R_PATTERN_MATCH, SearchPattern.R_EXACT_MATCH);	1008	SearchPattern.R_EXACT_MATCH);
1003	assertValidMatchRule("foo", SearchPattern.R_PATTERN_MATCH\|SearchPattern.R_PREFIX_MATCH, SearchPattern.R_PREFIX_MATCH);
1004	assertValidMatchRule("foo", SearchPattern.R_CAMELCASE_MATCH, SearchPattern.R_PREFIX_MATCH\|SearchPattern.R_CASE_SENSITIVE);
1005	}	1009	}
1006	public void testSearchPatternValidMatchRule02() {	1010	public void testSearchPatternValidMatchRule02() {
1007	assertValidMatchRule("CP*P", SearchPattern.R_EXACT_MATCH, SearchPattern.R_PATTERN_MATCH);	1011	assertValidMatchRule("foo",
1008	assertValidMatchRule("CP*P", SearchPattern.R_PREFIX_MATCH, SearchPattern.R_PATTERN_MATCH);	1012	SearchPattern.R_PREFIX_MATCH,
1009	assertValidMatchRule("CP*P", SearchPattern.R_PATTERN_MATCH, SearchPattern.R_PATTERN_MATCH);	1013	SearchPattern.R_PREFIX_MATCH);
1010	assertValidMatchRule("CP*P", SearchPattern.R_PATTERN_MATCH\|SearchPattern.R_PREFIX_MATCH, SearchPattern.R_PATTERN_MATCH);
1011	assertValidMatchRule("CP*P", SearchPattern.R_CAMELCASE_MATCH, SearchPattern.R_PATTERN_MATCH);
1012	}	1014	}
1013	public void testSearchPatternValidMatchRule03() {	1015	public void testSearchPatternValidMatchRule03() {
1014	assertValidMatchRule("NPE", SearchPattern.R_CAMELCASE_MATCH);	1016	assertValidMatchRule("foo",
		1017	SearchPattern.R_PATTERN_MATCH,
		1018	SearchPattern.R_EXACT_MATCH);
		1019	}
		1020	public void testSearchPatternValidMatchRule04() {
		1021	assertValidMatchRule("foo",
		1022	SearchPattern.R_PATTERN_MATCH \| SearchPattern.R_PREFIX_MATCH,
		1023	SearchPattern.R_PREFIX_MATCH);
		1024	}
		1025	/** @deprecated As using a depreciated constant */
		1026	public void testSearchPatternValidMatchRule05() {
		1027	assertValidMatchRule("foo",
		1028	SearchPattern.R_CAMELCASE_MATCH,
		1029	SearchPattern.R_PREFIX_MATCH \| SearchPattern.R_CASE_SENSITIVE);
		1030	}
		1031	public void testSearchPatternValidMatchRule06() {
		1032	assertValidMatchRule("foo",
		1033	SearchPattern.R_CAMEL_CASE_MATCH,
		1034	SearchPattern.R_PREFIX_MATCH);
		1035	}
		1036	public void testSearchPatternValidMatchRule10() {
		1037	assertValidMatchRule("CP*P",
		1038	SearchPattern.R_EXACT_MATCH,
		1039	SearchPattern.R_PATTERN_MATCH);
		1040	}
		1041	public void testSearchPatternValidMatchRule11() {
		1042	assertValidMatchRule("CP*P",
		1043	SearchPattern.R_PREFIX_MATCH,
		1044	SearchPattern.R_PATTERN_MATCH);
		1045	}
		1046	public void testSearchPatternValidMatchRule12() {
		1047	assertValidMatchRule("CP*P",
		1048	SearchPattern.R_PATTERN_MATCH,
		1049	SearchPattern.R_PATTERN_MATCH);
		1050	}
		1051	public void testSearchPatternValidMatchRule13() {
		1052	assertValidMatchRule("CP*P",
		1053	SearchPattern.R_PATTERN_MATCH \| SearchPattern.R_PREFIX_MATCH,
		1054	SearchPattern.R_PATTERN_MATCH);
		1055	}
		1056	/** @deprecated As using a depreciated constant */
		1057	public void testSearchPatternValidMatchRule14() {
		1058	assertValidMatchRule("CP*P",
		1059	SearchPattern.R_CAMELCASE_MATCH,
		1060	SearchPattern.R_PATTERN_MATCH);
		1061	}
		1062	public void testSearchPatternValidMatchRule15() {
		1063	assertValidMatchRule("CP*P",
		1064	SearchPattern.R_CAMEL_CASE_MATCH,
		1065	SearchPattern.R_PATTERN_MATCH);
		1066	}
		1067	/** @deprecated As using a depreciated constant */
		1068	public void testSearchPatternValidMatchRule20() {
		1069	assertValidMatchRule("NPE",
		1070	SearchPattern.R_CAMELCASE_MATCH);
		1071	}
		1072	/** @deprecated As using a depreciated constant */
		1073	public void testSearchPatternValidMatchRule21() {
1015	assertValidMatchRule("NPE",	1074	assertValidMatchRule("NPE",
1016	SearchPattern.R_CAMELCASE_MATCH\|SearchPattern.R_PREFIX_MATCH\|SearchPattern.R_CASE_SENSITIVE,	1075	SearchPattern.R_CAMELCASE_MATCH \| SearchPattern.R_PREFIX_MATCH \| SearchPattern.R_CASE_SENSITIVE,
1017	SearchPattern.R_CAMELCASE_MATCH);	1076	SearchPattern.R_CAMELCASE_MATCH);
1018	assertValidMatchRule("nPE", SearchPattern.R_CAMELCASE_MATCH);
1019	assertValidMatchRule("NuPoEx", SearchPattern.R_CAMELCASE_MATCH);
1020	assertValidMatchRule("oF", SearchPattern.R_CAMELCASE_MATCH);
1021	}	1077	}
1022	public void testSearchPatternValidMatchRule04() {	1078	/** @deprecated As using a depreciated constant */
		1079	public void testSearchPatternValidMatchRule22() {
		1080	assertValidMatchRule("nPE",
		1081	SearchPattern.R_CAMELCASE_MATCH);
		1082	}
		1083	/** @deprecated As using a depreciated constant */
		1084	public void testSearchPatternValidMatchRule23() {
		1085	assertValidMatchRule("NuPoEx",
		1086	SearchPattern.R_CAMELCASE_MATCH);
		1087	}
		1088	/** @deprecated As using a depreciated constant */
		1089	public void testSearchPatternValidMatchRule24() {
		1090	assertValidMatchRule("oF",
		1091	SearchPattern.R_CAMELCASE_MATCH);
		1092	}
		1093	public void testSearchPatternValidMatchRule30() {
		1094	assertValidMatchRule("NPE",
		1095	SearchPattern.R_CAMEL_CASE_MATCH);
		1096	}
		1097	public void testSearchPatternValidMatchRule31() {
		1098	assertValidMatchRule("NPE",
		1099	SearchPattern.R_CAMEL_CASE_MATCH \| SearchPattern.R_PREFIX_MATCH);
		1100	}
		1101	public void testSearchPatternValidMatchRule32() {
		1102	assertValidMatchRule("NPE",
		1103	SearchPattern.R_CAMEL_CASE_MATCH \| SearchPattern.R_CASE_SENSITIVE);
		1104	}
		1105	public void testSearchPatternValidMatchRule33() {
		1106	assertValidMatchRule("NPE",
		1107	SearchPattern.R_CAMEL_CASE_MATCH \| SearchPattern.R_PREFIX_MATCH \| SearchPattern.R_CASE_SENSITIVE);
		1108	}
		1109	public void testSearchPatternValidMatchRule34() {
		1110	assertValidMatchRule("nPE",
		1111	SearchPattern.R_CAMEL_CASE_MATCH);
		1112	}
		1113	public void testSearchPatternValidMatchRule35() {
		1114	assertValidMatchRule("NuPoEx",
		1115	SearchPattern.R_CAMEL_CASE_MATCH);
		1116	}
		1117	public void testSearchPatternValidMatchRule36() {
		1118	assertValidMatchRule("oF",
		1119	SearchPattern.R_CAMEL_CASE_MATCH);
		1120	}
		1121	/** @deprecated As using a depreciated constant */
		1122	public void testSearchPatternValidMatchRule40() {
1023	assertValidMatchRule("Nu/Po/Ex",	1123	assertValidMatchRule("Nu/Po/Ex",
1024	SearchPattern.R_CAMELCASE_MATCH,	1124	SearchPattern.R_CAMELCASE_MATCH,
1025	SearchPattern.R_PREFIX_MATCH\|SearchPattern.R_CASE_SENSITIVE);	1125	SearchPattern.R_PREFIX_MATCH \| SearchPattern.R_CASE_SENSITIVE);
		1126	}
		1127	/** @deprecated As using a depreciated constant */
		1128	public void testSearchPatternValidMatchRule41() {
1026	assertValidMatchRule("Nu.Po.Ex",	1129	assertValidMatchRule("Nu.Po.Ex",
1027	SearchPattern.R_CAMELCASE_MATCH\|SearchPattern.R_PREFIX_MATCH,	1130	SearchPattern.R_CAMELCASE_MATCH \| SearchPattern.R_PREFIX_MATCH,
1028	SearchPattern.R_PREFIX_MATCH);	1131	SearchPattern.R_PREFIX_MATCH);
1029	}	1132	}
1030	public void testSearchPatternValidMatchRule05() {	1133	/** @deprecated As using a depreciated constant */
1031	assertValidMatchRule("hashMap", SearchPattern.R_CAMELCASE_MATCH);	1134	public void testSearchPatternValidMatchRule42() {
1032	assertValidMatchRule("Hashmap", SearchPattern.R_CAMELCASE_MATCH);	1135	assertValidMatchRule("hashMap",
		1136	SearchPattern.R_CAMELCASE_MATCH);
		1137	}
		1138	/** @deprecated As using a depreciated constant */
		1139	public void testSearchPatternValidMatchRule43() {
		1140	assertValidMatchRule("Hashmap",
		1141	SearchPattern.R_CAMELCASE_MATCH);
		1142	}
		1143	public void testSearchPatternValidMatchRule44() {
		1144	assertValidMatchRule("Nu/Po/Ex",
		1145	SearchPattern.R_CAMEL_CASE_MATCH,
		1146	SearchPattern.R_PREFIX_MATCH);
		1147	}
		1148	public void testSearchPatternValidMatchRule45() {
		1149	assertValidMatchRule("Nu.Po.Ex",
		1150	SearchPattern.R_CAMEL_CASE_MATCH \| SearchPattern.R_PREFIX_MATCH,
		1151	SearchPattern.R_PREFIX_MATCH);
		1152	}
		1153	public void testSearchPatternValidMatchRule46() {
		1154	assertValidMatchRule("hashMap",
		1155	SearchPattern.R_CAMEL_CASE_MATCH);
		1156	}
		1157	public void testSearchPatternValidMatchRule47() {
		1158	assertValidMatchRule("Hashmap",
		1159	SearchPattern.R_CAMEL_CASE_MATCH);
1033	}	1160	}
1034		1161
1035	/**	1162	/**

Lines 503-508 Link Here

(-)src/org/eclipse/jdt/core/tests/model/AbstractJavaSearchTests.java (+13 lines)
503	}	503	}
504	}	504	}
505	System.out.println("--------------------------------------------------------------------------------");	505	System.out.println("--------------------------------------------------------------------------------");
		506	length *= 2;
506	for (int i=0; i<length; i+=2) {	507	for (int i=0; i<length; i+=2) {
507	System.out.println(sources[i]);	508	System.out.println(sources[i]);
508	System.out.println(sources[i+1]);	509	System.out.println(sources[i+1]);
Lines 632-637 Link Here
632	requestor,	633	requestor,
633	null);	634	null);
634	}	635	}
		636	protected void search(IJavaElement element, int limitTo) throws CoreException {
		637	search(element, limitTo, EXACT_RULE, getJavaSearchScope(), resultCollector);
		638	}
		639	protected void search(IJavaElement element, int limitTo, int matchRule) throws CoreException {
		640	search(element, limitTo, matchRule, getJavaSearchScope(), resultCollector);
		641	}
		642	protected void search(String patternString, int searchFor, int limitTo) throws CoreException {
		643	search(patternString, searchFor, limitTo, EXACT_RULE, getJavaSearchScope(), resultCollector);
		644	}
		645	protected void search(String patternString, int searchFor, int limitTo, int matchRule) throws CoreException {
		646	search(patternString, searchFor, limitTo, matchRule, getJavaSearchScope(), resultCollector);
		647	}
635	protected void searchAllTypeNames(String pattern, int matchRule, TypeNameRequestor requestor) throws JavaModelException {	648	protected void searchAllTypeNames(String pattern, int matchRule, TypeNameRequestor requestor) throws JavaModelException {
636	new SearchEngine(this.workingCopies).searchAllTypeNames(	649	new SearchEngine(this.workingCopies).searchAllTypeNames(
637	null,	650	null,

Lines 73-80 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/ConstructorPattern.java (-4 / +4 lines)
73	this.findDeclarations = findDeclarations;	73	this.findDeclarations = findDeclarations;
74	this.findReferences = findReferences;	74	this.findReferences = findReferences;
75		75
76	this.declaringQualification = isCaseSensitive() ? declaringQualification : CharOperation.toLowerCase(declaringQualification);	76	this.declaringQualification = this.isCaseSensitive ? declaringQualification : CharOperation.toLowerCase(declaringQualification);
77	this.declaringSimpleName = (isCaseSensitive() \|\| isCamelCase()) ? declaringSimpleName : CharOperation.toLowerCase(declaringSimpleName);	77	this.declaringSimpleName = (this.isCaseSensitive \|\| this.isCamelCase) ? declaringSimpleName : CharOperation.toLowerCase(declaringSimpleName);
78	if (parameterSimpleNames != null) {	78	if (parameterSimpleNames != null) {
79	this.parameterCount = parameterSimpleNames.length;	79	this.parameterCount = parameterSimpleNames.length;
80	boolean synthetic = this.parameterCount>0 && declaringQualification != null && CharOperation.equals(CharOperation.concat(parameterQualifications[0], parameterSimpleNames[0], '.'), declaringQualification);	80	boolean synthetic = this.parameterCount>0 && declaringQualification != null && CharOperation.equals(CharOperation.concat(parameterQualifications[0], parameterSimpleNames[0], '.'), declaringQualification);
Lines 87-94 Link Here
87	this.parameterQualifications = new char[this.parameterCount][];	87	this.parameterQualifications = new char[this.parameterCount][];
88	this.parameterSimpleNames = new char[this.parameterCount][];	88	this.parameterSimpleNames = new char[this.parameterCount][];
89	for (int i = 0; i < this.parameterCount; i++) {	89	for (int i = 0; i < this.parameterCount; i++) {
90	this.parameterQualifications[i] = isCaseSensitive() ? parameterQualifications[i+offset] : CharOperation.toLowerCase(parameterQualifications[i+offset]);	90	this.parameterQualifications[i] = this.isCaseSensitive ? parameterQualifications[i+offset] : CharOperation.toLowerCase(parameterQualifications[i+offset]);
91	this.parameterSimpleNames[i] = isCaseSensitive() ? parameterSimpleNames[i+offset] : CharOperation.toLowerCase(parameterSimpleNames[i+offset]);	91	this.parameterSimpleNames[i] = this.isCaseSensitive ? parameterSimpleNames[i+offset] : CharOperation.toLowerCase(parameterSimpleNames[i+offset]);
92	}	92	}
93	} else {	93	} else {
94	this.parameterCount = -1;	94	this.parameterCount = -1;

Lines 24-35 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/VariablePattern.java (-4 / +4 lines)
24	public VariablePattern(int patternKind, boolean findDeclarations, boolean readAccess, boolean writeAccess, char[] name, int matchRule) {	24	public VariablePattern(int patternKind, boolean findDeclarations, boolean readAccess, boolean writeAccess, char[] name, int matchRule) {
25	super(patternKind, matchRule);	25	super(patternKind, matchRule);
26		26
27	this.findDeclarations = findDeclarations; // set to find declarations & all occurences	27	this.findDeclarations = findDeclarations; // set to find declarations & all occurrences
28	this.readAccess = readAccess; // set to find any reference, read only references & all occurences	28	this.readAccess = readAccess; // set to find any reference, read only references & all occurrences
29	this.writeAccess = writeAccess; // set to find any reference, write only references & all occurences	29	this.writeAccess = writeAccess; // set to find any reference, write only references & all occurrences
30	this.findReferences = readAccess \|\| writeAccess;	30	this.findReferences = readAccess \|\| writeAccess;
31		31
32	this.name = (isCaseSensitive() \|\| isCamelCase()) ? name : CharOperation.toLowerCase(name);	32	this.name = (this.isCaseSensitive \|\| this.isCamelCase) ? name : CharOperation.toLowerCase(name);
33	}	33	}
34	/*	34	/*
35	* Returns whether a method declaration or message send will need to be resolved to	35	* Returns whether a method declaration or message send will need to be resolved to

Lines 42-48 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/JavaSearchPattern.java (-7 / +7 lines)
42	* <li>{@link #R_PREFIX_MATCH}</li>	42	* <li>{@link #R_PREFIX_MATCH}</li>
43	* <li>{@link #R_PATTERN_MATCH}</li>	43	* <li>{@link #R_PATTERN_MATCH}</li>
44	* <li>{@link #R_REGEXP_MATCH}</li>	44	* <li>{@link #R_REGEXP_MATCH}</li>
45	* <li>{@link #R_CAMELCASE_MATCH}</li>	45	* <li>{@link #R_CAMEL_CASE_MATCH}</li>
46	* </ul>	46	* </ul>
47	*/	47	*/
48	int matchMode;	48	int matchMode;
Lines 75-81 Link Here
75	// see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=81377	75	// see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=81377
76	int rule = getMatchRule();	76	int rule = getMatchRule();
77	this.isCaseSensitive = (rule & R_CASE_SENSITIVE) != 0;	77	this.isCaseSensitive = (rule & R_CASE_SENSITIVE) != 0;
78	this.isCamelCase = (rule & R_CAMELCASE_MATCH) != 0;	78	this.isCamelCase = (rule & R_CAMEL_CASE_MATCH) != 0;
79	this.matchCompatibility = rule & MATCH_COMPATIBILITY_MASK;	79	this.matchCompatibility = rule & MATCH_COMPATIBILITY_MASK;
80	this.matchMode = rule & MATCH_MODE_MASK;	80	this.matchMode = rule & MATCH_MODE_MASK;
81	}	81	}
Lines 84-106 Link Here
84	return null;	84	return null;
85	}	85	}
86		86
87	int getMatchMode() {	87	final int getMatchMode() {
88	return this.matchMode;	88	return this.matchMode;
89	}	89	}
90		90
91	boolean isCamelCase() {	91	final boolean isCamelCase() {
92	return this.isCamelCase;	92	return this.isCamelCase;
93	}	93	}
94		94
95	boolean isCaseSensitive () {	95	final boolean isCaseSensitive () {
96	return this.isCaseSensitive;	96	return this.isCaseSensitive;
97	}	97	}
98		98
99	boolean isErasureMatch() {	99	final boolean isErasureMatch() {
100	return (this.matchCompatibility & R_ERASURE_MATCH) != 0;	100	return (this.matchCompatibility & R_ERASURE_MATCH) != 0;
101	}	101	}
102		102
103	boolean isEquivalentMatch() {	103	final boolean isEquivalentMatch() {
104	return (this.matchCompatibility & R_EQUIVALENT_MATCH) != 0;	104	return (this.matchCompatibility & R_EQUIVALENT_MATCH) != 0;
105	}	105	}
106		106

Lines 118-124 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/PatternLocator.java (-13 / +14 lines)
118	public PatternLocator(SearchPattern pattern) {	118	public PatternLocator(SearchPattern pattern) {
119	int matchRule = pattern.getMatchRule();	119	int matchRule = pattern.getMatchRule();
120	this.isCaseSensitive = (matchRule & SearchPattern.R_CASE_SENSITIVE) != 0;	120	this.isCaseSensitive = (matchRule & SearchPattern.R_CASE_SENSITIVE) != 0;
121	this.isCamelCase = (matchRule & SearchPattern.R_CAMELCASE_MATCH) != 0;	121	this.isCamelCase = (matchRule & SearchPattern.R_CAMEL_CASE_MATCH) != 0;
122	this.isErasureMatch = (matchRule & SearchPattern.R_ERASURE_MATCH) != 0;	122	this.isErasureMatch = (matchRule & SearchPattern.R_ERASURE_MATCH) != 0;
123	this.isEquivalentMatch = (matchRule & SearchPattern.R_EQUIVALENT_MATCH) != 0;	123	this.isEquivalentMatch = (matchRule & SearchPattern.R_EQUIVALENT_MATCH) != 0;
124	this.matchMode = matchRule & JavaSearchPattern.MATCH_MODE_MASK;	124	this.matchMode = matchRule & JavaSearchPattern.MATCH_MODE_MASK;
Lines 282-305 Link Here
282	boolean matchFirstChar = !this.isCaseSensitive \|\| pattern[0] == name[0];	282	boolean matchFirstChar = !this.isCaseSensitive \|\| pattern[0] == name[0];
283	boolean sameLength = pattern.length == name.length;	283	boolean sameLength = pattern.length == name.length;
284	boolean canBePrefix = name.length >= pattern.length;	284	boolean canBePrefix = name.length >= pattern.length;
285	if (this.isCamelCase && matchFirstChar && CharOperation.camelCaseMatch(pattern, name)) {	285	if (this.isCamelCase) {
286	return POSSIBLE_MATCH;	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;
287	}	290	}
288	switch (this.matchMode) {	291	switch (this.matchMode) {
289	case SearchPattern.R_EXACT_MATCH:	292	case SearchPattern.R_EXACT_MATCH:
290	if (!this.isCamelCase) {	293	if (sameLength && matchFirstChar && CharOperation.equals(pattern, name, this.isCaseSensitive)) {
291	if (sameLength && matchFirstChar && CharOperation.equals(pattern, name, this.isCaseSensitive)) {	294	return POSSIBLE_MATCH \| EXACT_FLAVOR;
292	return POSSIBLE_MATCH \| EXACT_FLAVOR;
293	}
294	break;
295	}	295	}
296	// fall through next case to match as prefix if camel case failed	296	break;
297	case SearchPattern.R_PREFIX_MATCH:	297	case SearchPattern.R_PREFIX_MATCH:
298	if (canBePrefix && matchFirstChar && CharOperation.prefixEquals(pattern, name, this.isCaseSensitive)) {	298	if (canBePrefix && matchFirstChar && CharOperation.prefixEquals(pattern, name, this.isCaseSensitive)) {
299	return POSSIBLE_MATCH;	299	return POSSIBLE_MATCH;
300	}	300	}
301	break;	301	break;
302	case SearchPattern.R_PATTERN_MATCH:	302	case SearchPattern.R_PATTERN_MATCH:
		303	// TODO_PERFS (frederic) Not sure this lowercase is necessary
303	if (!this.isCaseSensitive) {	304	if (!this.isCaseSensitive) {
304	pattern = CharOperation.toLowerCase(pattern);	305	pattern = CharOperation.toLowerCase(pattern);
305	}	306	}
Lines 717-729 Link Here
717	}	718	}
718	}	719	}
719	if (this.isCamelCase) {	720	if (this.isCamelCase) {
720	if (!this.isCaseSensitive \|\| (qualifiedPattern.length>0 && sourceName.length>0 && qualifiedPattern[0] == sourceName[0])) {	721	if ((qualifiedPattern.length>0 && sourceName.length>0 && qualifiedPattern[0] == sourceName[0])) {
721	if (CharOperation.camelCaseMatch(qualifiedPattern, sourceName)) {	722	if (CharOperation.camelCaseMatch(qualifiedPattern, sourceName, (this.matchMode & SearchPattern.R_PREFIX_MATCH) != 0)) {
722	return ACCURATE_MATCH;	723	return ACCURATE_MATCH;
723	}	724	}
724	}	725	}
725	if (this.matchMode == SearchPattern.R_EXACT_MATCH) {	726	if (!this.isCaseSensitive && this.matchMode == SearchPattern.R_EXACT_MATCH) {
726	boolean matchPattern = CharOperation.prefixEquals(qualifiedPattern, sourceName, this.isCaseSensitive);	727	boolean matchPattern = CharOperation.equals(qualifiedPattern, sourceName, false);
727	return matchPattern ? ACCURATE_MATCH : IMPOSSIBLE_MATCH;	728	return matchPattern ? ACCURATE_MATCH : IMPOSSIBLE_MATCH;
728	}	729	}
729	}	730	}

Lines 46-60 Link Here

(-)search/org/eclipse/jdt/internal/core/search/matching/FieldPattern.java (-5 / +5 lines)
46		46
47	super(FIELD_PATTERN, findDeclarations, readAccess, writeAccess, name, matchRule);	47	super(FIELD_PATTERN, findDeclarations, readAccess, writeAccess, name, matchRule);
48		48
49	this.declaringQualification = isCaseSensitive() ? declaringQualification : CharOperation.toLowerCase(declaringQualification);	49	this.declaringQualification = this.isCaseSensitive ? declaringQualification : CharOperation.toLowerCase(declaringQualification);
50	this.declaringSimpleName = isCaseSensitive() ? declaringSimpleName : CharOperation.toLowerCase(declaringSimpleName);	50	this.declaringSimpleName = this.isCaseSensitive ? declaringSimpleName : CharOperation.toLowerCase(declaringSimpleName);
51	this.typeQualification = isCaseSensitive() ? typeQualification : CharOperation.toLowerCase(typeQualification);	51	this.typeQualification = this.isCaseSensitive ? typeQualification : CharOperation.toLowerCase(typeQualification);
52	this.typeSimpleName = (isCaseSensitive() \|\| isCamelCase()) ? typeSimpleName : CharOperation.toLowerCase(typeSimpleName);	52	this.typeSimpleName = (this.isCaseSensitive \|\| this.isCamelCase) ? typeSimpleName : CharOperation.toLowerCase(typeSimpleName);
53		53
54	((InternalSearchPattern)this).mustResolve = mustResolve();	54	((InternalSearchPattern)this).mustResolve = mustResolve();
55	}	55	}
56	/*	56	/*
57	* Instanciate a field pattern with additional information for generics search	57	* Instantiate a field pattern with additional information for generic search
58	*/	58	*/
59	public FieldPattern(	59	public FieldPattern(
60	boolean findDeclarations,	60	boolean findDeclarations,

Lines 46-54 Link Here

(-)buildnotes_jdt-core.html (-1 / +277 lines)
46	<br>Project org.eclipse.jdt.core v_809	46	<br>Project org.eclipse.jdt.core v_809
47	(<a href="http://dev.eclipse.org/viewcvs/index.cgi/org.eclipse.jdt.core/?only_with_tag=v_809">cvs</a>).	47	(<a href="http://dev.eclipse.org/viewcvs/index.cgi/org.eclipse.jdt.core/?only_with_tag=v_809">cvs</a>).
48	<h2>What's new in this drop</h2>	48	<h2>What's new in this drop</h2>
		49	<ul>
		50	<li>Prefix matching can be disabled while using Camel Case API methods. (see
		51	<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=124624">bug 124624</a>).<br>
		52	Following API methods have been added on <code>org.eclipse.jdt.core.compiler.CharOperation</code>:
		53	<pre>
		54	/**
		55	* Answers true if the pattern matches the given name using CamelCase rules, or
		56	* false otherwise. char[] CamelCase matching does NOT accept explicit wild-cards
		57	* '*' and '?' and is inherently case sensitive.
		58	*
		59	* CamelCase denotes the convention of writing compound names without spaces,
		60	* and capitalizing every term. This function recognizes both upper and lower
		61	* CamelCase, depending whether the leading character is capitalized or not.
		62	* The leading part of an upper CamelCase pattern is assumed to contain a
		63	* sequence of capitals which are appearing in the matching name; e.g. 'NPE' will
		64	* match 'NullPointerException', but not 'NewPerfData'. A lower CamelCase pattern
		65	* uses a lowercase first character. In Java, type names follow the upper
		66	* CamelCase convention, whereas method or field names follow the lower
		67	* CamelCase convention.
		68	*
		69	* The pattern may contain lowercase characters, which will be match in a case
		70	* sensitive way. These characters must appear in sequence in the name.
		71	* For instance, 'NPExcep' will match 'NullPointerException', but not
		72	* 'NullPointerExCEPTION' or 'NuPoEx' will match 'NullPointerException', but not
		73	* 'NoPointerException'.
		74	*
		75	* Digit characters are treated in a special way. They can be used in the pattern
		76	* but are not always considered as leading character. For instance, both
		77	* 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
		78	*
		79	* CamelCase may or may not match prefixes depending on the given parameter.
		80	* When the prefix match parameter is <code>true</code>, the given pattern can
		81	* match only a prefix of the given name. For instance, 'HM' , 'HaMa' and 'HMap'
		82	* patterns will all match 'HashMap', 'HatMapper' <b>and</b> 'HashMapEntry'.
		83	* Reversely, if the prefix match parameter is <code>false</code>, then pattern
		84	* and name must have <b>exactly</b> the same number of parts, and their last
		85	* parts must be identical if they contain lowercase characters.
		86	* For instance, 'HMap' and 'HaMap' patterns will match 'HashMap' but neither
		87	* 'HashMapEntry' nor 'HatMapper'. Note that when the last part does not contain
		88	* lowercase characters, then the name may end with lowercase characters.
		89	* So, 'HM' pattern will match both 'HashMap' <b>and</b> 'HatMapper' but will not
		90	* match 'HashMapEntry'.
		91	*
		92	* Examples:
		93	* 1. pattern = { 'N', 'P', 'E' }
		94	* name = { 'N', 'u','l', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
		95	* result => true
		96	* 2. pattern = { 'N', 'P', 'E' }
		97	* name = { 'N', 'o', 'P', 'e', 'r', 'm', 'i', 's', 's', 'i', 'o', 'n', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
		98	* result => true
		99	* 3. pattern = { 'N', 'u', 'P', 'o', 'E', 'x' }
		100	* name = { 'N', 'u','l', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
		101	* result => true
		102	* 4. pattern = { 'N', 'u', 'P', 'o', 'E', 'x' }
		103	* name = { 'N', 'o', 'P', 'e', 'r', 'm', 'i', 's', 's', 'i', 'o', 'n', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
		104	* result => false
		105	* 5. pattern = { 'n', p', 'e' }
		106	* name = { 'N', 'u','l', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
		107	* result => false
		108	* 6. pattern = { 'I', 'P', 'L', '3' }
		109	* name = { 'I', 'P', 'e', 'r', 's', 'p', 'e', 'c', 't', 'i', 'v', 'e', 'L', 'i', 's', 't', 'e', 'n', 'e', 'r', '3' }
		110	* result => true
		111	* 7. pattern = { 'H', M' }
		112	* name = { 'H', 'a', 's', 'h', 'M', 'a', 'p', 'E', 'n', 't', 'r', 'y' }
113	* result => (prefixMatch == true)
114	* 8. pattern = { 'H', M', 'a', 'p' }
115	* name = { 'H', 'a', 't', 'M', 'a', 'p', 'p', 'e', 'r' }
116	* result => (prefixMatch == true)
117	*
118	* @param pattern the given pattern
119	* @param name the given name
120	* @param prefixMatch flag telling whether the pattern can match name prefix or not.
121	* . For example, when it's <code>true</code>:
122	* - 'HM' type string pattern will match 'HashMap' and 'HtmlMapper' types,
123	* but not 'HashMapEntry'
124	* - 'HMap' type string pattern will match 'HashMap' type but not 'HtmlMapper'.
125	* . and, when it's <code>false</code>:
126	* - 'HM' type string pattern will match both 'HashMap' and 'HtmlMapper'
127	* and 'HashMapEntry'
128	* - 'HMap' type string pattern will match both 'HashMap' and 'HtmlMapper'
129	* types.
130	*
131	* @return true if the pattern matches the given name, false otherwise
132	* @since 3.4
133	*/
134	public static final boolean camelCaseMatch(char[] pattern, char[] name, boolean prefixMatch) {
135	...
136	}
137
138	/**
139	* Answers true if a sub-pattern matches the sub-part of the given name using
140	* CamelCase rules, or false otherwise. char[] CamelCase matching does NOT
141	* accept explicit wild-cards '*' and '?' and is inherently case sensitive.
142	* Can match only subset of name/pattern, considering end positions as
143	* non-inclusive. The sub-pattern is defined by the patternStart and patternEnd
144	* positions.
145	*
146	* CamelCase denotes the convention of writing compound names without spaces,
147	* and capitalizing every term. This function recognizes both upper and lower
148	* CamelCase, depending whether the leading character is capitalized or not.
149	* The leading part of an upper CamelCase pattern is assumed to contain
150	* a sequence of capitals which are appearing in the matching name; e.g. 'NPE' will
151	* match 'NullPointerException', but not 'NewPerfData'. A lower CamelCase pattern
152	* uses a lowercase first character. In Java, type names follow the upper
153	* CamelCase convention, whereas method or field names follow the lower
154	* CamelCase convention.
155	*
156	* The pattern may contain lowercase characters, which will be match in a case
157	* sensitive way. These characters must appear in sequence in the name.
158	* For instance, 'NPExcep' will match 'NullPointerException', but not
159	* 'NullPointerExCEPTION' or 'NuPoEx' will match 'NullPointerException', but not
160	* 'NoPointerException'.
161	*
162	* Digit characters are treated in a special way. They can be used in the pattern
163	* but are not always considered as leading character. For instance, both
164	* 'UTF16DSS' and 'UTFDSS' patterns will match 'UTF16DocumentScannerSupport'.
165	*
166	* CamelCase may or may not match prefixes depending on the given parameter.
167	* When the prefix match parameter is <code>true</code>, the given pattern can
168	* match only a prefix of the given name. For instance, 'HM' , 'HaMa' and 'HMap'
169	* patterns will all match 'HashMap', 'HatMapper' <b>and</b> 'HashMapEntry'.
170	* Reversely, if the prefix match parameter is <code>false</code>, then pattern
171	* and name must have <b>exactly</b> the same number of parts, and their last
172	* parts must be identical if they contain lowercase characters.
173	* For instance, 'HMap' and 'HaMap' patterns will match 'HashMap' but neither
174	* 'HashMapEntry' nor 'HatMapper'. Note that when the last part does not contain
175	* lowercase characters, then the name may end with lowercase characters.
176	* So, 'HM' pattern will match both 'HashMap' <b>and</b> 'HatMapper' but will not
177	* match 'HashMapEntry'.
178	*
179	* Examples:
180	* 1. pattern = { 'N', 'P', 'E' }
181	* patternStart = 0
182	* patternEnd = 3
183	* name = { 'N', 'u','l', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
184	* nameStart = 0
185	* nameEnd = 20
186	* result => true
187	* 2. pattern = { 'N', 'P', 'E' }
188	* patternStart = 0
189	* patternEnd = 3
190	* name = { 'N', 'o', 'P', 'e', 'r', 'm', 'i', 's', 's', 'i', 'o', 'n', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
191	* nameStart = 0
192	* nameEnd = 21
193	* result => true
194	* 3. pattern = { 'N', 'u', 'P', 'o', 'E', 'x' }
195	* patternStart = 0
196	* patternEnd = 6
197	* name = { 'N', 'u','l', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
198	* nameStart = 0
199	* nameEnd = 20
200	* result => true
201	* 4. pattern = { 'N', 'u', 'P', 'o', 'E', 'x' }
202	* patternStart = 0
203	* patternEnd = 6
204	* name = { 'N', 'o', 'P', 'e', 'r', 'm', 'i', 's', 's', 'i', 'o', 'n', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
205	* nameStart = 0
206	* nameEnd = 21
207	* result => false
208	* 5. pattern = { 'n', p', 'e' }
209	* patternStart = 0
210	* patternEnd = 3
211	* name = { 'N', 'u','l', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n' }
212	* nameStart = 20
213	* nameEnd = 9
214	* result => false
215	* 6. pattern = { 'I', 'P', 'L', '3' }
216	* patternStart = 0
217	* patternEnd = 4
218	* name = { 'I', 'P', 'e', 'r', 's', 'p', 'e', 'c', 't', 'i', 'v', 'e', 'L', 'i', 's', 't', 'e', 'n', 'e', 'r', '3' }
219	* nameStart = 0
220	* nameEnd = 21
221	* result => true
222	* 7. pattern = { 'H', M' }
223	* patternStart = 0
224	* patternEnd = 2
225	* name = { 'H', 'a', 's', 'h', 'M', 'a', 'p', 'E', 'n', 't', 'r', 'y' }
226	* nameStart = 0
227	* nameEnd = 12
228	* result => (prefixMatch == true)
229	* 8. pattern = { 'H', M', 'a', 'p' }
230	* patternStart = 0
231	* patternEnd = 4
232	* name = { 'H', 'a', 't', 'M', 'a', 'p', 'p', 'e', 'r' }
233	* nameStart = 0
234	* nameEnd = 9
235	* result => (prefixMatch == true)
236	*
237	* @param pattern the given pattern
238	* @param patternStart the start index of the pattern, inclusive
239	* @param patternEnd the end index of the pattern, exclusive
240	* @param name the given name
241	* @param nameStart the start index of the name, inclusive
242	* @param nameEnd the end index of the name, exclusive
243	* @param prefixMatch flag telling whether the pattern can match name prefix or not.
244	* . For example, when it's <code>true</code>:
245	* - 'HM' type string pattern will match 'HashMap' and 'HtmlMapper' types,
246	* but not 'HashMapEntry'
247	* - 'HMap' type string pattern will match 'HashMap' type but not 'HtmlMapper'.
248	* . and, when it's <code>false</code>:
249	* - 'HM' type string pattern will match both 'HashMap' and 'HtmlMapper'
250	* and 'HashMapEntry'
251	* - 'HMap' type string pattern will match both 'HashMap' and 'HtmlMapper'
252	* types.
253	*
254	* @return true if a sub-pattern matches the sub-part of the given name, false otherwise
255	* @since 3.4
256	*/
257	public static final boolean camelCaseMatch(char[] pattern, int patternStart, int patternEnd, char[] name, int nameStart, int nameEnd, boolean prefixMatch) {
258	...
259	}
260	</pre>
261	Note that same methods have been added on <code>SearchPattern</code> but with
262	<code>String</code> parameters instead of <code>char[]</code> ones (javadoc comments
263	are identical):
264	<pre>
265	public static final boolean camelCaseMatch(String pattern, String name, boolean prefixMatch) {
266	...
267	}
268	public static final boolean camelCaseMatch(String pattern, int patternStart, int patternEnd, String name, int nameStart, int nameEnd, boolean prefixMatch) {
269	...
270	}
271	</pre>
272	Note also that methods <code>camelCaseMatch(String, int, int, String, int, int)</code>
273	of <code>CharOperation</code> and <code>SearchPattern</code> classes have been
274	depreciated to avoid too many 'camelCaseMatch*' methods on these classes.
275	</li>
276	<li>Search Engine has been modified to better handle additional <code>SearchPattern</code>
277	constants while using Camel Case one (see <a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=200400">bug 200400</a>).<br>
278	Existing <code>SearchPattern#R_CAMELCASE_MATCH</code> constant has been depreciated and<br>
279	is <b>now replaced by <code>SearchPattern#R_CAMEL_CASE_MATCH</code></b>:<pre>
280	/**
281	* Match rule: The search pattern contains a Camel Case expression with
282	* a strict number of parts and preventing automatic prefix matching for the last
283	* part (if it consists of multiple letters).
284	*
285	* Examples:
286	* . 'HM' type string pattern will match 'HashMap' and 'HtmlMapper' types,
287	* but not 'HashMapEntry'
288	* . 'HMap' type string pattern will match 'HashMap' type but not 'HtmlMapper'.
289	*
290	* This Camel Case match rule does not allow prefix match but accept insensitive
291	* case. For instance, 'HashMap' or 'HASHMAP' patterns using this Camel Case
292	* rule will match both 'HashMap' but not 'HashMapEntry'.
293	*
294	* This rule still can be combined to prefix match to accept prefix matches
295	* ('HashMap' pattern matching 'HashMapEntry' name). It can also be combined
296	* to case sensitive match to reject case insensitive matches ('HAMA' pattern
297	* will not match 'HashMap' name).
298	*
299	* If {@link #R_PATTERN_MATCH} rule is also combined, then the real used
300	* match rule will depend on whether string pattern contains specific pattern
301	* characters (e.g. '*' or '?') or not. If it does, then only Pattern match rule will
302	* be used, otherwise only Camel Case match will be used.
303	* For example, with 'NPE' string pattern, search will only use
304	* Camel Case match rule, but with 'NPE*' string pattern, it will
305	* use only Pattern match rule.
306	*
307	* @see CharOperation#camelCaseMatch(char[], char[], boolean) for a detailed
308	* explanation of Camel Case matching.
309	*
310	* @since 3.4
311	*/
312	public static final int R_CAMEL_CASE_MATCH = 0x0100;
313	</pre>
314	This change was necessary has the obsolete <code>R_CAMELCASE_MATCH</code> could
315	not support correctly additional constants as <code>R_PREFIX_MATCH</code> or
316	<code>R_CASE_SENSITIVE</code>.<br>
317	However, this depreciated constant is still accepted for backward compatibility
318	but user is advised to replace it with <code>R_CAMEL_CASE_MATCH \| R_PREFIX_MATCH</code>
319	</li>
320	</ul>
49		321
50	<h3>Problem Reports Fixed</h3>	322	<h3>Problem Reports Fixed</h3>
51	<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=191739">191739</a>	323	<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=200400">200400</a>
		324	[search] Camel Case match prefix insensitive although spec says prefix sensitive
		325	<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=124624">124624</a>
		326	[search] Camelcase matching routines should support end character
		327	<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=191739">191739</a>
52	"Duplicate nested type" bogus error on static class of abstract class or interface	328	"Duplicate nested type" bogus error on static class of abstract class or interface
53	<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=200931">200931</a>	329	<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=200931">200931</a>
54	GENERATED_BY references still exist in some javadoc comments	330	GENERATED_BY references still exist in some javadoc comments

Lines 570-576 Link Here

(-)search/org/eclipse/jdt/core/search/SearchEngine.java (-7 / +23 lines)
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 name are prefixes of the names
571	* of the searched types.</li>	571	* 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 type name contain wild-cards.</li>
573	* <li>{@link SearchPattern#R_CAMELCASE_MATCH} if type name are camel case of the names of the searched types.</li>	573	* <li>{@link SearchPattern#R_CAMEL_CASE_MATCH} if type name are camel case of the names of the searched types.</li>
574	* </ul>	574	* </ul>
575	* combined with {@link SearchPattern#R_CASE_SENSITIVE},	575	* 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,	576	* e.g. {@link SearchPattern#R_EXACT_MATCH} \| {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested,
Lines 637-643 Link Here
637	* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type name are prefixes of the names	637	* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type name are prefixes of the names
638	* of the searched types.</li>	638	* of the searched types.</li>
639	* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and type name contain wild-cards.</li>	639	* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and type name contain wild-cards.</li>
640	* <li>{@link SearchPattern#R_CAMELCASE_MATCH} if type name are camel case of the names of the searched types.</li>	640	* <li>{@link SearchPattern#R_CAMEL_CASE_MATCH} if type name are camel case of the names of the searched types.</li>
641	* </ul>	641	* </ul>
642	* combined with {@link SearchPattern#R_CASE_SENSITIVE},	642	* 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,	643	* e.g. {@link SearchPattern#R_EXACT_MATCH} \| {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested,
Lines 649-655 Link Here
649	* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type name are prefixes of the names	649	* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type name are prefixes of the names
650	* of the searched types.</li>	650	* of the searched types.</li>
651	* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and type name contain wild-cards.</li>	651	* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and type name contain wild-cards.</li>
652	* <li>{@link SearchPattern#R_CAMELCASE_MATCH} if type name are camel case of the names of the searched types.</li>	652	* <li>{@link SearchPattern#R_CAMEL_CASE_MATCH} if type name are camel case of the names of the searched types.</li>
653	* </ul>	653	* </ul>
654	* combined with {@link SearchPattern#R_CASE_SENSITIVE},	654	* 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,	655	* e.g. {@link SearchPattern#R_EXACT_MATCH} \| {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested,
Lines 694-700 Link Here
694	IProgressMonitor progressMonitor) throws JavaModelException {	694	IProgressMonitor progressMonitor) throws JavaModelException {
695		695
696	TypeNameRequestorWrapper requestorWrapper = new TypeNameRequestorWrapper(nameRequestor);	696	TypeNameRequestorWrapper requestorWrapper = new TypeNameRequestorWrapper(nameRequestor);
697	this.basicEngine.searchAllTypeNames(packageName, packageMatchRule, typeName, typeMatchRule, searchFor, scope, requestorWrapper, waitingPolicy, progressMonitor);	697	this.basicEngine.searchAllTypeNames(packageName,
		698	packageMatchRule,
		699	typeName,
		700	SearchPattern.updateMatchRule(typeMatchRule),
		701	searchFor,
		702	scope,
		703	requestorWrapper,
		704	waitingPolicy,
		705	progressMonitor);
698	}	706	}
699		707
700	/**	708	/**
Lines 716-722 Link Here
716	* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type name are prefixes of the names	724	* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type name are prefixes of the names
717	* of the searched types.</li>	725	* of the searched types.</li>
718	* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and type name contain wild-cards.</li>	726	* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and type name contain wild-cards.</li>
719	* <li>{@link SearchPattern#R_CAMELCASE_MATCH} if type name are camel case of the names of the searched types.</li>	727	* <li>{@link SearchPattern#R_CAMEL_CASE_MATCH} if type name are camel case of the names of the searched types.</li>
720	* </ul>	728	* </ul>
721	* combined with {@link SearchPattern#R_CASE_SENSITIVE},	729	* combined with {@link SearchPattern#R_CASE_SENSITIVE},
722	* e.g. {@link SearchPattern#R_EXACT_MATCH} \| {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested,	730	* e.g. {@link SearchPattern#R_EXACT_MATCH} \| {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested,
Lines 732-738 Link Here
732	* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type name are prefixes of the names	740	* <li>{@link SearchPattern#R_PREFIX_MATCH} if the package name and type name are prefixes of the names
733	* of the searched types.</li>	741	* of the searched types.</li>
734	* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and type name contain wild-cards.</li>	742	* <li>{@link SearchPattern#R_PATTERN_MATCH} if the package name and type name contain wild-cards.</li>
735	* <li>{@link SearchPattern#R_CAMELCASE_MATCH} if type name are camel case of the names of the searched types.</li>	743	* <li>{@link SearchPattern#R_CAMEL_CASE_MATCH} if type name are camel case of the names of the searched types.</li>
736	* </ul>	744	* </ul>
737	* combined with {@link SearchPattern#R_CASE_SENSITIVE},	745	* combined with {@link SearchPattern#R_CASE_SENSITIVE},
738	* e.g. {@link SearchPattern#R_EXACT_MATCH} \| {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested,	746	* e.g. {@link SearchPattern#R_EXACT_MATCH} \| {@link SearchPattern#R_CASE_SENSITIVE} if an exact and case sensitive match is requested,
Lines 778-784 Link Here
778	IProgressMonitor progressMonitor) throws JavaModelException {	786	IProgressMonitor progressMonitor) throws JavaModelException {
779		787
780	TypeNameMatchRequestorWrapper requestorWrapper = new TypeNameMatchRequestorWrapper(nameMatchRequestor, scope);	788	TypeNameMatchRequestorWrapper requestorWrapper = new TypeNameMatchRequestorWrapper(nameMatchRequestor, scope);
781	this.basicEngine.searchAllTypeNames(packageName, packageMatchRule, typeName, typeMatchRule, searchFor, scope, requestorWrapper, waitingPolicy, progressMonitor);	789	this.basicEngine.searchAllTypeNames(packageName,
		790	packageMatchRule,
		791	typeName,
		792	SearchPattern.updateMatchRule(typeMatchRule),
		793	searchFor,
		794	scope,
		795	requestorWrapper,
		796	waitingPolicy,
		797	progressMonitor);
782	}	798	}
783		799
784	/**	800	/**

Lines 47-53 Link Here

(-)search/org/eclipse/jdt/internal/core/index/Index.java (-13 / +10 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_CAMELCASE_MATCH;	50	SearchPattern.R_CAMEL_CASE_MATCH;
51		51
52	public static boolean isMatch(char[] pattern, char[] word, int matchRule) {	52	public static boolean isMatch(char[] pattern, char[] word, int matchRule) {
53	if (pattern == null) return true;	53	if (pattern == null) return true;
Lines 57-84 Link Here
57	if (wordLength == 0) return (matchRule & SearchPattern.R_PATTERN_MATCH) != 0 && patternLength == 1 && pattern[0] == '*';	57	if (wordLength == 0) return (matchRule & SearchPattern.R_PATTERN_MATCH) != 0 && patternLength == 1 && pattern[0] == '*';
58		58
59	// First test camel case if necessary	59	// First test camel case if necessary
60	boolean isCamelCase = (matchRule & SearchPattern.R_CAMELCASE_MATCH) != 0;	60	boolean isCamelCase = (matchRule & SearchPattern.R_CAMEL_CASE_MATCH) != 0;
61	if (isCamelCase && pattern[0] == word[0] && CharOperation.camelCaseMatch(pattern, word)) {	61	if (isCamelCase) {
62	return true;	62	if (pattern[0] == word[0] && CharOperation.camelCaseMatch(pattern, word, (matchRule & SearchPattern.R_PREFIX_MATCH) != 0)) {
		63	return true;
		64	}
		65	if ((matchRule & SearchPattern.R_CASE_SENSITIVE) != 0) return false;
63	}	66	}
64		67
65	// need to mask some bits of pattern rule (bug 79790)	68	// need to mask some bits of pattern rule (bug 79790)
66	matchRule &= ~SearchPattern.R_CAMELCASE_MATCH;	69	matchRule &= ~SearchPattern.R_CAMEL_CASE_MATCH;
67	switch(matchRule & MATCH_RULE_INDEX_MASK) {	70	switch(matchRule & MATCH_RULE_INDEX_MASK) {
68	case SearchPattern.R_EXACT_MATCH :	71	case SearchPattern.R_EXACT_MATCH :
69	if (!isCamelCase) {	72	return patternLength == wordLength && CharOperation.equals(pattern, word, false);
70	return patternLength == wordLength && CharOperation.equals(pattern, word, false);
71	}
72	// fall through prefix match if camel case failed
73	case SearchPattern.R_PREFIX_MATCH :	73	case SearchPattern.R_PREFIX_MATCH :
74	return patternLength <= wordLength && CharOperation.prefixEquals(pattern, word, false);	74	return patternLength <= wordLength && CharOperation.prefixEquals(pattern, word, false);
75	case SearchPattern.R_PATTERN_MATCH :	75	case SearchPattern.R_PATTERN_MATCH :
76	return CharOperation.match(pattern, word, false);	76	return CharOperation.match(pattern, word, false);
77	case SearchPattern.R_EXACT_MATCH \| SearchPattern.R_CASE_SENSITIVE :	77	case SearchPattern.R_EXACT_MATCH \| SearchPattern.R_CASE_SENSITIVE :
78	if (!isCamelCase) {	78	return pattern[0] == word[0] && patternLength == wordLength && CharOperation.equals(pattern, word);
79	return pattern[0] == word[0] && patternLength == wordLength && CharOperation.equals(pattern, word);
80	}
81	// fall through prefix match if camel case failed
82	case SearchPattern.R_PREFIX_MATCH \| SearchPattern.R_CASE_SENSITIVE :	79	case SearchPattern.R_PREFIX_MATCH \| SearchPattern.R_CASE_SENSITIVE :
83	return pattern[0] == word[0] && patternLength <= wordLength && CharOperation.prefixEquals(pattern, word);	80	return pattern[0] == word[0] && patternLength <= wordLength && CharOperation.prefixEquals(pattern, word);
84	case SearchPattern.R_PATTERN_MATCH \| SearchPattern.R_CASE_SENSITIVE :	81	case SearchPattern.R_PATTERN_MATCH \| SearchPattern.R_CASE_SENSITIVE :