/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.lang.text;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.lang.mutable.MutableObject;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import junit.textui.TestRunner;
/**
* Test class for StrSubstitutor.
*
* @author Oliver Heger
* @version $Id: StrSubstitutorTest.java 437554 2006-08-28 06:21:41Z bayard $
*/
public class StrSubstitutorTest extends TestCase {
private Map values;
/**
* Main method.
*
* @param args command line arguments, ignored
*/
public static void main(String[] args) {
TestRunner.run(suite());
}
/**
* Return a new test suite containing this test case.
*
* @return a new test suite containing this test case
*/
public static Test suite() {
TestSuite suite = new TestSuite(StrSubstitutorTest.class);
suite.setName("StrSubstitutor Tests");
return suite;
}
protected void setUp() throws Exception {
super.setUp();
values = new HashMap();
values.put("animal", "quick brown fox");
values.put("target", "lazy dog");
}
protected void tearDown() throws Exception {
super.tearDown();
values = null;
}
//-----------------------------------------------------------------------
/**
* Tests simple key replace.
*/
public void testReplaceSimple() {
doTestReplace("The quick brown fox jumps over the lazy dog.", "The ${animal} jumps over the ${target}.", true);
}
/**
* Tests simple key replace.
*/
public void testReplaceSolo() {
doTestReplace("quick brown fox", "${animal}", false);
}
/**
* Tests replace with no variables.
*/
public void testReplaceNoVariables() {
doTestNoReplace("The balloon arrived.");
}
/**
* Tests replace with null.
*/
public void testReplaceNull() {
doTestNoReplace(null);
}
/**
* Tests replace with null.
*/
public void testReplaceEmpty() {
doTestNoReplace("");
}
/**
* Tests key replace changing map after initialization (not recommended).
*/
public void testReplaceChangedMap() {
StrSubstitutor sub = new StrSubstitutor(values);
values.put("target", "moon");
assertEquals("The quick brown fox jumps over the moon.", sub.replace("The ${animal} jumps over the ${target}."));
}
/**
* Tests unknown key replace.
*/
public void testReplaceUnknownKey() {
doTestReplace("The ${person} jumps over the lazy dog.", "The ${person} jumps over the ${target}.", true);
}
/**
* Tests adjacent keys.
*/
public void testReplaceAdjacentAtStart() {
values.put("code", "GBP");
values.put("amount", "12.50");
StrSubstitutor sub = new StrSubstitutor(values);
assertEquals("GBP12.50 charged", sub.replace("${code}${amount} charged"));
}
/**
* Tests adjacent keys.
*/
public void testReplaceAdjacentAtEnd() {
values.put("code", "GBP");
values.put("amount", "12.50");
StrSubstitutor sub = new StrSubstitutor(values);
assertEquals("Amount is GBP12.50", sub.replace("Amount is ${code}${amount}"));
}
/**
* Tests simple recursive replace.
*/
public void testReplaceRecursive() {
values.put("animal", "${critter}");
values.put("target", "${pet}");
values.put("pet", "${petCharacteristic} dog");
values.put("petCharacteristic", "lazy");
values.put("critter", "${critterSpeed} ${critterColor} ${critterType}");
values.put("critterSpeed", "quick");
values.put("critterColor", "brown");
values.put("critterType", "fox");
doTestReplace("The quick brown fox jumps over the lazy dog.", "The ${animal} jumps over the ${target}.", true);
}
/**
* Tests escaping.
*/
public void testReplaceEscaping() {
doTestReplace("The ${animal} jumps over the lazy dog.", "The $${animal} jumps over the ${target}.", true);
}
/**
* Tests escaping.
*/
public void testReplaceSoloEscaping() {
doTestReplace("${animal}", "$${animal}", false);
}
/**
* Tests complex escaping.
*/
public void testReplaceComplexEscaping() {
doTestReplace("The ${quick brown fox} jumps over the lazy dog.", "The $${${animal}} jumps over the ${target}.", true);
}
/**
* Tests when no prefix or suffix.
*/
public void testReplaceNoPefixNoSuffix() {
doTestReplace("The animal jumps over the lazy dog.", "The animal jumps over the ${target}.", true);
}
/**
* Tests when no incomplete prefix.
*/
public void testReplaceIncompletePefix() {
doTestReplace("The {animal} jumps over the lazy dog.", "The {animal} jumps over the ${target}.", true);
}
/**
* Tests when prefix but no suffix.
*/
public void testReplacePrefixNoSuffix() {
doTestReplace("The ${animal jumps over the ${target} lazy dog.", "The ${animal jumps over the ${target} ${target}.", true);
}
/**
* Tests when suffix but no prefix.
*/
public void testReplaceNoPrefixSuffix() {
doTestReplace("The animal} jumps over the lazy dog.", "The animal} jumps over the ${target}.", true);
}
/**
* Tests when no variable name.
*/
public void testReplaceEmptyKeys() {
doTestReplace("The ${} jumps over the lazy dog.", "The ${} jumps over the ${target}.", true);
}
/**
* Tests replace creates output same as input.
*/
public void testReplaceToIdentical() {
values.put("animal", "$${${thing}}");
values.put("thing", "animal");
doTestReplace("The ${animal} jumps.", "The ${animal} jumps.", true);
}
/**
* Tests a cyclic replace operation.
* The cycle should be detected and cause an exception to be thrown.
*/
public void testCyclicReplacement() {
Map map = new HashMap();
map.put("animal", "${critter}");
map.put("target", "${pet}");
map.put("pet", "${petCharacteristic} dog");
map.put("petCharacteristic", "lazy");
map.put("critter", "${critterSpeed} ${critterColor} ${critterType}");
map.put("critterSpeed", "quick");
map.put("critterColor", "brown");
map.put("critterType", "${animal}");
StrSubstitutor sub = new StrSubstitutor(map);
try {
sub.replace("The ${animal} jumps over the ${target}.");
fail("Cyclic replacement was not detected!");
} catch (IllegalStateException ex) {
// expected
}
}
/**
* Tests interpolation with weird boundary patterns.
*/
public void testReplaceWeirdPattens() {
doTestNoReplace("");
doTestNoReplace("${}");
doTestNoReplace("${ }");
doTestNoReplace("${\t}");
doTestNoReplace("${\n}");
doTestNoReplace("${\b}");
doTestNoReplace("${");
doTestNoReplace("$}");
doTestNoReplace("}");
doTestNoReplace("${}$");
doTestNoReplace("${${");
doTestNoReplace("${${}}");
doTestNoReplace("${$${}}");
doTestNoReplace("${$$${}}");
doTestNoReplace("${$$${$}}");
doTestNoReplace("${${}}");
doTestNoReplace("${${ }}");
}
/**
* Tests simple key replace.
*/
public void testReplacePartialString_noReplace() {
StrSubstitutor sub = new StrSubstitutor();
assertEquals("${animal} jumps", sub.replace("The ${animal} jumps over the ${target}.", 4, 15));
}
//-----------------------------------------------------------------------
/**
* Tests protected.
*/
public void testResolveVariable() {
final StrBuilder builder = new StrBuilder("Hi ${name}!");
Map map = new HashMap();
map.put("name", "commons");
StrSubstitutor sub = new StrSubstitutor(map) {
protected String resolveVariable(String variableName, StrBuilder buf, int startPos, int endPos) {
assertEquals("name", variableName);
assertSame(builder, buf);
assertEquals(3, startPos);
assertEquals(10, endPos);
return "jakarta";
}
};
sub.replaceIn(builder);
assertEquals("Hi jakarta!", builder.toString());
}
//-----------------------------------------------------------------------
/**
* Tests constructor.
*/
public void testConstructorNoArgs() {
StrSubstitutor sub = new StrSubstitutor();
assertEquals("Hi ${name}", sub.replace("Hi ${name}"));
}
/**
* Tests constructor.
*/
public void testConstructorMapPrefixSuffix() {
Map map = new HashMap();
map.put("name", "commons");
StrSubstitutor sub = new StrSubstitutor(map, "<", ">");
assertEquals("Hi < commons", sub.replace("Hi $< <name>"));
}
/**
* Tests constructor.
*/
public void testConstructorMapFull() {
Map map = new HashMap();
map.put("name", "commons");
StrSubstitutor sub = new StrSubstitutor(map, "<", ">", '!');
assertEquals("Hi < commons", sub.replace("Hi !< <name>"));
}
//-----------------------------------------------------------------------
/**
* Tests get set.
*/
public void testGetSetEscape() {
StrSubstitutor sub = new StrSubstitutor();
assertEquals('$', sub.getEscapeChar());
sub.setEscapeChar('<');
assertEquals('<', sub.getEscapeChar());
}
/**
* Tests get set.
*/
public void testGetSetPrefix() {
StrSubstitutor sub = new StrSubstitutor();
assertEquals(true, sub.getVariablePrefixMatcher() instanceof StrMatcher.StringMatcher);
sub.setVariablePrefix('<');
assertEquals(true, sub.getVariablePrefixMatcher() instanceof StrMatcher.CharMatcher);
sub.setVariablePrefix("<<");
assertEquals(true, sub.getVariablePrefixMatcher() instanceof StrMatcher.StringMatcher);
try {
sub.setVariablePrefix((String) null);
fail();
} catch (IllegalArgumentException ex) {
// expected
}
assertEquals(true, sub.getVariablePrefixMatcher() instanceof StrMatcher.StringMatcher);
StrMatcher matcher = StrMatcher.commaMatcher();
sub.setVariablePrefixMatcher(matcher);
assertSame(matcher, sub.getVariablePrefixMatcher());
try {
sub.setVariablePrefixMatcher((StrMatcher) null);
fail();
} catch (IllegalArgumentException ex) {
// expected
}
assertSame(matcher, sub.getVariablePrefixMatcher());
}
/**
* Tests get set.
*/
public void testGetSetSuffix() {
StrSubstitutor sub = new StrSubstitutor();
assertEquals(true, sub.getVariableSuffixMatcher() instanceof StrMatcher.StringMatcher);
sub.setVariableSuffix('<');
assertEquals(true, sub.getVariableSuffixMatcher() instanceof StrMatcher.CharMatcher);
sub.setVariableSuffix("<<");
assertEquals(true, sub.getVariableSuffixMatcher() instanceof StrMatcher.StringMatcher);
try {
sub.setVariableSuffix((String) null);
fail();
} catch (IllegalArgumentException ex) {
// expected
}
assertEquals(true, sub.getVariableSuffixMatcher() instanceof StrMatcher.StringMatcher);
StrMatcher matcher = StrMatcher.commaMatcher();
sub.setVariableSuffixMatcher(matcher);
assertSame(matcher, sub.getVariableSuffixMatcher());
try {
sub.setVariableSuffixMatcher((StrMatcher) null);
fail();
} catch (IllegalArgumentException ex) {
// expected
}
assertSame(matcher, sub.getVariableSuffixMatcher());
}
//-----------------------------------------------------------------------
/**
* Tests static.
*/
public void testStaticReplace() {
Map map = new HashMap();
map.put("name", "commons");
assertEquals("Hi commons!", StrSubstitutor.replace("Hi ${name}!", map));
}
/**
* Tests static.
*/
public void testStaticReplacePrefixSuffix() {
Map map = new HashMap();
map.put("name", "commons");
assertEquals("Hi commons!", StrSubstitutor.replace("Hi <name>!", map, "<", ">"));
}
/**
* Tests interpolation with system properties.
*/
public void testStaticReplaceSystemProperties() {
StrBuilder buf = new StrBuilder();
buf.append("Hi ").append(System.getProperty("user.name"));
buf.append(", you are working with ");
buf.append(System.getProperty("os.name"));
buf.append(", your home directory is ");
buf.append(System.getProperty("user.home")).append('.');
assertEquals(buf.toString(), StrSubstitutor.replaceSystemProperties("Hi ${user.name}, you are "
+ "working with ${os.name}, your home "
+ "directory is ${user.home}."));
}
//-----------------------------------------------------------------------
private void doTestReplace(String expectedResult, String replaceTemplate, boolean substring) {
String expectedShortResult = expectedResult.substring(1, expectedResult.length() - 1);
StrSubstitutor sub = new StrSubstitutor(values);
// replace using String
assertEquals(expectedResult, sub.replace(replaceTemplate));
if (substring) {
assertEquals(expectedShortResult, sub.replace(replaceTemplate, 1, replaceTemplate.length() - 2));
}
// replace using char[]
char[] chars = replaceTemplate.toCharArray();
assertEquals(expectedResult, sub.replace(chars));
if (substring) {
assertEquals(expectedShortResult, sub.replace(chars, 1, chars.length - 2));
}
// replace using StringBuffer
StringBuffer buf = new StringBuffer(replaceTemplate);
assertEquals(expectedResult, sub.replace(buf));
if (substring) {
assertEquals(expectedShortResult, sub.replace(buf, 1, buf.length() - 2));
}
// replace using StrBuilder
StrBuilder bld = new StrBuilder(replaceTemplate);
assertEquals(expectedResult, sub.replace(bld));
if (substring) {
assertEquals(expectedShortResult, sub.replace(bld, 1, bld.length() - 2));
}
// replace using object
MutableObject obj = new MutableObject(replaceTemplate); // toString returns template
assertEquals(expectedResult, sub.replace(obj));
// replace in StringBuffer
buf = new StringBuffer(replaceTemplate);
assertEquals(true, sub.replaceIn(buf));
assertEquals(expectedResult, buf.toString());
if (substring) {
buf = new StringBuffer(replaceTemplate);
assertEquals(true, sub.replaceIn(buf, 1, buf.length() - 2));
assertEquals(expectedResult, buf.toString()); // expect full result as remainder is untouched
}
// replace in StrBuilder
bld = new StrBuilder(replaceTemplate);
assertEquals(true, sub.replaceIn(bld));
assertEquals(expectedResult, bld.toString());
if (substring) {
bld = new StrBuilder(replaceTemplate);
assertEquals(true, sub.replaceIn(bld, 1, bld.length() - 2));
assertEquals(expectedResult, bld.toString()); // expect full result as remainder is untouched
}
}
private void doTestNoReplace(String replaceTemplate) {
StrSubstitutor sub = new StrSubstitutor(values);
if (replaceTemplate == null) {
assertEquals(null, sub.replace((String) null));
assertEquals(null, sub.replace((String) null, 0, 100));
assertEquals(null, sub.replace((char[]) null));
assertEquals(null, sub.replace((char[]) null, 0, 100));
assertEquals(null, sub.replace((StringBuffer) null));
assertEquals(null, sub.replace((StringBuffer) null, 0, 100));
assertEquals(null, sub.replace((StrBuilder) null));
assertEquals(null, sub.replace((StrBuilder) null, 0, 100));
assertEquals(null, sub.replace((Object) null));
assertEquals(false, sub.replaceIn((StringBuffer) null));
assertEquals(false, sub.replaceIn((StringBuffer) null, 0, 100));
assertEquals(false, sub.replaceIn((StrBuilder) null));
assertEquals(false, sub.replaceIn((StrBuilder) null, 0, 100));
} else {
assertEquals(replaceTemplate, sub.replace(replaceTemplate));
StrBuilder bld = new StrBuilder(replaceTemplate);
assertEquals(false, sub.replaceIn(bld));
assertEquals(replaceTemplate, bld.toString());
}
}
}