### Eclipse Workspace Patch 1.0
#P org.eclipse.jdt.core
Index: search/org/eclipse/jdt/internal/core/search/matching/PatternLocator.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/matching/PatternLocator.java,v
retrieving revision 1.56
diff -u -r1.56 PatternLocator.java
--- search/org/eclipse/jdt/internal/core/search/matching/PatternLocator.java	29 Mar 2006 03:13:59 -0000	1.56
+++ search/org/eclipse/jdt/internal/core/search/matching/PatternLocator.java	10 Apr 2006 17:28:09 -0000
@@ -270,31 +270,20 @@
 	}
 	boolean matchFirstChar = !this.isCaseSensitive || pattern[0] == name[0];
 	boolean sameLength = pattern.length == name.length;
-	boolean canBePrefix = name.length > pattern.length;
+	boolean canBePrefix = name.length >= pattern.length;
+	if (this.isCamelCase && matchFirstChar && CharOperation.camelCaseMatch(pattern, name)) {
+		return POSSIBLE_MATCH;
+	}
 	switch (this.matchMode) {
 		case SearchPattern.R_EXACT_MATCH:
-			if (sameLength && matchFirstChar && 	CharOperation.equals(pattern, name, this.isCaseSensitive)) {
+			if (!this.isCamelCase && sameLength && matchFirstChar && CharOperation.equals(pattern, name, this.isCaseSensitive)) {
 				return POSSIBLE_FULL_MATCH;
 			}
-			if (this.isCamelCase) {
-				if (canBePrefix && matchFirstChar && CharOperation.prefixEquals(pattern, name, this.isCaseSensitive)) {
-					return POSSIBLE_PREFIX_MATCH;
-				}
-				if (matchFirstChar && CharOperation.camelCaseMatch(pattern, name)) {
-					return POSSIBLE_CAMELCASE_MATCH;
-				}
-			}
 			break;
 		case SearchPattern.R_PREFIX_MATCH:
-			if (sameLength && matchFirstChar && 	CharOperation.equals(pattern, name, this.isCaseSensitive)) {
-				return POSSIBLE_FULL_MATCH;
-			}
 			if (canBePrefix && matchFirstChar && CharOperation.prefixEquals(pattern, name, this.isCaseSensitive)) {
 				return POSSIBLE_PREFIX_MATCH;
 			}
-			if (this.isCamelCase && matchFirstChar && CharOperation.camelCaseMatch(pattern, name)) {
-				return POSSIBLE_CAMELCASE_MATCH;
-			}
 			break;
 		case SearchPattern.R_PATTERN_MATCH:
 			if (!this.isCaseSensitive) {
@@ -702,6 +691,9 @@
 				return ACCURATE_MATCH;
 			}
 		}
+		if (this.matchMode == SearchPattern.R_EXACT_MATCH) {
+			return IMPOSSIBLE_MATCH;
+		}
 	}
 	boolean matchPattern = CharOperation.match(qualifiedPattern, sourceName, this.isCaseSensitive);
 	return matchPattern ? ACCURATE_MATCH : IMPOSSIBLE_MATCH;
Index: buildnotes_jdt-core.html
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/buildnotes_jdt-core.html,v
retrieving revision 1.5165
diff -u -r1.5165 buildnotes_jdt-core.html
--- buildnotes_jdt-core.html	10 Apr 2006 14:03:51 -0000	1.5165
+++ buildnotes_jdt-core.html	10 Apr 2006 17:28:07 -0000
@@ -52,7 +52,9 @@
 What's new in this drop</h2>
 
 <h3>Problem Reports Fixed</h3>
-<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=129330">129330</a>
+<a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=130390">130390</a>
+CamelCase algorithm cleanup and improvement
+<br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=129330">129330</a>
 strange statement recovery
 <br><a href="http://bugs.eclipse.org/bugs/show_bug.cgi?id=135602">135602</a>
 [compiler] Codegen bug for continue statement
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 17:28:08 -0000
@@ -7,6 +7,7 @@
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
+ *     Luiz-Otávio Zorzella <z0149@zorzella.com> - Improve CamelCase algorithm
  *******************************************************************************/
 package org.eclipse.jdt.core.compiler;
 
