/*
    * 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
    *
    *      https://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.lang3.text;
  
  import static org.apache.commons.lang3.LangAssertions.assertNullPointerException;
  import static org.junit.jupiter.api.Assertions.assertEquals;
  import static org.junit.jupiter.api.Assertions.assertFalse;
  import static org.junit.jupiter.api.Assertions.assertInstanceOf;
  import static org.junit.jupiter.api.Assertions.assertNull;
  import static org.junit.jupiter.api.Assertions.assertSame;
  import static org.junit.jupiter.api.Assertions.assertThrows;
  import static org.junit.jupiter.api.Assertions.assertTrue;
  
  import java.util.HashMap;
  import java.util.Map;
  import java.util.Properties;
  
  import org.apache.commons.lang3.AbstractLangTest;
  import org.apache.commons.lang3.SystemProperties;
  import org.apache.commons.lang3.mutable.MutableObject;
  import org.junit.jupiter.api.AfterEach;
  import org.junit.jupiter.api.BeforeEach;
  import org.junit.jupiter.api.Test;
  
  /**
   * Test class for StrSubstitutor.
   */
  @Deprecated
  class StrSubstitutorTest extends AbstractLangTest {
  
      private Map<String, String> values;
  
      private void doTestNoReplace(final String replaceTemplate) {
          final StrSubstitutor sub = new StrSubstitutor(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 String expectedShortResult = expectedResult.substring(1, expectedResult.length() - 1);
          final 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[]
          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
         }
     }
 
     @BeforeEach
     public void setUp() {
         values = new HashMap<>();
         values.put("animal", "quick brown fox");
         values.put("target", "lazy dog");
     }
 
     @AfterEach
     public void tearDown() {
         values = null;
     }
 
     /**
      * Tests constructor.
      */
     @Test
     void testConstructorMapFull() {
         final Map<String, String> map = new HashMap<>();
         map.put("name", "commons");
         StrSubstitutor sub = new StrSubstitutor(map, "<", ">", '!');
         assertEquals("Hi < commons", sub.replace("Hi !< <name>"));
         sub = new StrSubstitutor(map, "<", ">", '!', "||");
         assertEquals("Hi < commons", sub.replace("Hi !< <name2||commons>"));
     }
 
     /**
      * Tests constructor.
      */
     @Test
     void testConstructorMapPrefixSuffix() {
         final Map<String, String> map = new HashMap<>();
         map.put("name", "commons");
         final StrSubstitutor sub = new StrSubstitutor(map, "<", ">");
         assertEquals("Hi < commons", sub.replace("Hi $< <name>"));
     }
 
     /**
      * Tests constructor.
      */
     @Test
     void testConstructorNoArgs() {
         final StrSubstitutor sub = new StrSubstitutor();
         assertEquals("Hi ${name}", sub.replace("Hi ${name}"));
     }
 
     /**
      * Tests a cyclic replace operation.
      * The cycle should be detected and cause an exception to be thrown.
      */
     @Test
     void testCyclicReplacement() {
         final Map<String, String> 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}");
         final StrSubstitutor sub = new StrSubstitutor(map);
         assertThrows(IllegalStateException.class, () -> sub.replace("The ${animal} jumps over the ${target}."), "Cyclic replacement was not detected.");
         // also check even when default value is set.
         map.put("critterType", "${animal:-fox}");
         final StrSubstitutor sub2 = new StrSubstitutor(map);
         assertThrows(IllegalStateException.class, () -> sub2.replace("The ${animal} jumps over the ${target}."), "Cyclic replacement was not detected.");
     }
 
     /**
      * Tests that deeply nested (acyclic) variable references hit the depth budget with an
      * {@link IllegalStateException} instead of recursing towards {@link StackOverflowError}.
      */
     @Test
     void testDeeplyNestedReplacementThrowsIllegalStateException() {
         final Map<String, String> map = new HashMap<>();
         for (int i = 0; i < 400; i++) {
             map.put("v" + i, "${v" + (i + 1) + "}");
         }
         map.put("v400", "x");
         final StrSubstitutor sub = new StrSubstitutor(map);
         assertThrows(IllegalStateException.class, () -> sub.replace("${v0}"), "Depth budget was not enforced.");
         // shallow nesting still works, including after a budget-exceeded failure (counters reset per top-level call)
         assertEquals("x", sub.replace("${v398}"));
     }
 
     @Test
     void testDefaultValueDelimiters() {
         final Map<String, String> map = new HashMap<>();
         map.put("animal", "fox");
         map.put("target", "dog");
 
         StrSubstitutor sub = new StrSubstitutor(map, "${", "}", '$');
         assertEquals("The fox jumps over the lazy dog. 1234567890.",
                 sub.replace("The ${animal} jumps over the lazy ${target}. ${undefined.number:-1234567890}."));
 
         sub = new StrSubstitutor(map, "${", "}", '$', "?:");
         assertEquals("The fox jumps over the lazy dog. 1234567890.",
                 sub.replace("The ${animal} jumps over the lazy ${target}. ${undefined.number?:1234567890}."));
 
         sub = new StrSubstitutor(map, "${", "}", '$', "||");
         assertEquals("The fox jumps over the lazy dog. 1234567890.",
                 sub.replace("The ${animal} jumps over the lazy ${target}. ${undefined.number||1234567890}."));
 
         sub = new StrSubstitutor(map, "${", "}", '$', "!");
         assertEquals("The fox jumps over the lazy dog. 1234567890.",
                 sub.replace("The ${animal} jumps over the lazy ${target}. ${undefined.number!1234567890}."));
 
         sub = new StrSubstitutor(map, "${", "}", '$', "");
         sub.setValueDelimiterMatcher(null);
         assertEquals("The fox jumps over the lazy dog. ${undefined.number!1234567890}.",
                 sub.replace("The ${animal} jumps over the lazy ${target}. ${undefined.number!1234567890}."));
 
         sub = new StrSubstitutor(map, "${", "}", '$');
         sub.setValueDelimiterMatcher(null);
         assertEquals("The fox jumps over the lazy dog. ${undefined.number!1234567890}.",
                 sub.replace("The ${animal} jumps over the lazy ${target}. ${undefined.number!1234567890}."));
     }
 
     /**
      * Tests that exponential acyclic fan-out (each variable expanding to many more) hits the
      * total-output-size budget with an {@link IllegalStateException} instead of consuming
      * unbounded CPU and memory. The cycle check cannot detect this shape (no variable repeats
      * on the substitution stack).
      */
     @Test
     void testExponentialFanOutReplacementThrowsIllegalStateException() {
         final Map<String, String> map = new HashMap<>();
         final char[] leafChars = new char[8192];
         java.util.Arrays.fill(leafChars, 'x');
         map.put("a6", new String(leafChars));
         for (int level = 5; level >= 0; level--) {
             final StringBuilder value = new StringBuilder();
             for (int i = 0; i < 10; i++) {
                 value.append("${a").append(level + 1).append("}");
             }
             map.put("a" + level, value.toString());
         }
         // full expansion would be 10^6 leaves * 8 KiB = ~8 GiB
         final StrSubstitutor sub = new StrSubstitutor(map);
         assertThrows(IllegalStateException.class, () -> sub.replace("${a0}"), "Size budget was not enforced.");
     }
 
     /**
      * Tests get set.
      */
     @Test
     void testGetSetEscape() {
         final StrSubstitutor sub = new StrSubstitutor();
         assertEquals('$', sub.getEscapeChar());
         sub.setEscapeChar('<');
         assertEquals('<', sub.getEscapeChar());
     }
 
     /**
      * Tests get set.
      */
     @Test
     void testGetSetPrefix() {
         final StrSubstitutor sub = new StrSubstitutor();
         assertInstanceOf(StrMatcher.StringMatcher.class, sub.getVariablePrefixMatcher());
         sub.setVariablePrefix('<');
         assertInstanceOf(StrMatcher.CharMatcher.class, sub.getVariablePrefixMatcher());
 
         sub.setVariablePrefix("<<");
         assertInstanceOf(StrMatcher.StringMatcher.class, sub.getVariablePrefixMatcher());
         assertNullPointerException(() -> sub.setVariablePrefix(null));
         assertInstanceOf(StrMatcher.StringMatcher.class, sub.getVariablePrefixMatcher());
 
         final StrMatcher matcher = StrMatcher.commaMatcher();
         sub.setVariablePrefixMatcher(matcher);
         assertSame(matcher, sub.getVariablePrefixMatcher());
         assertNullPointerException(() -> sub.setVariablePrefixMatcher(null));
         assertSame(matcher, sub.getVariablePrefixMatcher());
     }
 
     /**
      * Tests get set.
      */
     @Test
     void testGetSetSuffix() {
         final StrSubstitutor sub = new StrSubstitutor();
         assertInstanceOf(StrMatcher.StringMatcher.class, sub.getVariableSuffixMatcher());
         sub.setVariableSuffix('<');
         assertInstanceOf(StrMatcher.CharMatcher.class, sub.getVariableSuffixMatcher());
 
         sub.setVariableSuffix("<<");
         assertInstanceOf(StrMatcher.StringMatcher.class, sub.getVariableSuffixMatcher());
         assertNullPointerException(() -> sub.setVariableSuffix(null));
         assertInstanceOf(StrMatcher.StringMatcher.class, sub.getVariableSuffixMatcher());
 
         final StrMatcher matcher = StrMatcher.commaMatcher();
         sub.setVariableSuffixMatcher(matcher);
         assertSame(matcher, sub.getVariableSuffixMatcher());
         assertNullPointerException(() -> sub.setVariableSuffixMatcher(null));
         assertSame(matcher, sub.getVariableSuffixMatcher());
     }
 
     /**
      * Tests get set.
      */
     @Test
     void testGetSetValueDelimiter() {
         final StrSubstitutor sub = new StrSubstitutor();
         assertInstanceOf(StrMatcher.StringMatcher.class, sub.getValueDelimiterMatcher());
         sub.setValueDelimiter(':');
         assertInstanceOf(StrMatcher.CharMatcher.class, sub.getValueDelimiterMatcher());
 
         sub.setValueDelimiter("||");
         assertInstanceOf(StrMatcher.StringMatcher.class, sub.getValueDelimiterMatcher());
         sub.setValueDelimiter(null);
         assertNull(sub.getValueDelimiterMatcher());
 
         final StrMatcher matcher = StrMatcher.commaMatcher();
         sub.setValueDelimiterMatcher(matcher);
         assertSame(matcher, sub.getValueDelimiterMatcher());
         sub.setValueDelimiterMatcher(null);
         assertNull(sub.getValueDelimiterMatcher());
     }
 
     /**
      * Test for LANG-1055: StrSubstitutor.replaceSystemProperties does not work consistently
      */
     @Test
     void testLANG1055() {
         System.setProperty("test_key",  "test_value");
 
         final String expected = StrSubstitutor.replace("test_key=${test_key}", System.getProperties());
         final String actual = StrSubstitutor.replaceSystemProperties("test_key=${test_key}");
         assertEquals(expected, actual);
     }
 
     /**
      * Tests adjacent keys.
      */
     @Test
     void testReplaceAdjacentAtEnd() {
         values.put("code", "GBP");
         values.put("amount", "12.50");
         final StrSubstitutor sub = new StrSubstitutor(values);
         assertEquals("Amount is GBP12.50", sub.replace("Amount is ${code}${amount}"));
     }
 
     /**
      * Tests adjacent keys.
      */
     @Test
     void testReplaceAdjacentAtStart() {
         values.put("code", "GBP");
         values.put("amount", "12.50");
         final StrSubstitutor sub = new StrSubstitutor(values);
         assertEquals("GBP12.50 charged", sub.replace("${code}${amount} charged"));
     }
 
     /**
      * Tests key replace changing map after initialization (not recommended).
      */
     @Test
     void testReplaceChangedMap() {
         final 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 complex escaping.
      */
     @Test
     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
     void testReplaceEmpty() {
         doTestNoReplace("");
     }
 
     /**
      * Tests when no variable name.
      */
     @Test
     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
     void testReplaceEscaping() {
         doTestReplace("The ${animal} jumps over the lazy dog.", "The $${animal} jumps over the ${target}.", true);
     }
 
     /**
      * Tests when no incomplete prefix.
      */
     @Test
     void testReplaceIncompletePrefix() {
         doTestReplace("The {animal} jumps over the lazy dog.", "The {animal} jumps over the ${target}.", true);
     }
 
     /**
      * Tests whether a variable can be replaced in a variable name.
      */
     @Test
     void testReplaceInVariable() {
         values.put("animal.1", "fox");
         values.put("animal.2", "mouse");
         values.put("species", "2");
         final StrSubstitutor sub = new StrSubstitutor(values);
         sub.setEnableSubstitutionInVariables(true);
         assertEquals(
                 "The mouse jumps over the lazy dog.",
                 sub.replace("The ${animal.${species}} jumps over the ${target}."),
                 "Wrong result (1)");
         values.put("species", "1");
         assertEquals(
                 "The fox jumps over the lazy dog.",
                 sub.replace("The ${animal.${species}} jumps over the ${target}."),
                 "Wrong result (2)");
         assertEquals(
                 "The fox jumps over the lazy dog.",
                 sub.replace("The ${unknown.animal.${unknown.species:-1}:-fox} jumps over the ${unknown.target:-lazy dog}."),
                 "Wrong result (3)");
     }
 
     /**
      * Tests whether substitution in variable names is disabled per default.
      */
     @Test
     void testReplaceInVariableDisabled() {
         values.put("animal.1", "fox");
         values.put("animal.2", "mouse");
         values.put("species", "2");
         final StrSubstitutor sub = new StrSubstitutor(values);
         assertEquals(
                 "The ${animal.${species}} jumps over the lazy dog.",
                 sub.replace("The ${animal.${species}} jumps over the ${target}."),
                 "Wrong result (1)");
         assertEquals(
                 "The ${animal.${species:-1}} jumps over the lazy dog.",
                 sub.replace("The ${animal.${species:-1}} jumps over the ${target}."),
                 "Wrong result (2)");
     }
 
     /**
      * Tests complex and recursive substitution in variable names.
      */
     @Test
     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 StrSubstitutor sub = new StrSubstitutor(values);
         sub.setEnableSubstitutionInVariables(true);
         assertEquals(
                 "The white mouse jumps over the lazy dog.",
                 sub.replace("The ${animal.${species.${color}}} jumps over the ${target}."),
                 "Wrong result (1)");
         assertEquals(
                 "The brown fox jumps over the lazy dog.",
                 sub.replace("The ${animal.${species.${unknownColor:-brown}}} jumps over the ${target}."),
                 "Wrong result (2)");
     }
 
     /**
      * Tests when no prefix or suffix.
      */
     @Test
     void testReplaceNoPrefixNoSuffix() {
         doTestReplace("The animal jumps over the lazy dog.", "The animal jumps over the ${target}.", true);
     }
 
     /**
      * Tests when suffix but no prefix.
      */
     @Test
     void testReplaceNoPrefixSuffix() {
         doTestReplace("The animal} jumps over the lazy dog.", "The animal} jumps over the ${target}.", true);
     }
 
     /**
      * Tests replace with no variables.
      */
     @Test
     void testReplaceNoVariables() {
         doTestNoReplace("The balloon arrived.");
     }
 
     /**
      * Tests replace with null.
      */
     @Test
     void testReplaceNull() {
         doTestNoReplace(null);
     }
 
     /**
      * Tests simple key replace.
      */
     @Test
     void testReplacePartialString_noReplace() {
         final StrSubstitutor sub = new StrSubstitutor();
         assertEquals("${animal} jumps", sub.replace("The ${animal} jumps over the ${target}.", 4, 15));
     }
 
     /**
      * Tests when prefix but no suffix.
      */
     @Test
     void testReplacePrefixNoSuffix() {
         doTestReplace("The ${animal jumps over the ${target} lazy dog.", "The ${animal jumps over the ${target} ${target}.", true);
     }
 
     /**
      * Tests simple recursive replace.
      */
     @Test
     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
     void testReplaceSimple() {
         doTestReplace("The quick brown fox jumps over the lazy dog.", "The ${animal} jumps over the ${target}.", true);
     }
 
     /**
      * Tests simple key replace.
      */
     @Test
     void testReplaceSolo() {
         doTestReplace("quick brown fox", "${animal}", false);
     }
 
     /**
      * Tests escaping.
      */
     @Test
     void testReplaceSoloEscaping() {
         doTestReplace("${animal}", "$${animal}", false);
     }
 
     /**
      * Tests replace creates output same as input.
      */
     @Test
     void testReplaceToIdentical() {
         values.put("animal", "$${${thing}}");
         values.put("thing", "animal");
         doTestReplace("The ${animal} jumps.", "The ${animal} jumps.", true);
     }
 
     /**
      * Tests unknown key replace.
      */
     @Test
     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
     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
     void testResolveVariable() {
         final StrBuilder builder = new StrBuilder("Hi ${name}!");
         final Map<String, String> map = new HashMap<>();
         map.put("name", "commons");
         final StrSubstitutor sub = new StrSubstitutor(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
     void testSamePrefixAndSuffix() {
         final Map<String, String> map = new HashMap<>();
         map.put("greeting", "Hello");
         map.put(" there ", "XXX");
         map.put("name", "commons");
         assertEquals("Hi commons!", StrSubstitutor.replace("Hi @name@!", map, "@", "@"));
         assertEquals("Hello there commons!", StrSubstitutor.replace("@greeting@ there @name@!", map, "@", "@"));
     }
 
     /**
      * Tests static.
      */
     @Test
     void testStaticReplace() {
         final Map<String, String> map = new HashMap<>();
         map.put("name", "commons");
         assertEquals("Hi commons!", StrSubstitutor.replace("Hi ${name}!", map));
     }
 
     /**
      * Tests static.
      */
     @Test
     void testStaticReplacePrefixSuffix() {
         final Map<String, String> map = new HashMap<>();
         map.put("name", "commons");
         assertEquals("Hi commons!", StrSubstitutor.replace("Hi <name>!", map, "<", ">"));
     }
 
     /**
      * Tests interpolation with system properties.
      */
     @Test
     void testStaticReplaceSystemProperties() {
         final StrBuilder buf = new StrBuilder();
         buf.append("Hi ").append(SystemProperties.getUserName());
         buf.append(", you are working with ");
         buf.append(SystemProperties.getOsName());
         buf.append(", your home directory is ");
         buf.append(SystemProperties.getUserHome()).append('.');
         assertEquals(buf.toString(), StrSubstitutor.replaceSystemProperties("Hi ${user.name}, you are "
             + "working with ${os.name}, your home "
             + "directory is ${user.home}."));
     }
 
     /**
      * Test the replace of a properties object
      */
     @Test
     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!", StrSubstitutor.replace(org, props));
     }
 
     @Test
     void testSubstitutePreserveEscape() {
         final String org = "${not-escaped} $${escaped}";
         final Map<String, String> map = new HashMap<>();
         map.put("not-escaped", "value");
 
         final StrSubstitutor sub = new StrSubstitutor(map, "${", "}", '$');
         assertFalse(sub.isPreserveEscapes());
         assertEquals("value ${escaped}", sub.replace(org));
 
         sub.setPreserveEscapes(true);
         assertTrue(sub.isPreserveEscapes());
         assertEquals("value $${escaped}", sub.replace(org));
     }
 
 }