Attachment #35567 for bug #61759

View | Details | Raw Unified | Return to bug 61759
Collapse All | Expand All




import java.util.EnumSet;
import java.util.LinkedList;
import java.util.List;
import java.util.regex.Pattern;

import org.apache.commons.lang3.StringUtils;
import org.apache.jmeter.engine.util.CompoundVariable;
import org.apache.jmeter.samplers.SampleResult;

 * <li>upper case</li>
 * <li>lower case</li>
 * <li>capitalize</li>
 * <li>camel cases</li>
 * <li></li>
 * </ul>
 * 

 */
public class ChangeCase extends AbstractFunction {

    private static final Pattern NOT_ALPHANUMERIC_REGEX = 
            Pattern.compile("[^a-zA-Z]");
    private static final Logger LOGGER = LoggerFactory.getLogger(ChangeCase.class);
    private static final List<String> DESC = new LinkedList<>();
    private static final String KEY = "__changeCase";

            case CAPITALIZE:
                targetString = StringUtils.capitalize(originalString);
                break;
            case LOWER_CAMEL_CASE:
                targetString = camel(originalString, false);
                break;
            case UPPER_CAMEL_CASE:
                targetString = camel(originalString, true);
                break;
            default:
                // default not doing nothing to string
            }

    public List<String> getArgumentDesc() {
        return DESC;
    }

    private static String camel(String str, boolean isFirstCapitalized) {
        StringBuilder builder = new StringBuilder(str.length());
        String[] tokens = NOT_ALPHANUMERIC_REGEX.split(str);
        for (int i = 0; i < tokens.length; i++) {
            String lowerCased = StringUtils.lowerCase(tokens[i]);
            if(i == 0) {
                builder.append(isFirstCapitalized ? StringUtils.capitalize(lowerCased):
                    lowerCased);
            } else {
                builder.append(StringUtils.capitalize(lowerCased));
            }
        }
        return builder.toString();
    }
    
    /**
     * ChangeCase Modes

     *
     */
    public enum ChangeCaseMode {
        UPPER("UPPER"), LOWER("LOWER"), CAPITALIZE("CAPITALIZE");
        UPPER_CAMEL_CASE("UPPER_CAMEL_CASE"), LOWER_CAMEL_CASE("LOWER_CAMEL_CASE");
        private String mode;

        private ChangeCaseMode(String mode) {




    }

    @Test
    public void testChangeCaseCamelCase() throws Exception {
        String returnValue = execute("ab-CD eF", "UPPER_CAMEL_CASE");
        assertEquals("AbCdEf", returnValue);
    }

    @Test
    public void testChangeCaseCapitalize() throws Exception {
        String returnValue = execute("ab-CD eF", "CAPITALIZE");
        assertEquals("Ab-CD eF", returnValue);
    }

    @Test
    public void testChangeCaseCamelCaseFirstLower() throws Exception {
        String returnValue = execute("ab-CD eF", "LOWER_CAMEL_CASE");
        assertEquals("abCdEf", returnValue);
    }

    @Test
    public void testChangeCaseCamelCaseFirstLowerWithFirstUpperCaseChar() throws Exception {
        String returnValue = execute("Ab-CD eF", "lower_CAMEL_CASE");
        assertEquals("abCdEf", returnValue);

        returnValue = execute(" zadad", "lower_CAMEL_CASE");
        assertEquals("Zadad", returnValue);
    }

    @Test(expected = InvalidVariableException.class)
    public void testChangeCaseError() throws Exception {
        changeCase.setParameters(new LinkedList<>());

Lines 1649-1659 Link Here

(-)xdocs/usermanual/functions.xml (-3 / +1 lines)
1649	<property name="change case mode" required="Yes">	1649	<property name="change case mode" required="Yes">
1650	The mode to be used to change case, for example for ab-CD eF:	1650	The mode to be used to change case, for example for ab-CD eF:
1651	<ul>	1651	<ul>
1652	<li><code>UPPER</code> result as AB-CD EF</li>	1652	<li><code>UPPER</code> (default) result as AB-CD EF</li>
1653	<li><code>LOWER</code> result as ab-cd ed</li>	1653	<li><code>LOWER</code> result as ab-cd ed</li>
1654	<li><code>CAPITALIZE</code> result as Ab-CD eF</li>	1654	<li><code>CAPITALIZE</code> result as Ab-CD eF</li>
1655	<li><code>UPPER_CAMEL_CASE</code>result as AbCdEf</li>
1656	<li><code>LOWER_CAMEL_CASE</code>result as abCdEf</li>
1657	</ul>	1655	</ul>
1658	<note>mode is case insensitive</note>	1656	<note>mode is case insensitive</note>
1659	</property>	1657	</property>

Return to bug 61759

Lines 22-29 Link Here

(-)src/functions/org/apache/jmeter/functions/ChangeCase.java (-28 / +1 lines)
22	import java.util.EnumSet;	22	import java.util.EnumSet;
23	import java.util.LinkedList;	23	import java.util.LinkedList;
24	import java.util.List;	24	import java.util.List;
25	import java.util.regex.Pattern;
26
27	import org.apache.commons.lang3.StringUtils;	25	import org.apache.commons.lang3.StringUtils;
28	import org.apache.jmeter.engine.util.CompoundVariable;	26	import org.apache.jmeter.engine.util.CompoundVariable;
29	import org.apache.jmeter.samplers.SampleResult;	27	import org.apache.jmeter.samplers.SampleResult;
Lines 40-46 Link Here
40	* <li>upper case</li>	38	* <li>upper case</li>
41	* <li>lower case</li>	39	* <li>lower case</li>
42	* <li>capitalize</li>	40	* <li>capitalize</li>
43	* <li>camel cases</li>
44	* <li></li>	41	* <li></li>
45	* </ul>	42	* </ul>
46	*	43	*
Lines 49-56 Link Here
49	*/	46	*/
50	public class ChangeCase extends AbstractFunction {	47	public class ChangeCase extends AbstractFunction {
51		48
52	private static final Pattern NOT_ALPHANUMERIC_REGEX =
53	Pattern.compile("[^a-zA-Z]");
54	private static final Logger LOGGER = LoggerFactory.getLogger(ChangeCase.class);	49	private static final Logger LOGGER = LoggerFactory.getLogger(ChangeCase.class);
55	private static final List<String> DESC = new LinkedList<>();	50	private static final List<String> DESC = new LinkedList<>();
56	private static final String KEY = "__changeCase";	51	private static final String KEY = "__changeCase";
Lines 96-107 Link Here
96	case CAPITALIZE:	91	case CAPITALIZE:
97	targetString = StringUtils.capitalize(originalString);	92	targetString = StringUtils.capitalize(originalString);
98	break;	93	break;
99	case LOWER_CAMEL_CASE:
100	targetString = camel(originalString, false);
101	break;
102	case UPPER_CAMEL_CASE:
103	targetString = camel(originalString, true);
104	break;
105	default:	94	default:
106	// default not doing nothing to string	95	// default not doing nothing to string
107	}	96	}
Lines 126-146 Link Here
126	public List<String> getArgumentDesc() {	115	public List<String> getArgumentDesc() {
127	return DESC;	116	return DESC;
128	}	117	}
129
130	private static String camel(String str, boolean isFirstCapitalized) {
131	StringBuilder builder = new StringBuilder(str.length());
132	String[] tokens = NOT_ALPHANUMERIC_REGEX.split(str);
133	for (int i = 0; i < tokens.length; i++) {
134	String lowerCased = StringUtils.lowerCase(tokens[i]);
135	if(i == 0) {
136	builder.append(isFirstCapitalized ? StringUtils.capitalize(lowerCased):
137	lowerCased);
138	} else {
139	builder.append(StringUtils.capitalize(lowerCased));
140	}
141	}
142	return builder.toString();
143	}
144		118
145	/**	119	/**
146	* ChangeCase Modes	120	* ChangeCase Modes
Lines 149-156 Link Here
149	*	123	*
150	*/	124	*/
151	public enum ChangeCaseMode {	125	public enum ChangeCaseMode {
152	UPPER("UPPER"), LOWER("LOWER"), CAPITALIZE("CAPITALIZE"),	126	UPPER("UPPER"), LOWER("LOWER"), CAPITALIZE("CAPITALIZE");
153	UPPER_CAMEL_CASE("UPPER_CAMEL_CASE"), LOWER_CAMEL_CASE("LOWER_CAMEL_CASE");
154	private String mode;	127	private String mode;
155		128
156	private ChangeCaseMode(String mode) {	129	private ChangeCaseMode(String mode) {

Lines 90-121 Link Here

(-)test/src/org/apache/jmeter/functions/TestChangeCase.java (-21 lines)
90	}	90	}
91		91
92	@Test	92	@Test
93	public void testChangeCaseCamelCase() throws Exception {
94	String returnValue = execute("ab-CD eF", "UPPER_CAMEL_CASE");
95	assertEquals("AbCdEf", returnValue);
96	}
97
98	@Test
99	public void testChangeCaseCapitalize() throws Exception {	93	public void testChangeCaseCapitalize() throws Exception {
100	String returnValue = execute("ab-CD eF", "CAPITALIZE");	94	String returnValue = execute("ab-CD eF", "CAPITALIZE");
101	assertEquals("Ab-CD eF", returnValue);	95	assertEquals("Ab-CD eF", returnValue);
102	}	96	}
103		97
104	@Test
105	public void testChangeCaseCamelCaseFirstLower() throws Exception {
106	String returnValue = execute("ab-CD eF", "LOWER_CAMEL_CASE");
107	assertEquals("abCdEf", returnValue);
108	}
109
110	@Test
111	public void testChangeCaseCamelCaseFirstLowerWithFirstUpperCaseChar() throws Exception {
112	String returnValue = execute("Ab-CD eF", "lower_CAMEL_CASE");
113	assertEquals("abCdEf", returnValue);
114
115	returnValue = execute(" zadad", "lower_CAMEL_CASE");
116	assertEquals("Zadad", returnValue);
117	}
118
119	@Test(expected = InvalidVariableException.class)	98	@Test(expected = InvalidVariableException.class)
120	public void testChangeCaseError() throws Exception {	99	public void testChangeCaseError() throws Exception {
121	changeCase.setParameters(new LinkedList<>());	100	changeCase.setParameters(new LinkedList<>());