@@ -283,59 +284,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 uppercase letter
 	}
-	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 17:28:09 -0000
@@ -307,59 +307,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.charAt(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.charAt(iPattern)) == name.charAt(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.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
+		}
+		else if (Character.isJavaIdentifierPart(patternChar) && !Character.isUpperCase(patternChar)) {
+			return false;
+		}
+
+		// patternChar is uppercase, so let's find the next uppercase in name
+		while (true) {
+			if (iName == nameEnd){
+	            //	We have exhausted name (and not pattern), so it's not a match
+				return false;
+			}
+
+			nameChar = name.charAt(iName);
+
+			if (nameChar < ScannerHelper.MAX_OBVIOUS) {
+				if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar] & (ScannerHelper.C_LOWER_LETTER | ScannerHelper.C_SPECIAL | ScannerHelper.C_DIGIT)) != 0) {
+					// nameChar is lowercase    
 					iName++;
-					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.charAt(iPattern) != name.charAt(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 uppercase letter
 	}
-	return iPattern == patternEnd;
 }	
 
 /**
@@ -1715,6 +1735,8 @@
 		boolean isCaseSensitive = (this.matchRule & R_CASE_SENSITIVE) != 0;
 		boolean isCamelCase = (this.matchRule & R_CAMELCASE_MATCH) != 0;
 		int matchMode = this.matchRule & MODE_MASK;
+		boolean sameLength = pattern.length == name.length;
+		boolean canBePrefix = name.length >= pattern.length;
 		boolean matchFirstChar = !isCaseSensitive || pattern.length == 0 || (name.length > 0 &&  pattern[0] == name[0]);
 		if (isCamelCase && matchFirstChar && CharOperation.camelCaseMatch(pattern, name)) {
 			return true;
@@ -1722,11 +1744,16 @@
 		switch (matchMode) {
 			case R_EXACT_MATCH :
 			case R_FULL_MATCH :
-				if (isCamelCase) return false;
-				return matchFirstChar && CharOperation.equals(pattern, name, isCaseSensitive);
+				if (!isCamelCase && sameLength && matchFirstChar) {
+					return CharOperation.equals(pattern, name, isCaseSensitive);
+				}
+				break;
 
 			case R_PREFIX_MATCH :
-				return matchFirstChar && CharOperation.prefixEquals(pattern, name, isCaseSensitive);
+				if (canBePrefix && matchFirstChar) {
+					return CharOperation.prefixEquals(pattern, name, isCaseSensitive);
+				}
+				break;
 
 			case R_PATTERN_MATCH :
 				if (!isCaseSensitive)
@@ -1805,22 +1832,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.model
Index: src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java,v
retrieving revision 1.69
diff -u -r1.69 JavaSearchBugsTests.java
--- src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java	9 Apr 2006 16:45:43 -0000	1.69
+++ src/org/eclipse/jdt/core/tests/model/JavaSearchBugsTests.java	10 Apr 2006 17:28:16 -0000
@@ -49,7 +49,7 @@
 //	org.eclipse.jdt.internal.codeassist.SelectionEngine.DEBUG = true;
 //	TESTS_PREFIX =  "testBug110060";
 //	TESTS_NAMES = new String[] { "testBug126330" };
-//	TESTS_NUMBERS = new int[] { 89686 };
+//	TESTS_NUMBERS = new int[] { 110060, 130390 };
 //	TESTS_RANGE = new int[] { 83304, -1 };
 	}
 
@@ -4400,6 +4400,9 @@
 }
 
 /**
+ * To get these tests search matches in a workspace, do NOT forget to modify files
+ * to set them as working copies.
+ *
  * @test Bug 110060: [plan][search] Add support for Camel Case search pattern
  * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=110060"
  */
@@ -5918,4 +5921,104 @@
 	);
 }
 
