Attachment 38134 Details for Bug 130390 – Tuned patch to fit last changes done in CharOperation

[patch] Tuned patch to fit last changes done in CharOperation

v00.txt (text/plain), 20.42 KB, created by Frederic Fusier

on 2006-04-10 08:06:43 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Frederic Fusier

Created: 2006-04-10 08:06:43 EDT

Size: 20.42 KB

patch

obsolete

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

Actions: View | Diff

Attachments on bug 130390: 35703 | 38134 | 38178