### Eclipse Workspace Patch 1.0
#P org.eclipse.ui.tests
Index: Eclipse UI Tests/org/eclipse/ui/tests/dialogs/SearchPatternAuto.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.ui.tests/Eclipse UI Tests/org/eclipse/ui/tests/dialogs/SearchPatternAuto.java,v
retrieving revision 1.5
diff -u -r1.5 SearchPatternAuto.java
--- Eclipse UI Tests/org/eclipse/ui/tests/dialogs/SearchPatternAuto.java	25 Jan 2007 23:09:56 -0000	1.5
+++ Eclipse UI Tests/org/eclipse/ui/tests/dialogs/SearchPatternAuto.java	27 Feb 2007 10:51:09 -0000
@@ -65,7 +65,7 @@
 			if (lenght == res.length()) 
 				resources.add(res);
 			else if ((res.trim().length() % 2) == 0)
-					generateRescourcesTestCases(Character.toUpperCase((char)(startChar + 1)), Character.toUpperCase((char)(endChar + 1)), lenght, res + " ");
+					generateRescourcesTestCases(Character.toUpperCase((char)(startChar + 1)), Character.toUpperCase((char)(endChar + 1)), lenght, res);
 				else 
 					generateRescourcesTestCases(Character.toLowerCase((char)(startChar + 1)), Character.toLowerCase((char)(endChar + 1)), lenght, res);
 		}
@@ -79,11 +79,12 @@
 	}
 	
 	/**
-	 * Tests exact match funtionality
+	 * Tests exact match funtionality. If we camelCase rule is enable, Pattern should starts with lowerCase character.
+	 * Result for "abcd " pattern should be similar to regexp pattern "abcd" with case insensitive.
 	 */
 	public void testExactMatch1() {
-		String patternText = "aBcD ";
-		Pattern pattern = Pattern.compile("aBcD", Pattern.CASE_INSENSITIVE);
+		String patternText = "abcd ";
+		Pattern pattern = Pattern.compile("abcd", Pattern.CASE_INSENSITIVE);
 		SearchPattern patternMatcher = new SearchPattern();
 		patternMatcher.setPattern(patternText);
 		assertEquals(patternMatcher.getMatchRule(), SearchPattern.RULE_EXACT_MATCH);
@@ -94,11 +95,12 @@
 	}
 	
 	/**
-	 * Tests exact match funtionality
+	 * Tests exact match funtionality. If we camelCase rule is enable, Pattern should starts with lowerCase character.
+	 * Result for "abcd " pattern should be similar to regexp pattern "abcd" with case insensitive.
 	 */
 	public void testExactMatch2() {
-		String patternText = "AbCdEfGh<";
-		Pattern pattern = Pattern.compile("AbCdEfGh", Pattern.CASE_INSENSITIVE);
+		String patternText = "abcdefgh<";
+		Pattern pattern = Pattern.compile("abcdefgh", Pattern.CASE_INSENSITIVE);
 		SearchPattern patternMatcher = new SearchPattern();
 		patternMatcher.setPattern(patternText);
 		assertEquals(patternMatcher.getMatchRule(), SearchPattern.RULE_EXACT_MATCH);
@@ -109,7 +111,8 @@
 	}
 	
 	/**
-	 * Tests prefix match funtionality
+	 * Tests prefix match funtionality. If we camelCase rule is enable, Pattern should starts with lowerCase character.
+	 * Result for "ab" pattern should be similar to regexp pattern "ab.*" with case insensitive.
 	 */
 	public void testPrefixMatch() {
 		String patternText = "ab";
@@ -124,7 +127,8 @@
 	}
 	
 	/**
-	 * Tests pattern match funtionality
+	 * Tests pattern match funtionality. It's similar to regexp patterns.
+	 * Result for "**cDe" pattern should be similar to regexp pattern ".*cde.*" with case insensitive.
 	 */
 	public void testPatternMatch1() {
 		String patternText = "**cDe";
@@ -139,7 +143,8 @@
 	}
 	
 	/**
-	 * Tests pattern match funtionality
+	 * Tests pattern match funtionality. It's similar to regexp patterns.
+	 * Result for "**c*e*i" pattern should be similar to regexp pattern ".*c.*e.*i.*" with case insensitive.
 	 */
 	public void testPatternMatch2() {
 		String patternText = "**c*e*i";
@@ -155,10 +160,11 @@
 	
 	/**
 	 * Tests camelCase match funtionality.
-	 * Every string contains only upperCase characters should be racognize as camelCase pattern match rule.
+	 * Every string starts with upperCase characters should be racognize as camelCase pattern match rule.
 	 * Result for "CD" SearchPattern should be similar to regexp pattern "C[^A-Z]*D.*" or "CD.*"
+	 * If pattern contains only upperCase characters result contains all prefix match elements.
 	 */
-	public void testCamelCaseMatch() {
+	public void testCamelCaseMatch1() {
 		String patternText = "CD";
 		Pattern pattern = Pattern.compile("C[^A-Z]*D.*");
 		Pattern pattern2 = Pattern.compile("CD.*", Pattern.CASE_INSENSITIVE);
@@ -174,6 +180,40 @@
 	}
 	
 	/**
+	 * Tests camelCase match funtionality.
+	 * Every string starts with upperCase characters should be racognize as camelCase pattern match rule.
+	 * Result for "AbCd " SearchPattern should be similar to regexp pattern "C[^A-Z]*D.*" or "CD.*"
+	 */
+	public void testCamelCaseMatch2() {
+		String patternText = "AbCd ";
+		Pattern pattern = Pattern.compile("Ab[^A-Z]*Cd[^A-Z]*");
+		SearchPattern patternMatcher = new SearchPattern();
+		patternMatcher.setPattern(patternText);
+		assertEquals(patternMatcher.getMatchRule(), SearchPattern.RULE_CAMELCASE_MATCH);
+		for (Iterator iter = resources.iterator(); iter.hasNext();) {
+			String res = (String) iter.next();
+			assertEquals(patternMatcher.matches(res), pattern.matcher(res).matches());
+		}
+	}
+	
+	/**
+	 * Tests camelCase match funtionality.
+	 * Every string starts with upperCase characters should be racognize as camelCase pattern match rule.
+	 * Result for "AbCdE<" SearchPattern should be similar to regexp pattern "Ab[^A-Z]*Cd[^A-Z]*E[^A-Z]*"
+	 */
+	public void testCamelCaseMatch3() {
+		String patternText = "AbCdE<";
+		Pattern pattern = Pattern.compile("Ab[^A-Z]*Cd[^A-Z]*E[^A-Z]*");
+		SearchPattern patternMatcher = new SearchPattern();
+		patternMatcher.setPattern(patternText);
+		assertEquals(patternMatcher.getMatchRule(), SearchPattern.RULE_CAMELCASE_MATCH);
+		for (Iterator iter = resources.iterator(); iter.hasNext();) {
+			String res = (String) iter.next();
+			assertEquals(patternMatcher.matches(res), pattern.matcher(res).matches());
+		}
+	}
+	
+	/**
 	 * Tests blank match funtionality. 
 	 * Blank string should be racognize as blank pattern match rule.
 	 * It should match with all resources.
#P org.eclipse.ui.workbench
Index: Eclipse UI/org/eclipse/ui/dialogs/SearchPattern.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.ui.workbench/Eclipse UI/org/eclipse/ui/dialogs/SearchPattern.java,v
retrieving revision 1.11
diff -u -r1.11 SearchPattern.java
--- Eclipse UI/org/eclipse/ui/dialogs/SearchPattern.java	23 Feb 2007 18:00:23 -0000	1.11
+++ Eclipse UI/org/eclipse/ui/dialogs/SearchPattern.java	27 Feb 2007 10:51:10 -0000
@@ -32,7 +32,8 @@
 	// Rules for pattern matching: (exact, prefix, pattern) [ | case sensitive]
 	/**
 	 * Match rule: The search pattern matches exactly the search result, that
-	 * is, the source of the search result equals the search pattern.
+	 * is, the source of the search result equals the search pattern. Search pattern
+	 * should start from lowerCase char.
 	 */
 	public static final int RULE_EXACT_MATCH = 0;
 
@@ -212,6 +213,12 @@
 			return;
 		}
 
+		if (validateMatchRule(pattern, RULE_CAMELCASE_MATCH) == RULE_CAMELCASE_MATCH) {
+			matchRule = RULE_CAMELCASE_MATCH;
+			stringPattern = pattern;
+			return;
+		}
+		
 		if (last == END_SYMBOL) {
 			matchRule = RULE_EXACT_MATCH;
 			stringPattern = pattern.substring(0, length - 1);
@@ -224,12 +231,6 @@
 			return;
 		}
 
-		if (validateMatchRule(pattern, RULE_CAMELCASE_MATCH) == RULE_CAMELCASE_MATCH) {
-			matchRule = RULE_CAMELCASE_MATCH;
-			stringPattern = pattern;
-			return;
-		}
-
 		matchRule = RULE_PREFIX_MATCH;
 		stringPattern = pattern;
 
@@ -447,6 +448,11 @@
 			// first char must strictly match (upper/lower)
 			return false;
 		}
