Attachment #35703 for bug #130390




package org.eclipse.jdt.core.tests.compiler.regression;

import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;

import junit.framework.Test;


public static Class testClass() {
	return CharOperationTest.class;
}

public void testCamel() {
    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];
        assertTrue (match[0] + ":" + match[1], CharOperation.camelCaseMatch(match[0].toCharArray(), match[1].toCharArray())); //$NON-NLS-1$
    }
    
    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];
        assertFalse (match[0] + ":" + match[1], CharOperation.camelCaseMatch(match[0].toCharArray(), match[1].toCharArray())); //$NON-NLS-1$
    }
    
}

}




		return false;
	}
	char patternChar, nameChar;
	
	int iPattern = patternStart;
	int iName = nameStart;
	
	while (true) {
			switch (ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[patternChar]) {
				case ScannerHelper.C_UPPER_LETTER :
					// still uppercase
					break;
				default:
					// end of camelCase part of pattern
					break nextPatternChar;
			}
		} else if (Character.isJavaIdentifierPart(patternChar) 
						&& !Character.isUpperCase(patternChar)) {
			// end of camelCase part of pattern
			break nextPatternChar;
		}
		nextNameChar: while (iName < nameEnd) {
			if ((nameChar = name[iName]) != patternChar) {
				if (nameChar < ScannerHelper.MAX_OBVIOUS) {
					switch (ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar]) {
						case ScannerHelper.C_LOWER_LETTER :
						case ScannerHelper.C_IDENT_PART :
						case ScannerHelper.C_DIGIT :
							// lowercase/digit char is ignored
							iName++;
							continue nextNameChar;
					}
				} else if (Character.isJavaIdentifierPart(nameChar) 
								&& !Character.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[iPattern] != name[iName]) {
			return false;
		}
		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;
		}
		
		patternChar = pattern[iPattern];
		
		// For as long as we're exactly matching, bring it on
		if (patternChar == name[iName])
			continue;
		        
		if ( 
              (patternChar < ScannerHelper.MAX_OBVIOUS 
			    && 
              ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[patternChar] != ScannerHelper.C_UPPER_LETTER)
			||
              (Character.isJavaIdentifierPart(patternChar)
                &&
              !Character.isUpperCase(patternChar))
		) {
			// patternChar is lowercase, and it does not match name, so it's not a match
			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 
					    && 
		              ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar] != ScannerHelper.C_UPPER_LETTER)
					||
		              (Character.isJavaIdentifierPart(nameChar)
		                &&
		              !Character.isUpperCase(nameChar))
				) {
				// nameChar is lowercase    
				iName++;
			} else {
				// nameChar is uppercase... 
				if (patternChar != nameChar)
					//.. and it does not match patternChar, so it's not a match
					return false;
				
				//.. and it matched patternChar. Back to the big loop
				break;
			}
		}
		
		// At this point, either name has been exhausted, or it is at an uppercase letter.
		// Since pattern is also at an 
			
	}
	return iPattern == patternEnd;
}	

