### Eclipse Workspace Patch 1.0
#P org.eclipse.jdt.core
Index: compiler/org/eclipse/jdt/core/compiler/CharOperation.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/CharOperation.java,v
retrieving revision 1.69
diff -u -r1.69 CharOperation.java
--- compiler/org/eclipse/jdt/core/compiler/CharOperation.java	28 Mar 2006 20:30:01 -0000	1.69
+++ compiler/org/eclipse/jdt/core/compiler/CharOperation.java	10 Apr 2006 11:54:24 -0000
@@ -283,59 +283,79 @@
 		// first char must strictly match (upper/lower)
 		return false;
 	}
+
 	char patternChar, nameChar;
-	int iPattern = patternStart+1;
-	int iName = nameStart+1;
-	nextPatternChar: while (iPattern < patternEnd) {
-		// check patternChar, keep camelCasing only if uppercase
-		if ((patternChar = pattern[iPattern]) < ScannerHelper.MAX_OBVIOUS) {
+	int iPattern = patternStart;
+	int iName = nameStart;
+
+	// Main loop is on pattern characters
+	while (true) {
+
+		iPattern++;
+		iName++;
+
+		if (iPattern == patternEnd) {
+			// We have exhausted pattern, so it's a match
+			return true;
+		}
+
+		if (iName == nameEnd){
+			// We have exhausted name (and not pattern), so it's not a match 
+			return false;
+		}
+
+		// For as long as we're exactly matching, bring it on (even if it's a lower case character)
+		if ((patternChar = pattern[iPattern]) == name[iName]) {
+			continue;
+		}
+
+		// If character are not the same then return if patternChar is lowercase
+		if (patternChar < ScannerHelper.MAX_OBVIOUS) {
 			if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[patternChar] & ScannerHelper.C_UPPER_LETTER) == 0) {
-				// end of camelCase part of pattern
-				break nextPatternChar;
+				return false;
 			}
-			// still uppercase
-		} else if (ScannerHelper.isJavaIdentifierPart(patternChar) 
-						&& !ScannerHelper.isUpperCase(patternChar)) {
-			// end of camelCase part of pattern
-			break nextPatternChar;
-		}
-		nextNameChar: while (iName < nameEnd) {
-			if ((nameChar = name[iName]) != patternChar) {
-				if (nameChar < ScannerHelper.MAX_OBVIOUS) {
-					if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar] & (ScannerHelper.C_LOWER_LETTER | ScannerHelper.C_SPECIAL | ScannerHelper.C_DIGIT)) != 0) {
-						// lowercase/digit char is ignored
-						iName++;
-						continue nextNameChar;
-					}
-				} else if (ScannerHelper.isJavaIdentifierPart(nameChar) 
-								&& !ScannerHelper.isUpperCase(nameChar)) {
-					// lowercase name char is ignored
+		}
+		else if (Character.isJavaIdentifierPart(patternChar) && !Character.isUpperCase(patternChar)) {
+			return false;
+		}
+
+		// patternChar is uppercase, so let's find the next uppercase in name
+		while (true) {
+			if (iName == nameEnd){
+	            //	We have exhausted name (and not pattern), so it's not a match
+				return false;
+			}
+
+			nameChar = name[iName];
+
+			if (nameChar < ScannerHelper.MAX_OBVIOUS) {
+				if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar] & (ScannerHelper.C_LOWER_LETTER | ScannerHelper.C_SPECIAL | ScannerHelper.C_DIGIT)) != 0) {
+					// nameChar is lowercase    
 					iName++;
-					continue nextNameChar;
+				// 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;
 				}
-				// mismatch, either uppercase in name or non case char ('/' etc)--> reject
+			}
+			else if (Character.isJavaIdentifierPart(nameChar) && !Character.isUpperCase(nameChar)) {
+				// nameChar is lowercase    
+				iName++;
+			// nameChar is uppercase...
+			} else  if (patternChar != nameChar) {
+				//.. and it does not match patternChar, so it's not a match
 				return false;
 			} else {
-				// pattern char == name char (uppercase)
-				iName++;
-				iPattern++;
-				continue nextPatternChar;
-			}	
-		}
-		if (iPattern == patternEnd) return true;
-		if (iName == nameEnd) return false;
-		continue nextPatternChar;
-	}
-		
-	// check trailing part in case sensitive way
-	while (iPattern < patternEnd && iName < nameEnd) {
-		if (pattern[iPattern] != name[iName]) {
-			return false;
+				//.. and it matched patternChar. Back to the big loop
+				break;
+			}
 		}