+		
+		int patternLength = pattern.length();
+		
+		if (pattern.charAt(patternLength - 1) == END_SYMBOL || pattern.charAt(patternLength - 1) == BLANK )
+			patternLength--;
 
 		char patternChar, nameChar;
 		int iPattern = patternStart;
@@ -464,6 +470,8 @@
 			}
 
 			if (iName == nameEnd) {
+				if (iPattern == patternLength) 
+					return true;
 				// We have exhausted name (and not pattern), so it's not a match
 				return false;
 			}
@@ -483,13 +491,21 @@
 			// name
 			while (true) {
 				if (iName == nameEnd) {
-					// We have exhausted name (and not pattern), so it's not a
-					// match
+					if (patternChar == END_SYMBOL || patternChar == BLANK)
+						return true;
 					return false;
 				}
 
 				nameChar = name.charAt(iName);
 
+				if (patternChar == END_SYMBOL || patternChar == BLANK) {
+					if (isNameCharAllowed(nameChar)) {
+						return false;
+					}
+					iName++;
+					continue;
+				}
+
 				if (!isNameCharAllowed(nameChar)) {
 					// nameChar is lowercase
 					iName++;
@@ -516,7 +532,8 @@
 	 * @return true if patternChar is in set of allowed characters for pattern
 	 */
 	protected boolean isPatternCharAllowed(char patternChar) {
-		return Character.isUpperCase(patternChar);
+		return Character.isUpperCase(patternChar) || patternChar == END_SYMBOL
+				|| patternChar == BLANK;
 	}
 
 	/**
@@ -600,17 +617,11 @@
 			// 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 = isValidCamelCaseChar(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 = Character.isUpperCase(ch);
 			}
-			validCamelCase = validCamelCase && uppercase;
+			validCamelCase = validCamelCase && Character.isUpperCase(stringPattern.charAt(0));
 			// Verify bits compatibility
 			if (validCamelCase) {
 				if ((matchRule & RULE_PREFIX_MATCH) != 0) {