/**

Return to bug 130390

Lines 11-16 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/CharOperationTest.java (+48 lines)
11	package org.eclipse.jdt.core.tests.compiler.regression;	11	package org.eclipse.jdt.core.tests.compiler.regression;
12		12
13	import org.eclipse.jdt.core.compiler.CharOperation;	13	import org.eclipse.jdt.core.compiler.CharOperation;
		14	import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
14		15
15	import junit.framework.Test;	16	import junit.framework.Test;
16		17
Lines 77-80 Link Here
77	public static Class testClass() {	78	public static Class testClass() {
78	return CharOperationTest.class;	79	return CharOperationTest.class;
79	}	80	}
		81
		82	public void testCamel() {
		83	String[][] MATCHES = {
		84	{"TZ","TimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		85	{"TiZ","TimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		86	{"TiZon","TimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		87	{"TZon","TimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		88	{"TZone","TimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		89	{"TimeZone","TimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		90	{"TimeZ","TimeZ"}, //$NON-NLS-1$//$NON-NLS-2$
		91	{"TZ","TimeZ"}, //$NON-NLS-1$//$NON-NLS-2$
		92	{"T","TimeZ"}, //$NON-NLS-1$//$NON-NLS-2$
		93	{"T","TimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		94	{"TZ","TZ"}, //$NON-NLS-1$//$NON-NLS-2$
		95	{"aT","aTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		96	{"aTi","aTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		97	{"aTiZ","aTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		98	{"aTZ","aTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		99	{"aT","artTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		100	{"aTi","artTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		101	{"aTiZ","artTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		102	{"aTZ","artTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		103	};
		104
		105	for (int i = 0; i<MATCHES.length ; i++) {
		106	String[] match = MATCHES[i];
		107	assertTrue (match[0] + ":" + match[1], CharOperation.camelCaseMatch(match[0].toCharArray(), match[1].toCharArray())); //$NON-NLS-1$
		108	}
		109
		110	String[][] MIS_MATCHES = {
		111	{"TZ","Timezone"}, //$NON-NLS-1$//$NON-NLS-2$
		112	{"aTZ","TimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		113	{"aTZ","TZ"}, //$NON-NLS-1$//$NON-NLS-2$
		114	{"arT","aTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		115	{"arTi","aTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		116	{"arTiZ","aTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		117	{"arTZ","aTimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		118	{"aT","atimeZone"}, //$NON-NLS-1$//$NON-NLS-2$
		119	};
		120
		121	for (int i = 0; i<MIS_MATCHES.length ; i++) {
		122	String[] match = MIS_MATCHES[i];
		123	assertFalse (match[0] + ":" + match[1], CharOperation.camelCaseMatch(match[0].toCharArray(), match[1].toCharArray())); //$NON-NLS-1$
		124	}
		125
		126	}
		127
80	}	128	}

Lines 284-347 Link Here

(-)compiler/org/eclipse/jdt/core/compiler/CharOperation.java (-54 / +69 lines)
284	return false;	284	return false;
285	}	285	}
286	char patternChar, nameChar;	286	char patternChar, nameChar;
287	int iPattern = patternStart+1;	287
288	int iName = nameStart+1;	288	int iPattern = patternStart;
289	nextPatternChar: while (iPattern < patternEnd) {	289	int iName = nameStart;
290	// check patternChar, keep camelCasing only if uppercase	290
291	if ((patternChar = pattern[iPattern]) < ScannerHelper.MAX_OBVIOUS) {	291	while (true) {
292	switch (ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[patternChar]) {
293	case ScannerHelper.C_UPPER_LETTER :
294	// still uppercase
295	break;
296	default:
297	// end of camelCase part of pattern
298	break nextPatternChar;
299	}
300	} else if (Character.isJavaIdentifierPart(patternChar)
301	&& !Character.isUpperCase(patternChar)) {
302	// end of camelCase part of pattern
303	break nextPatternChar;
304	}
305	nextNameChar: while (iName < nameEnd) {
306	if ((nameChar = name[iName]) != patternChar) {
307	if (nameChar < ScannerHelper.MAX_OBVIOUS) {
308	switch (ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar]) {
309	case ScannerHelper.C_LOWER_LETTER :
310	case ScannerHelper.C_IDENT_PART :
311	case ScannerHelper.C_DIGIT :
312	// lowercase/digit char is ignored
313	iName++;
314	continue nextNameChar;
315	}
316	} else if (Character.isJavaIdentifierPart(nameChar)
317	&& !Character.isUpperCase(nameChar)) {
318	// lowercase name char is ignored
319	iName++;
320	continue nextNameChar;
321	}
322	// mismatch, either uppercase in name or non case char ('/' etc)--> reject
323	return false;
324	} else {
325	// pattern char == name char (uppercase)
326	iName++;
327	iPattern++;
328	continue nextPatternChar;
329	}
330	}
331	if (iPattern == patternEnd) return true;
332	if (iName == nameEnd) return false;
333	continue nextPatternChar;
334	}
335		292
336	// check trailing part in case sensitive way
337	while (iPattern < patternEnd && iName < nameEnd) {
338	if (pattern[iPattern] != name[iName]) {
339	return false;
340	}
341	iPattern++;	293	iPattern++;
342	iName++;	294	iName++;
		295
		296	if (iPattern == patternEnd) {
		297	// We have exhausted pattern, so it's a match
		298	return true;
		299	}
		300
		301	if (iName == nameEnd){
		302	// We have exhausted name (and not pattern), so it's not a match
		303	return false;
		304	}
		305
		306	patternChar = pattern[iPattern];
		307
		308	// For as long as we're exactly matching, bring it on
		309	if (patternChar == name[iName])
		310	continue;
		311
		312	if (
		313	(patternChar < ScannerHelper.MAX_OBVIOUS
		314	&&
		315	ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[patternChar] != ScannerHelper.C_UPPER_LETTER)
		316	\|\|
		317	(Character.isJavaIdentifierPart(patternChar)
		318	&&
		319	!Character.isUpperCase(patternChar))
		320	) {
		321	// patternChar is lowercase, and it does not match name, so it's not a match
		322	return false;
		323	}
		324
		325	// patternChar is uppercase, so let's find the next uppercase in name
		326	while (true) {
		327	if (iName == nameEnd){
		328	// We have exhausted name (and not pattern), so it's not a match
		329	return false;
		330	}
		331
		332	nameChar = name[iName];
		333
		334	if (
		335	(nameChar < ScannerHelper.MAX_OBVIOUS
		336	&&
		337	ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar] != ScannerHelper.C_UPPER_LETTER)
		338	\|\|
		339	(Character.isJavaIdentifierPart(nameChar)
		340	&&
		341	!Character.isUpperCase(nameChar))
		342	) {
		343	// nameChar is lowercase
		344	iName++;
		345	} else {
		346	// nameChar is uppercase...
		347	if (patternChar != nameChar)
		348	//.. and it does not match patternChar, so it's not a match
		349	return false;
		350
		351	//.. and it matched patternChar. Back to the big loop
		352	break;
		353	}
		354	}
		355
		356	// At this point, either name has been exhausted, or it is at an uppercase letter.
		357	// Since pattern is also at an
		358
343	}	359	}
344	return iPattern == patternEnd;
345	}	360	}
346		361
347	/**	362	/**