Repository: commons-text Updated Branches: refs/heads/master 3e649a798 -> 4b67dd516
http://git-wip-us.apache.org/repos/asf/commons-text/blob/4b67dd51/src/test/java/org/apache/commons/text/StringSubstitutorTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/text/StringSubstitutorTest.java b/src/test/java/org/apache/commons/text/StringSubstitutorTest.java new file mode 100644 index 0000000..6f62fe8 --- /dev/null +++ b/src/test/java/org/apache/commons/text/StringSubstitutorTest.java @@ -0,0 +1,622 @@ +/* + * 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.text; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertTrue; +import java.util.HashMap; +import java.util.Map; +import java.util.Properties; + +import org.apache.commons.lang3.mutable.MutableObject; +import org.apache.commons.text.lookup.StringLookup; +import org.apache.commons.text.lookup.StringLookupFactory; +import org.apache.commons.text.matcher.StringMatcher; +import org.apache.commons.text.matcher.StringMatcherFactory; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +/** + * Test class for {@link StringSubstitutor}. + */ +public class StringSubstitutorTest { + + private Map<String, String> values; + + private void doTestNoReplace(final String replaceTemplate) { + final StringSubstitutor sub = new StringSubstitutor(values); + + if (replaceTemplate == null) { + assertNull(sub.replace((String) null)); + assertNull(sub.replace((String) null, 0, 100)); + assertNull(sub.replace((char[]) null)); + assertNull(sub.replace((char[]) null, 0, 100)); + assertNull(sub.replace((StringBuffer) null)); + assertNull(sub.replace((StringBuffer) null, 0, 100)); + assertNull(sub.replace((StrBuilder) null)); + assertNull(sub.replace((StrBuilder) null, 0, 100)); + assertNull(sub.replace((Object) null)); + assertFalse(sub.replaceIn((StringBuffer) null)); + assertFalse(sub.replaceIn((StringBuffer) null, 0, 100)); + assertFalse(sub.replaceIn((StrBuilder) null)); + assertFalse(sub.replaceIn((StrBuilder) null, 0, 100)); + } else { + assertEquals(replaceTemplate, sub.replace(replaceTemplate)); + final StrBuilder bld = new StrBuilder(replaceTemplate); + assertFalse(sub.replaceIn(bld)); + assertEquals(replaceTemplate, bld.toString()); + } + } + + private void doTestReplace(final String expectedResult, final String replaceTemplate, final boolean substring) { + final StringSubstitutor sub = new StringSubstitutor(values); + doTestReplace(sub, expectedResult, replaceTemplate, substring); + } + + //----------------------------------------------------------------------- + private void doTestReplace(final StringSubstitutor sub, final String expectedResult, final String replaceTemplate, + final boolean substring) { + final String expectedShortResult = expectedResult.substring(1, expectedResult.length() - 1); + + // replace using String + assertEquals(expectedResult, sub.replace(replaceTemplate)); + if (substring) { + assertEquals(expectedShortResult, sub.replace(replaceTemplate, 1, replaceTemplate.length() - 2)); + } + + // replace using char[] + final 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 StringBuilder + StringBuilder builder = new StringBuilder(replaceTemplate); + assertEquals(expectedResult, sub.replace(builder)); + if (substring) { + assertEquals(expectedShortResult, sub.replace(builder, 1, builder.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 + final MutableObject<String> obj = new MutableObject<>(replaceTemplate); // toString returns template + assertEquals(expectedResult, sub.replace(obj)); + + // replace in StringBuffer + buf = new StringBuffer(replaceTemplate); + assertTrue(sub.replaceIn(buf)); + assertEquals(expectedResult, buf.toString()); + if (substring) { + buf = new StringBuffer(replaceTemplate); + assertTrue(sub.replaceIn(buf, 1, buf.length() - 2)); + assertEquals(expectedResult, buf.toString()); // expect full result as remainder is untouched + } + + // replace in StringBuilder + builder = new StringBuilder(replaceTemplate); + assertTrue(sub.replaceIn(builder)); + assertEquals(expectedResult, builder.toString()); + if (substring) { + builder = new StringBuilder(replaceTemplate); + assertTrue(sub.replaceIn(builder, 1, builder.length() - 2)); + assertEquals(expectedResult, builder.toString()); // expect full result as remainder is untouched + } + + // replace in StrBuilder + bld = new StrBuilder(replaceTemplate); + assertTrue(sub.replaceIn(bld)); + assertEquals(expectedResult, bld.toString()); + if (substring) { + bld = new StrBuilder(replaceTemplate); + assertTrue(sub.replaceIn(bld, 1, bld.length() - 2)); + assertEquals(expectedResult, bld.toString()); // expect full result as remainder is untouched + } + } + + @Before + public void setUp() throws Exception { + values = new HashMap<>(); + values.put("animal", "quick brown fox"); + values.put("target", "lazy dog"); + } + + @After + public void tearDown() throws Exception { + values = null; + } + + //----------------------------------------------------------------------- + /** + * Tests get set. + */ + @Test + public void testGetSetEscape() { + final StringSubstitutor sub = new StringSubstitutor(); + assertEquals('$', sub.getEscapeChar()); + sub.setEscapeChar('<'); + assertEquals('<', sub.getEscapeChar()); + } + + /** + * Test for LANG-1055: StringSubstitutor.replaceSystemProperties does not work consistently + */ + @Test + public void testLANG1055() { + System.setProperty("test_key", "test_value"); + + final String expected = StringSubstitutor.replace("test_key=${test_key}", System.getProperties()); + final String actual = StringSubstitutor.replaceSystemProperties("test_key=${test_key}"); + assertEquals(expected, actual); + } + + /** + * Tests adjacent keys. + */ + @Test + public void testReplaceAdjacentAtEnd() { + values.put("code", "GBP"); + values.put("amount", "12.50"); + final StringSubstitutor sub = new StringSubstitutor(values); + assertEquals("Amount is GBP12.50", sub.replace("Amount is ${code}${amount}")); + } + + /** + * Tests adjacent keys. + */ + @Test + public void testReplaceAdjacentAtStart() { + values.put("code", "GBP"); + values.put("amount", "12.50"); + final StringSubstitutor sub = new StringSubstitutor(values); + assertEquals("GBP12.50 charged", sub.replace("${code}${amount} charged")); + } + + /** + * Tests key replace changing map after initialization (not recommended). + */ + @Test + public void testReplaceChangedMap() { + final StringSubstitutor sub = new StringSubstitutor(values); + values.put("target", "moon"); + assertEquals("The quick brown fox jumps over the moon.", + sub.replace("The ${animal} jumps over the ${target}.")); + } + + /** + * Tests complex escaping. + */ + @Test + public void testReplaceComplexEscaping() { + doTestReplace("The ${quick brown fox} jumps over the lazy dog.", + "The $${${animal}} jumps over the ${target}.", true); + doTestReplace("The ${quick brown fox} jumps over the lazy dog. ${1234567890}.", + "The $${${animal}} jumps over the ${target}. $${${undefined.number:-1234567890}}.", true); + } + + /** + * Tests replace with null. + */ + @Test + public void testReplaceEmpty() { + doTestNoReplace(""); + } + + /** + * Tests when no variable name. + */ + @Test + public void testReplaceEmptyKeys() { + doTestReplace("The ${} jumps over the lazy dog.", "The ${} jumps over the ${target}.", true); + doTestReplace("The animal jumps over the lazy dog.", "The ${:-animal} jumps over the ${target}.", true); + } + + /** + * Tests escaping. + */ + @Test + public void testReplaceEscaping() { + doTestReplace("The ${animal} jumps over the lazy dog.", "The $${animal} jumps over the ${target}.", true); + } + + /** + * Tests when no incomplete prefix. + */ + @Test + public void testReplaceIncompletePrefix() { + doTestReplace("The {animal} jumps over the lazy dog.", "The {animal} jumps over the ${target}.", true); + } + + @Test + public void testReplaceInTakingStringBufferWithNonNull() { + final StringSubstitutor strSubstitutor = + new StringSubstitutor(new HashMap<String, String>(), "WV@i#y?N*[", "WV@i#y?N*[", '*'); + + assertFalse(strSubstitutor.isPreserveEscapes()); + assertFalse(strSubstitutor.replaceIn(new StringBuffer("WV@i#y?N*["))); + assertEquals('*', strSubstitutor.getEscapeChar()); + } + + @Test + public void testReplaceInTakingStringBuilderWithNonNull() { + final StringLookup strLookup = StringLookupFactory.INSTANCE.systemPropertyStringLookup(); + final StringSubstitutor strSubstitutor = new StringSubstitutor(strLookup, "b<H", "b<H", '\''); + final StringBuilder stringBuilder = new StringBuilder((CharSequence) "b<H"); + + assertEquals('\'', strSubstitutor.getEscapeChar()); + assertFalse(strSubstitutor.replaceIn(stringBuilder)); + } + + @Test + public void testReplaceInTakingStringBuilderWithNull() { + final Map<String, Object> map = new HashMap<>(); + final StringSubstitutor strSubstitutor = new StringSubstitutor(map, "", "", 'T', "K+<'f"); + + assertFalse(strSubstitutor.replaceIn((StringBuilder) null)); + } + + @Test + public void testReplaceInTakingTwoAndThreeIntsReturningFalse() { + final Map<String, Object> hashMap = new HashMap<>(); + final StringLookup mapStringLookup = StringLookupFactory.INSTANCE.mapStringLookup(hashMap); + final StringMatcher strMatcher = StringMatcherFactory.INSTANCE.tabMatcher(); + final StringSubstitutor strSubstitutor = + new StringSubstitutor(mapStringLookup, strMatcher, strMatcher, 'b', strMatcher); + + assertFalse(strSubstitutor.replaceIn((StringBuilder) null, 1315, (-1369))); + assertEquals('b', strSubstitutor.getEscapeChar()); + assertFalse(strSubstitutor.isPreserveEscapes()); + } + + /** + * Tests whether a variable can be replaced in a variable name. + */ + @Test + public void testReplaceInVariable() { + values.put("animal.1", "fox"); + values.put("animal.2", "mouse"); + values.put("species", "2"); + final StringSubstitutor sub = new StringSubstitutor(values); + sub.setEnableSubstitutionInVariables(true); + assertEquals( + "Wrong result (1)", + "The mouse jumps over the lazy dog.", + sub.replace("The ${animal.${species}} jumps over the ${target}.")); + values.put("species", "1"); + assertEquals( + "Wrong result (2)", + "The fox jumps over the lazy dog.", + sub.replace("The ${animal.${species}} jumps over the ${target}.")); + assertEquals( + "Wrong result (3)", + "The fox jumps over the lazy dog.", + sub.replace("The ${unknown.animal.${unknown.species:-1}:-fox} " + + "jumps over the ${unknow.target:-lazy dog}.")); + } + + /** + * Tests whether substitution in variable names is disabled per default. + */ + @Test + public void testReplaceInVariableDisabled() { + values.put("animal.1", "fox"); + values.put("animal.2", "mouse"); + values.put("species", "2"); + final StringSubstitutor sub = new StringSubstitutor(values); + assertEquals( + "Wrong result (1)", + "The ${animal.${species}} jumps over the lazy dog.", + sub.replace("The ${animal.${species}} jumps over the ${target}.")); + assertEquals( + "Wrong result (2)", + "The ${animal.${species:-1}} jumps over the lazy dog.", + sub.replace("The ${animal.${species:-1}} jumps over the ${target}.")); + } + + /** + * Tests complex and recursive substitution in variable names. + */ + @Test + public void testReplaceInVariableRecursive() { + values.put("animal.2", "brown fox"); + values.put("animal.1", "white mouse"); + values.put("color", "white"); + values.put("species.white", "1"); + values.put("species.brown", "2"); + final StringSubstitutor sub = new StringSubstitutor(values); + sub.setEnableSubstitutionInVariables(true); + assertEquals( + "Wrong result (1)", + "The white mouse jumps over the lazy dog.", + sub.replace("The ${animal.${species.${color}}} jumps over the ${target}.")); + assertEquals( + "Wrong result (2)", + "The brown fox jumps over the lazy dog.", + sub.replace("The ${animal.${species.${unknownColor:-brown}}} jumps over the ${target}.")); + } + + /** + * Tests when no prefix or suffix. + */ + @Test + public void testReplaceNoPrefixNoSuffix() { + doTestReplace("The animal jumps over the lazy dog.", "The animal jumps over the ${target}.", true); + } + + /** + * Tests when suffix but no prefix. + */ + @Test + public void testReplaceNoPrefixSuffix() { + doTestReplace("The animal} jumps over the lazy dog.", "The animal} jumps over the ${target}.", true); + } + + /** + * Tests replace with no variables. + */ + @Test + public void testReplaceNoVariables() { + doTestNoReplace("The balloon arrived."); + } + + /** + * Tests replace with null. + */ + @Test + public void testReplaceNull() { + doTestNoReplace(null); + } + + /** + * Tests simple key replace. + */ + @Test + public void testReplacePartialString_noReplace() { + final StringSubstitutor sub = new StringSubstitutor(); + assertEquals("${animal} jumps", sub.replace("The ${animal} jumps over the ${target}.", 4, 15)); + } + + /** + * Tests when prefix but no suffix. + */ + @Test + public void testReplacePrefixNoSuffix() { + doTestReplace("The ${animal jumps over the ${target} lazy dog.", + "The ${animal jumps over the ${target} ${target}.", true); + } + + /** + * Tests simple recursive replace. + */ + @Test + 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); + + values.put("pet", "${petCharacteristicUnknown:-lazy} dog"); + doTestReplace("The quick brown fox jumps over the lazy dog.", "The ${animal} jumps over the ${target}.", true); + } + + //----------------------------------------------------------------------- + /** + * Tests simple key replace. + */ + @Test + public void testReplaceSimple() { + doTestReplace("The quick brown fox jumps over the lazy dog.", "The ${animal} jumps over the ${target}.", true); + } + + /** + * Tests simple key replace. + */ + @Test + public void testReplaceSolo() { + doTestReplace("quick brown fox", "${animal}", false); + } + + /** + * Tests escaping. + */ + @Test + public void testReplaceSoloEscaping() { + doTestReplace("${animal}", "$${animal}", false); + } + + @Test + public void testReplaceTakingCharSequenceReturningNull() { + final StringSubstitutor strSubstitutor = new StringSubstitutor((StringLookup) null); + + assertNull(strSubstitutor.replace((CharSequence) null)); + assertFalse(strSubstitutor.isPreserveEscapes()); + assertEquals('$', strSubstitutor.getEscapeChar()); + } + + @Test(expected = NullPointerException.class) + public void testReplaceTakingThreeArgumentsThrowsNullPointerException() { + StringSubstitutor.replace(null, (Properties) null); + } + + /** + * Tests replace creates output same as input. + */ + @Test + public void testReplaceToIdentical() { + values.put("animal", "$${${thing}}"); + values.put("thing", "animal"); + doTestReplace("The ${animal} jumps.", "The ${animal} jumps.", true); + } + + /** + * Tests unknown key replace. + */ + @Test + public void testReplaceUnknownKey() { + doTestReplace("The ${person} jumps over the lazy dog.", "The ${person} jumps over the ${target}.", true); + doTestReplace("The ${person} jumps over the lazy dog. 1234567890.", + "The ${person} jumps over the ${target}. ${undefined.number:-1234567890}.", true); + } + + /** + * Tests interpolation with weird boundary patterns. + */ + @Test + public void testReplaceWeirdPattens() { + doTestNoReplace(""); + doTestNoReplace("${}"); + doTestNoReplace("${ }"); + doTestNoReplace("${\t}"); + doTestNoReplace("${\n}"); + doTestNoReplace("${\b}"); + doTestNoReplace("${"); + doTestNoReplace("$}"); + doTestNoReplace("}"); + doTestNoReplace("${}$"); + doTestNoReplace("${${"); + doTestNoReplace("${${}}"); + doTestNoReplace("${$${}}"); + doTestNoReplace("${$$${}}"); + doTestNoReplace("${$$${$}}"); + doTestNoReplace("${${}}"); + doTestNoReplace("${${ }}"); + } + + //----------------------------------------------------------------------- + /** + * Tests protected. + */ + @Test + public void testResolveVariable() { + final StrBuilder builder = new StrBuilder("Hi ${name}!"); + final Map<String, String> map = new HashMap<>(); + map.put("name", "commons"); + final StringSubstitutor sub = new StringSubstitutor(map) { + @Override + protected String resolveVariable(final String variableName, final StrBuilder buf, final int startPos, + final int endPos) { + assertEquals("name", variableName); + assertSame(builder, buf); + assertEquals(3, startPos); + assertEquals(10, endPos); + return "jakarta"; + } + }; + sub.replaceIn(builder); + assertEquals("Hi jakarta!", builder.toString()); + } + + @Test + public void testSamePrefixAndSuffix() { + final Map<String, String> map = new HashMap<>(); + map.put("greeting", "Hello"); + map.put(" there ", "XXX"); + map.put("name", "commons"); + assertEquals("Hi commons!", StringSubstitutor.replace("Hi @name@!", map, "@", "@")); + assertEquals("Hello there commons!", StringSubstitutor.replace("@greeting@ there @name@!", map, "@", "@")); + } + + //----------------------------------------------------------------------- + /** + * Tests static. + */ + @Test + public void testStaticReplace() { + final Map<String, String> map = new HashMap<>(); + map.put("name", "commons"); + assertEquals("Hi commons!", StringSubstitutor.replace("Hi ${name}!", map)); + } + + /** + * Tests static. + */ + @Test + public void testStaticReplacePrefixSuffix() { + final Map<String, String> map = new HashMap<>(); + map.put("name", "commons"); + assertEquals("Hi commons!", StringSubstitutor.replace("Hi <name>!", map, "<", ">")); + } + + /** + * Tests interpolation with system properties. + */ + @Test + public void testStaticReplaceSystemProperties() { + final 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(), StringSubstitutor.replaceSystemProperties("Hi ${user.name}, you are " + + "working with ${os.name}, your home " + + "directory is ${user.home}.")); + } + + /** + * Test the replace of a properties object + */ + @Test + public void testSubstituteDefaultProperties() { + final String org = "${doesnotwork}"; + System.setProperty("doesnotwork", "It works!"); + + // create a new Properties object with the System.getProperties as default + final Properties props = new Properties(System.getProperties()); + + assertEquals("It works!", StringSubstitutor.replace(org, props)); + } + + @Test + public void testSubstitutePreserveEscape() { + final String org = "${not-escaped} $${escaped}"; + final Map<String, String> map = new HashMap<>(); + map.put("not-escaped", "value"); + + final StringSubstitutor sub = new StringSubstitutor(map, "${", "}", '$'); + assertFalse(sub.isPreserveEscapes()); + assertEquals("value ${escaped}", sub.replace(org)); + + sub.setPreserveEscapes(true); + assertTrue(sub.isPreserveEscapes()); + assertEquals("value $${escaped}", sub.replace(org)); + } + +} http://git-wip-us.apache.org/repos/asf/commons-text/blob/4b67dd51/src/test/java/org/apache/commons/text/StringSubstitutorWithInterpolatorStringLookupTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/text/StringSubstitutorWithInterpolatorStringLookupTest.java b/src/test/java/org/apache/commons/text/StringSubstitutorWithInterpolatorStringLookupTest.java new file mode 100644 index 0000000..e8bca78 --- /dev/null +++ b/src/test/java/org/apache/commons/text/StringSubstitutorWithInterpolatorStringLookupTest.java @@ -0,0 +1,49 @@ +/* + * 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.text; + +import java.util.HashMap; +import java.util.Map; + +import org.apache.commons.text.lookup.StringLookupFactory; +import org.junit.Assert; +import org.junit.Test; + +public class StringSubstitutorWithInterpolatorStringLookupTest { + + @Test + public void testMapAndSystemProperty() { + final String key = "key"; + final String value = "value"; + final Map<String, String> map = new HashMap<>(); + map.put(key, value); + final StringSubstitutor strSubst = new StringSubstitutor( + StringLookupFactory.INSTANCE.interpolatorStringLookup(map)); + final String spKey = "user.name"; + Assert.assertEquals(System.getProperty(spKey), strSubst.replace("${sys:" + spKey + "}")); + Assert.assertEquals(value, strSubst.replace("${" + key + "}")); + } + + @Test + public void testSystemProperty() { + final StringSubstitutor strSubst = new StringSubstitutor( + StringLookupFactory.INSTANCE.interpolatorStringLookup()); + final String spKey = "user.name"; + Assert.assertEquals(System.getProperty(spKey), strSubst.replace("${sys:" + spKey + "}")); + } +} http://git-wip-us.apache.org/repos/asf/commons-text/blob/4b67dd51/src/test/java/org/apache/commons/text/matcher/StringMatcherTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/text/matcher/StringMatcherTest.java b/src/test/java/org/apache/commons/text/matcher/StringMatcherTest.java new file mode 100644 index 0000000..6dcd792 --- /dev/null +++ b/src/test/java/org/apache/commons/text/matcher/StringMatcherTest.java @@ -0,0 +1,219 @@ +/* + * 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.text.matcher; + +import static org.assertj.core.api.Assertions.assertThat; + +import org.junit.Test; + +/** + * Unit tests for {@link StringMatcher}. + */ +public class StringMatcherTest { + + private static final char[] BUFFER1 = "0,1\t2 3\n\r\f\u0000'\"".toCharArray(); + + private static final char[] BUFFER2 = "abcdef".toCharArray(); + + // ----------------------------------------------------------------------- + @Test + public void testCommaMatcher() { + final StringMatcher matcher = StringMatcherFactory.INSTANCE.commaMatcher(); + assertThat(StringMatcherFactory.INSTANCE.commaMatcher()).isSameAs(matcher); + assertThat(matcher.isMatch(BUFFER1, 0, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 1, 0, BUFFER1.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER1, 2, 0, BUFFER1.length)).isEqualTo(0); + } + + // ----------------------------------------------------------------------- + @Test + public void testTabMatcher() { + final StringMatcher matcher = StringMatcherFactory.INSTANCE.tabMatcher(); + assertThat(StringMatcherFactory.INSTANCE.tabMatcher()).isSameAs(matcher); + assertThat(matcher.isMatch(BUFFER1, 2, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 3, 0, BUFFER1.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER1, 4, 0, BUFFER1.length)).isEqualTo(0); + } + + // ----------------------------------------------------------------------- + @Test + public void testSpaceMatcher() { + final StringMatcher matcher = StringMatcherFactory.INSTANCE.spaceMatcher(); + assertThat(StringMatcherFactory.INSTANCE.spaceMatcher()).isSameAs(matcher); + assertThat(matcher.isMatch(BUFFER1, 4, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 5, 0, BUFFER1.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER1, 6, 0, BUFFER1.length)).isEqualTo(0); + } + + // ----------------------------------------------------------------------- + @Test + public void testSplitMatcher() { + final StringMatcher matcher = StringMatcherFactory.INSTANCE.splitMatcher(); + assertThat(StringMatcherFactory.INSTANCE.splitMatcher()).isSameAs(matcher); + assertThat(matcher.isMatch(BUFFER1, 2, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 3, 0, BUFFER1.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER1, 4, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 5, 0, BUFFER1.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER1, 6, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 7, 0, BUFFER1.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER1, 8, 0, BUFFER1.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER1, 9, 0, BUFFER1.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER1, 10, 0, BUFFER1.length)).isEqualTo(0); + } + + // ----------------------------------------------------------------------- + @Test + public void testTrimMatcher() { + final StringMatcher matcher = StringMatcherFactory.INSTANCE.trimMatcher(); + assertThat(StringMatcherFactory.INSTANCE.trimMatcher()).isSameAs(matcher); + assertThat(matcher.isMatch(BUFFER1, 2, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 3, 0, BUFFER1.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER1, 4, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 5, 0, BUFFER1.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER1, 6, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 7, 0, BUFFER1.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER1, 8, 0, BUFFER1.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER1, 9, 0, BUFFER1.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER1, 10, 0, BUFFER1.length)).isEqualTo(1); + } + + // ----------------------------------------------------------------------- + @Test + public void testSingleQuoteMatcher() { + final StringMatcher matcher = StringMatcherFactory.INSTANCE.singleQuoteMatcher(); + assertThat(StringMatcherFactory.INSTANCE.singleQuoteMatcher()).isSameAs(matcher); + assertThat(matcher.isMatch(BUFFER1, 10, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 11, 0, BUFFER1.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER1, 12, 0, BUFFER1.length)).isEqualTo(0); + } + + // ----------------------------------------------------------------------- + @Test + public void testDoubleQuoteMatcher() { + final StringMatcher matcher = StringMatcherFactory.INSTANCE.doubleQuoteMatcher(); + assertThat(StringMatcherFactory.INSTANCE.doubleQuoteMatcher()).isSameAs(matcher); + assertThat(matcher.isMatch(BUFFER1, 11, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 12, 0, BUFFER1.length)).isEqualTo(1); + } + + // ----------------------------------------------------------------------- + @Test + public void testQuoteMatcher() { + final StringMatcher matcher = StringMatcherFactory.INSTANCE.quoteMatcher(); + assertThat(StringMatcherFactory.INSTANCE.quoteMatcher()).isSameAs(matcher); + assertThat(matcher.isMatch(BUFFER1, 10, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 11, 0, BUFFER1.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER1, 12, 0, BUFFER1.length)).isEqualTo(1); + } + + // ----------------------------------------------------------------------- + @Test + public void testNoneMatcher() { + final StringMatcher matcher = StringMatcherFactory.INSTANCE.noneMatcher(); + assertThat(StringMatcherFactory.INSTANCE.noneMatcher()).isSameAs(matcher); + assertThat(matcher.isMatch(BUFFER1, 0, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 1, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 2, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 3, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 4, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 5, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 6, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 7, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 8, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 9, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 10, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 11, 0, BUFFER1.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER1, 12, 0, BUFFER1.length)).isEqualTo(0); + } + + // ----------------------------------------------------------------------- + @Test + public void testCharMatcher_char() { + final StringMatcher matcher = StringMatcherFactory.INSTANCE.charMatcher('c'); + assertThat(matcher.isMatch(BUFFER2, 0, 0, BUFFER2.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER2, 1, 0, BUFFER2.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER2, 2, 0, BUFFER2.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER2, 3, 0, BUFFER2.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER2, 4, 0, BUFFER2.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER2, 5, 0, BUFFER2.length)).isEqualTo(0); + } + + // ----------------------------------------------------------------------- + @Test + public void testCharSetMatcher_String() { + final StringMatcher matcher = StringMatcherFactory.INSTANCE.charSetMatcher("ace"); + assertThat(matcher.isMatch(BUFFER2, 0, 0, BUFFER2.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER2, 1, 0, BUFFER2.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER2, 2, 0, BUFFER2.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER2, 3, 0, BUFFER2.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER2, 4, 0, BUFFER2.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER2, 5, 0, BUFFER2.length)).isEqualTo(0); + assertThat(StringMatcherFactory.INSTANCE.charSetMatcher("")) + .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher()); + assertThat(StringMatcherFactory.INSTANCE.charSetMatcher((String) null)) + .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher()); + assertThat(StringMatcherFactory.INSTANCE.charSetMatcher("a") instanceof AbstractStringMatcher.CharMatcher) + .isTrue(); + } + + // ----------------------------------------------------------------------- + @Test + public void testCharSetMatcher_charArray() { + final StringMatcher matcher = StringMatcherFactory.INSTANCE.charSetMatcher("ace".toCharArray()); + assertThat(matcher.isMatch(BUFFER2, 0, 0, BUFFER2.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER2, 1, 0, BUFFER2.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER2, 2, 0, BUFFER2.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER2, 3, 0, BUFFER2.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER2, 4, 0, BUFFER2.length)).isEqualTo(1); + assertThat(matcher.isMatch(BUFFER2, 5, 0, BUFFER2.length)).isEqualTo(0); + assertThat(StringMatcherFactory.INSTANCE.charSetMatcher(new char[0])) + .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher()); + assertThat(StringMatcherFactory.INSTANCE.charSetMatcher((char[]) null)) + .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher()); + assertThat(StringMatcherFactory.INSTANCE + .charSetMatcher("a".toCharArray()) instanceof AbstractStringMatcher.CharMatcher).isTrue(); + } + + // ----------------------------------------------------------------------- + @Test + public void testStringMatcher_String() { + final StringMatcher matcher = StringMatcherFactory.INSTANCE.stringMatcher("bc"); + assertThat(matcher.isMatch(BUFFER2, 0, 0, BUFFER2.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER2, 1, 0, BUFFER2.length)).isEqualTo(2); + assertThat(matcher.isMatch(BUFFER2, 2, 0, BUFFER2.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER2, 3, 0, BUFFER2.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER2, 4, 0, BUFFER2.length)).isEqualTo(0); + assertThat(matcher.isMatch(BUFFER2, 5, 0, BUFFER2.length)).isEqualTo(0); + assertThat(StringMatcherFactory.INSTANCE.stringMatcher("")) + .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher()); + assertThat(StringMatcherFactory.INSTANCE.stringMatcher((String) null)) + .isSameAs(StringMatcherFactory.INSTANCE.noneMatcher()); + } + + // ----------------------------------------------------------------------- + @Test + public void testMatcherIndices() { + // remember that the API contract is tight for the isMatch() method + // all the onus is on the caller, so invalid inputs are not + // the concern of StringMatcher, and are not bugs + final StringMatcher matcher = StringMatcherFactory.INSTANCE.stringMatcher("bc"); + assertThat(matcher.isMatch(BUFFER2, 1, 1, BUFFER2.length)).isEqualTo(2); + assertThat(matcher.isMatch(BUFFER2, 1, 0, 3)).isEqualTo(2); + assertThat(matcher.isMatch(BUFFER2, 1, 0, 2)).isEqualTo(0); + } + +} http://git-wip-us.apache.org/repos/asf/commons-text/blob/4b67dd51/src/test/java/org/apache/commons/text/matcher/StringSubstitutorGetSetTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/text/matcher/StringSubstitutorGetSetTest.java b/src/test/java/org/apache/commons/text/matcher/StringSubstitutorGetSetTest.java new file mode 100644 index 0000000..733c853 --- /dev/null +++ b/src/test/java/org/apache/commons/text/matcher/StringSubstitutorGetSetTest.java @@ -0,0 +1,119 @@ +/* + * 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.text.matcher; + +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import org.apache.commons.text.StringSubstitutor; +import org.junit.Test; + +/** + * Test class for {@link StringSubstitutor}. + */ +public class StringSubstitutorGetSetTest { + + /** + * Tests get set. + */ + @Test + public void testGetSetPrefix() { + final StringSubstitutor sub = new StringSubstitutor(); + assertTrue(sub.getVariablePrefixMatcher() instanceof AbstractStringMatcher.StringMatcher); + sub.setVariablePrefix('<'); + assertTrue(sub.getVariablePrefixMatcher() instanceof AbstractStringMatcher.CharMatcher); + + sub.setVariablePrefix("<<"); + assertTrue(sub.getVariablePrefixMatcher() instanceof AbstractStringMatcher.StringMatcher); + try { + sub.setVariablePrefix((String) null); + fail(); + } catch (final IllegalArgumentException ex) { + // expected + } + assertTrue(sub.getVariablePrefixMatcher() instanceof AbstractStringMatcher.StringMatcher); + + final StringMatcher matcher = StringMatcherFactory.INSTANCE.commaMatcher(); + sub.setVariablePrefixMatcher(matcher); + assertSame(matcher, sub.getVariablePrefixMatcher()); + try { + sub.setVariablePrefixMatcher((StringMatcher) null); + fail(); + } catch (final IllegalArgumentException ex) { + // expected + } + assertSame(matcher, sub.getVariablePrefixMatcher()); + } + + /** + * Tests get set. + */ + @Test + public void testGetSetSuffix() { + final StringSubstitutor sub = new StringSubstitutor(); + assertTrue(sub.getVariableSuffixMatcher() instanceof AbstractStringMatcher.StringMatcher); + sub.setVariableSuffix('<'); + assertTrue(sub.getVariableSuffixMatcher() instanceof AbstractStringMatcher.CharMatcher); + + sub.setVariableSuffix("<<"); + assertTrue(sub.getVariableSuffixMatcher() instanceof AbstractStringMatcher.StringMatcher); + try { + sub.setVariableSuffix((String) null); + fail(); + } catch (final IllegalArgumentException ex) { + // expected + } + assertTrue(sub.getVariableSuffixMatcher() instanceof AbstractStringMatcher.StringMatcher); + + final StringMatcher matcher = StringMatcherFactory.INSTANCE.commaMatcher(); + sub.setVariableSuffixMatcher(matcher); + assertSame(matcher, sub.getVariableSuffixMatcher()); + try { + sub.setVariableSuffixMatcher((StringMatcher) null); + fail(); + } catch (final IllegalArgumentException ex) { + // expected + } + assertSame(matcher, sub.getVariableSuffixMatcher()); + } + + /** + * Tests get set. + */ + @Test + public void testGetSetValueDelimiter() { + final StringSubstitutor sub = new StringSubstitutor(); + assertTrue(sub.getValueDelimiterMatcher() instanceof AbstractStringMatcher.StringMatcher); + sub.setValueDelimiter(':'); + assertTrue(sub.getValueDelimiterMatcher() instanceof AbstractStringMatcher.CharMatcher); + + sub.setValueDelimiter("||"); + assertTrue(sub.getValueDelimiterMatcher() instanceof AbstractStringMatcher.StringMatcher); + sub.setValueDelimiter((String) null); + assertNull(sub.getValueDelimiterMatcher()); + + final StringMatcher matcher = StringMatcherFactory.INSTANCE.commaMatcher(); + sub.setValueDelimiterMatcher(matcher); + assertSame(matcher, sub.getValueDelimiterMatcher()); + sub.setValueDelimiterMatcher((StringMatcher) null); + assertNull(sub.getValueDelimiterMatcher()); + } + +}
