Attachment 38178 Details for Bug 130390 – Final patch including fixes for some side effects + duplicate algortihm in SearchPatter

[patch] Final patch including fixes for some side effects + duplicate algortihm in SearchPatter

v01.txt (text/plain), 31.96 KB, created by Frederic Fusier

on 2006-04-10 13:40:57 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Frederic Fusier

Created: 2006-04-10 13:40:57 EDT

Size: 31.96 KB

patch

obsolete

>### 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;

Actions: View | Diff

Attachments on bug 130390: 35703 | 38134 | 38178