+
+/**
+ * To get these tests search matches in a workspace, do NOT forget to modify files
+ * to set them as working copies.
+ *
+ * @test Bug 130390: CamelCase algorithm cleanup and improvement
+ * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=130390"
+ */
+public void testBug130390() throws CoreException {
+	workingCopies = new ICompilationUnit[4];
+	workingCopies[0] = getWorkingCopy("/JavaSearchBugs/src/b130390/TZ.java",
+		"package b130390;\n" + 
+		"public class TZ {\n" +
+		"}\n"
+	);
+	workingCopies[1] = getWorkingCopy("/JavaSearchBugs/src/b130390/TimeZone.java",
+		"package b130390;\n" + 
+		"public class TimeZone{\n" +
+		"}\n"
+	);
+	workingCopies[2] = getWorkingCopy("/JavaSearchBugs/src/b130390/Npe.java",
+		"package b130390;\n" + 
+		"public class Npe {\n" +
+		"}\n"
+	);
+	workingCopies[3] = getWorkingCopy("/JavaSearchBugs/src/b130390/NullPointerException.java",
+		"package b130390;\n" + 
+		"public class NullPointerException {\n" +
+		"}\n"
+	);
+	search("NuPoEx", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
+	this.discard = false;
+	assertSearchResults(
+		"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
+	);
+}
+public void testBug130390b() throws CoreException {
+	assertNotNull("There should be working copies!", workingCopies);
+	assertEquals("Invalid number of working copies kept between tests!", 4, workingCopies.length);
+	search("NPE", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH);
+	this.discard = false;
+	assertSearchResults(
+		"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
+	);
+}
+public void testBug130390c() throws CoreException {
+	assertNotNull("There should be working copies!", workingCopies);
+	assertEquals("Invalid number of working copies kept between tests!", 4, workingCopies.length);
+	search("NPE", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE);
+	this.discard = false;
+	assertSearchResults(
+		"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
+	);
+}
+public void testBug130390d() throws CoreException {
+	assertNotNull("There should be working copies!", workingCopies);
+	assertEquals("Invalid number of working copies kept between tests!", 4, workingCopies.length);
+	search("Npe", TYPE, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);
+	this.discard = false;
+	assertSearchResults(
+		"src/b130390/Npe.java b130390.Npe [Npe] EXACT_MATCH"
+	);
+}
+public void testBug130390e() throws CoreException {
+	assertNotNull("There should be working copies!", workingCopies);
+	assertEquals("Invalid number of working copies kept between tests!", 4, workingCopies.length);
+	search("Npe", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE);
+	this.discard = false;
+	assertSearchResults(
+		"src/b130390/Npe.java b130390.Npe [Npe] EXACT_MATCH"
+	);
+}
+public void testBug130390f() throws CoreException {
+	assertNotNull("There should be working copies!", workingCopies);
+	assertEquals("Invalid number of working copies kept between tests!", 4, workingCopies.length);
+	search("NullPE", TYPE, ALL_OCCURRENCES, SearchPattern.R_CAMELCASE_MATCH);
+	this.discard = false;
+	assertSearchResults(
+		"src/b130390/NullPointerException.java b130390.NullPointerException [NullPointerException] EXACT_MATCH"
+	);
+}
+public void testBug130390g() throws CoreException {
+	assertNotNull("There should be working copies!", workingCopies);
+	assertEquals("Invalid number of working copies kept between tests!", 4, workingCopies.length);
+	search("TZ", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE);
+	this.discard = false;
+	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 {
+	assertNotNull("There should be working copies!", workingCopies);
+	assertEquals("Invalid number of working copies kept between tests!", 4, workingCopies.length);
+	search("TiZo", TYPE, DECLARATIONS, SearchPattern.R_CAMELCASE_MATCH | SearchPattern.R_CASE_SENSITIVE);
+	this.discard = false;
+	assertSearchResults(
+		"src/b130390/TimeZone.java b130390.TimeZone [TimeZone] EXACT_MATCH"
+	);
+}
 }
#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 17:28:18 -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;