-		iPattern++;
-		iName++;
+		// At this point, either name has been exhausted, or it is at an uppercase letter.
+		// Since pattern is also at an 
 	}
-	return iPattern == patternEnd;
 }	
 
 /**
Index: search/org/eclipse/jdt/core/search/SearchPattern.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/search/org/eclipse/jdt/core/search/SearchPattern.java,v
retrieving revision 1.55
diff -u -r1.55 SearchPattern.java
--- search/org/eclipse/jdt/core/search/SearchPattern.java	3 Apr 2006 15:31:03 -0000	1.55
+++ search/org/eclipse/jdt/core/search/SearchPattern.java	10 Apr 2006 11:54:26 -0000
@@ -234,8 +234,9 @@
 		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());
+	char[] patternChars = pattern.toCharArray();
+	char nameChars[] = name.toCharArray();
+	return CharOperation.camelCaseMatch(patternChars, 0, patternChars.length, nameChars, 0, nameChars.length);
 }
 
 /**
@@ -297,69 +298,7 @@
 		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+1;
-	int iName = nameStart+1;
-	nextPatternChar: while (iPattern < patternEnd) {
-		// check patternChar, keep camelCasing only if uppercase
-		if ((patternChar = pattern.charAt(iPattern)) < ScannerHelper.MAX_OBVIOUS) {
-			if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[patternChar] & ScannerHelper.C_UPPER_LETTER) == 0) {
-				// end of camelCase part of pattern
-				break nextPatternChar;
-			}
-			// still uppercase
-		} else if (ScannerHelper.isJavaIdentifierPart(patternChar) 
-						&& !ScannerHelper.isUpperCase(patternChar)) {
-			// end of camelCase part of pattern
-			break nextPatternChar;
-		}
-		nextNameChar: while (iName < nameEnd) {
-			if ((nameChar = name.charAt(iName)) != patternChar) {
-				if (nameChar < ScannerHelper.MAX_OBVIOUS) {
-					if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar] & (ScannerHelper.C_LOWER_LETTER|ScannerHelper.C_SPECIAL |ScannerHelper.C_DIGIT)) != 0) {
-						// lowercase/digit char is ignored
-						iName++;
-						continue nextNameChar;
-					}
-				} else if (ScannerHelper.isJavaIdentifierPart(nameChar) 
-								&& !ScannerHelper.isUpperCase(nameChar)) {
-					// lowercase name char is ignored
-					iName++;
-					continue nextNameChar;
-				}
-				// mismatch, either uppercase in name or non case char ('/' etc)--> reject
-				return false;
-			} else {
-				// pattern char == name char (uppercase)
-				iName++;
-				iPattern++;
-				continue nextPatternChar;
-			}	
-		}
-		if (iPattern == patternEnd) return true;
-		if (iName == nameEnd) return false;
-		continue nextPatternChar;
-	}
-		
-	// check trailing part in case sensitive way
-	while (iPattern < patternEnd && iName < nameEnd) {
-		if (pattern.charAt(iPattern) != name.charAt(iName)) {
-			return false;
-		}
-		iPattern++;
-		iName++;
-	}
-	return iPattern == patternEnd;
+	return CharOperation.camelCaseMatch(pattern.toCharArray(), patternStart, patternEnd, name.toCharArray(), nameStart, nameEnd);
 }	
 
 /**
@@ -1805,22 +1744,10 @@
 	if ((matchRule & R_CAMELCASE_MATCH) != 0) {
 		// Verify sting pattern validity
 		int length = stringPattern.length();
-		boolean validCamelCase = false;
-		if (length > 1) {
-			int idx = 0;
-			char ch = stringPattern.charAt(idx++);
-			if (ScannerHelper.isJavaIdentifierStart(ch)) {
-				ch = stringPattern.charAt(idx++);
-				if (ScannerHelper.isUpperCase(ch)) {
-					while (idx<length && ScannerHelper.isUpperCase(stringPattern.charAt(idx))) {
-						idx++;
-					}
-					while (idx<length && (!ScannerHelper.isUpperCase(ch=stringPattern.charAt(idx)) && ScannerHelper.isJavaIdentifierPart(ch))) {
-						idx++;
-					}
-					validCamelCase = idx == length;
-				}
-			}
+		boolean validCamelCase = true;
+		for (int i=0; i<length && validCamelCase; i++) {
+			char ch = stringPattern.charAt(i++);
+			validCamelCase = ScannerHelper.isJavaIdentifierStart(ch);
 		}
 		// Verify bits compatibility
 		if (validCamelCase) {
#P org.eclipse.jdt.core.tests.compiler
Index: src/org/eclipse/jdt/core/tests/compiler/regression/UtilTest.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/UtilTest.java,v
retrieving revision 1.31
diff -u -r1.31 UtilTest.java
--- src/org/eclipse/jdt/core/tests/compiler/regression/UtilTest.java	29 Mar 2006 03:50:23 -0000	1.31
+++ src/org/eclipse/jdt/core/tests/compiler/regression/UtilTest.java	10 Apr 2006 11:54:28 -0000
@@ -19,13 +19,48 @@
 import junit.framework.Test;
 
 public class UtilTest extends AbstractRegressionTest {
-	
+
+StringBuffer camelCaseErrors;
+
 public UtilTest(String name) {
 	super(name);
 }
+static {
+//	TESTS_RANGE = new int[] { 62, -1 };
+}
 public static Test suite() {
 	return buildAllCompliancesTestSuite(testClass());
 }
+/**
+ * Assert that a pattern and a name matches or not.
+ * If result is invalid then store warning in buffer and display it.
+ */
+void assertCamelCase(String pattern, String name, boolean match) {
+	boolean camelCase = CharOperation.camelCaseMatch(pattern==null?null:pattern.toCharArray(), name==null?null:name.toCharArray());
+	if (match != camelCase) {
+		StringBuffer line = new StringBuffer("'");
+		line.append(name);
+		line.append("' SHOULD");
+		if (!match) line.append(" NOT");
+		line.append(" match pattern '");
+		line.append(pattern);
+		line.append("'");
+		if (this.camelCaseErrors.length() == 0) {
+			System.out.println("Invalid results in test "+getName()+":");
+		}
+		System.out.println("	- "+line);
+		this.camelCaseErrors.append('\n');
+		this.camelCaseErrors.append(line);
+	}
+}
+/* (non-Javadoc)
+ * @see org.eclipse.jdt.core.tests.compiler.regression.AbstractRegressionTest#setUp()
+ */
+protected void setUp() throws Exception {
+	super.setUp();
+	this.camelCaseErrors = new StringBuffer();
+}
+
 public boolean checkPathMatch(char[] pattern, char[] path, boolean isCaseSensitive) {
 	
 	CharOperation.replace(pattern, '/', File.separatorChar);
@@ -430,70 +465,96 @@
 		checkPathMatch("/P/src/**/CVS/".toCharArray(), "/P/src/CVS".toCharArray(), true));
 }
 public void test62() {
-	assertTrue("Camel pattern matching failure-1",
-			CharOperation.camelCaseMatch("NPE".toCharArray(), "NullPointerException".toCharArray()));
-	assertTrue("Camel pattern matching failure-2",
-			CharOperation.camelCaseMatch("NPExc".toCharArray(), "NullPointerException".toCharArray()));
-	assertTrue("Camel pattern matching failure-3",
-			!CharOperation.camelCaseMatch("NPoE".toCharArray(), "NullPointerException".toCharArray()));
-	assertTrue("Camel pattern matching failure-4",
-			!CharOperation.camelCaseMatch("NuPExc".toCharArray(), "NullPointerException".toCharArray()));
+	assertCamelCase("NPE", "NullPointerException", true/* should match */);
+	assertCamelCase("NPExc", "NullPointerException", true/* should match */);
+	assertCamelCase("NPoE", "NullPointerException", true/* should match */);
+	assertCamelCase("NuPExc", "NullPointerException", true/* should match */);
+    assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
 }
 public void test63() {
-	assertTrue("Camel pattern matching failure-1",
-			!CharOperation.camelCaseMatch("NPEX".toCharArray(), "NullPointerException".toCharArray()));
-	assertTrue("Camel pattern matching failure-2",
-			!CharOperation.camelCaseMatch("NPex".toCharArray(), "NullPointerException".toCharArray()));
-	assertTrue("Camel pattern matching failure-3",
-			!CharOperation.camelCaseMatch("npe".toCharArray(), "NullPointerException".toCharArray()));
-	assertTrue("Camel pattern matching failure-4",
-			!CharOperation.camelCaseMatch("npe".toCharArray(), "NPException".toCharArray()));
-	assertTrue("Camel pattern matching failure-5",
-			CharOperation.camelCaseMatch("NPointerE".toCharArray(), "NullPointerException".toCharArray()));
+	assertCamelCase("NPEX", "NullPointerException", false/* should not match */);
+	assertCamelCase("NPex", "NullPointerException", false/* should not match */);
+	assertCamelCase("npe", "NullPointerException", false/* should not match */);
+	assertCamelCase("npe", "NPException", false/* should not match */);
+	assertCamelCase("NPointerE", "NullPointerException", true/* should match */);
+    assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
 }
 public void test64() {
-	assertTrue("Camel pattern matching failure-1",
-			CharOperation.camelCaseMatch("IAE".toCharArray(), "IgnoreAllErrorHandler".toCharArray()));
-	assertTrue("Camel pattern matching failure-2",
-			CharOperation.camelCaseMatch("IAE".toCharArray(), "IAnchorElement".toCharArray()));
-	assertTrue("Camel pattern matching failure-3",
-			CharOperation.camelCaseMatch("IAnchorEleme".toCharArray(), "IAnchorElement".toCharArray()));
-	assertTrue("Camel pattern matching failure-4",
-			!CharOperation.camelCaseMatch("".toCharArray(), "IAnchorElement".toCharArray()));
-	assertTrue("Camel pattern matching failure-5",
-			CharOperation.camelCaseMatch(null, "IAnchorElement".toCharArray()));
-	assertTrue("Camel pattern matching failure-6",
-			CharOperation.camelCaseMatch("".toCharArray(), "".toCharArray()));
-	assertTrue("Camel pattern matching failure-7",
-			!CharOperation.camelCaseMatch("IAnchor".toCharArray(), null));
+	assertCamelCase("IAE", "IgnoreAllErrorHandler", true/* should match */);
+	assertCamelCase("IAE", "IAnchorElement", true/* should match */);
+	assertCamelCase("IAnchorEleme", "IAnchorElement", true/* should match */);
+	assertCamelCase("", "IAnchorElement", false/* should not match */);
+	assertCamelCase(null, "IAnchorElement", true/* should match */);
+	assertCamelCase("", "", true/* should match */);
+	assertCamelCase("IAnchor", null, false/* should not match */);
+    assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
 }
 public void test65() {
-	assertTrue("Camel pattern matching failure-1",
-			CharOperation.camelCaseMatch("iSCDCo".toCharArray(), "invokeStringConcatenationDefaultConstructor".toCharArray()));
-	assertTrue("Camel pattern matching failure-2",
-			!CharOperation.camelCaseMatch("inVOke".toCharArray(), "invokeStringConcatenationDefaultConstructor".toCharArray()));
-	assertTrue("Camel pattern matching failure-3",
-			CharOperation.camelCaseMatch("i".toCharArray(), "invokeStringConcatenationDefaultConstructor".toCharArray()));
-	assertTrue("Camel pattern matching failure-4",
-			!CharOperation.camelCaseMatch("I".toCharArray(), "invokeStringConcatenationDefaultConstructor".toCharArray()));
-	assertTrue("Camel pattern matching failure-5",
-			!CharOperation.camelCaseMatch("iStringCD".toCharArray(), "invokeStringConcatenationDefaultConstructor".toCharArray()));
-	assertTrue("Camel pattern matching failure-6",
-			CharOperation.camelCaseMatch("NPE".toCharArray(), "NullPointerException/java.lang".toCharArray()));
-	assertTrue("Camel pattern matching failure-7",
-			!CharOperation.camelCaseMatch("NPE".toCharArray(), "NullPointer/lang.Exception".toCharArray()));
-	assertTrue("Camel pattern matching failure-8",
-			CharOperation.camelCaseMatch("NPE".toCharArray(), "Null_Pointer$Exception".toCharArray()));
-	assertTrue("Camel pattern matching failure-9",
-			CharOperation.camelCaseMatch("NPE".toCharArray(), "Null1Pointer2Exception".toCharArray()));
-	assertTrue("Camel pattern matching failure-10",
-			!CharOperation.camelCaseMatch("NPE".toCharArray(), "Null.Pointer.Exception".toCharArray()));
-	assertTrue("Camel pattern matching failure-11",
-			!CharOperation.camelCaseMatch("NPE".toCharArray(), "aNullPointerException".toCharArray()));
-	assertTrue("Camel pattern matching failure-12",
-			CharOperation.camelCaseMatch("nullP".toCharArray(), "nullPointerException".toCharArray()));
-	assertTrue("Camel pattern matching failure-13",
-			CharOperation.camelCaseMatch("nP".toCharArray(), "nullPointerException".toCharArray()));
+	assertCamelCase("iSCDCo", "invokeStringConcatenationDefaultConstructor", true/* should match */);
+	assertCamelCase("inVOke", "invokeStringConcatenationDefaultConstructor", false/* should not match */);
+	assertCamelCase("i", "invokeStringConcatenationDefaultConstructor", true/* should match */);
+	assertCamelCase("I", "invokeStringConcatenationDefaultConstructor", false/* should not match */);
+	assertCamelCase("iStringCD", "invokeStringConcatenationDefaultConstructor", true/* should match */);
+	assertCamelCase("NPE", "NullPointerException/java.lang", true/* should match */);
+	assertCamelCase("NPE", "NullPointer/lang.Exception", false/* should not match */);
+	assertCamelCase("NPE", "Null_Pointer$Exception", true/* should match */);
+	assertCamelCase("NPE", "Null1Pointer2Exception", true/* should match */);
+	assertCamelCase("NPE", "Null.Pointer.Exception", false/* should not match */);
+	assertCamelCase("NPE", "aNullPointerException", false/* should not match */);
+	assertCamelCase("nullP", "nullPointerException", true/* should match */);
+	assertCamelCase("nP", "nullPointerException", true/* should match */);
+    assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
+}
+
+/**
+ * Bug 130390: CamelCase algorithm cleanup and improvement
+ * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=130390"
+ *
+ */
+public void test66() {
+    String[][] MATCHES = {
+            {"TZ","TimeZone"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"TiZ","TimeZone"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"TiZon","TimeZone"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"TZon","TimeZone"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"TZone","TimeZone"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"TimeZone","TimeZone"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"TimeZ","TimeZ"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"TZ","TimeZ"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"T","TimeZ"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"T","TimeZone"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"TZ","TZ"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"aT","aTimeZone"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"aTi","aTimeZone"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"aTiZ","aTimeZone"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"aTZ","aTimeZone"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"aT","artTimeZone"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"aTi","artTimeZone"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"aTiZ","artTimeZone"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"aTZ","artTimeZone"},  //$NON-NLS-1$//$NON-NLS-2$
+    };
+    
+    for (int i = 0; i<MATCHES.length ; i++) {
+        String[] match = MATCHES[i];
+        assertCamelCase(match[0], match[1], true/*should match*/);
+    }
+    
+    String[][] MIS_MATCHES = {
+            {"TZ","Timezone"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"aTZ","TimeZone"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"aTZ","TZ"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"arT","aTimeZone"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"arTi","aTimeZone"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"arTiZ","aTimeZone"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"arTZ","aTimeZone"},  //$NON-NLS-1$//$NON-NLS-2$
+            {"aT","atimeZone"},  //$NON-NLS-1$//$NON-NLS-2$
+    };
+    
+    for (int i = 0; i<MIS_MATCHES.length ; i++) {
+        String[] match = MIS_MATCHES[i];
+        assertCamelCase(match[0], match[1], false/*should not match*/);
+    }
+    assertTrue(this.camelCaseErrors.toString(), this.camelCaseErrors.length()==0);
 }
 public static Class testClass() {
 	return UtilTest.class;