commons-notifications mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From chtom...@apache.org
Subject svn commit: r1012767 [25/39] - in /websites/production/commons/content/proper/commons-text: ./ apidocs/ apidocs/org/apache/commons/text/ apidocs/org/apache/commons/text/class-use/ apidocs/org/apache/commons/text/diff/ apidocs/org/apache/commons/text/di...
Date Tue, 23 May 2017 13:12:45 GMT
Modified: websites/production/commons/content/proper/commons-text/jacoco/org.apache.commons.text/StrSubstitutor.java.html
==============================================================================
--- websites/production/commons/content/proper/commons-text/jacoco/org.apache.commons.text/StrSubstitutor.java.html (original)
+++ websites/production/commons/content/proper/commons-text/jacoco/org.apache.commons.text/StrSubstitutor.java.html Tue May 23 13:12:41 2017
@@ -23,6 +23,8 @@ import java.util.List;
 import java.util.Map;
 import java.util.Properties;
 
+import org.apache.commons.lang3.Validate;
+
 /**
  * Substitutes variables within a string by values.
  * <p>
@@ -129,15 +131,15 @@ public class StrSubstitutor {
     /**
      * Constant for the default variable prefix.
      */
-<span class="fc" id="L132">    public static final StrMatcher DEFAULT_PREFIX = StrMatcher.stringMatcher(&quot;${&quot;);</span>
+<span class="fc" id="L134">    public static final StrMatcher DEFAULT_PREFIX = StrMatcher.stringMatcher(&quot;${&quot;);</span>
     /**
      * Constant for the default variable suffix.
      */
-<span class="fc" id="L136">    public static final StrMatcher DEFAULT_SUFFIX = StrMatcher.stringMatcher(&quot;}&quot;);</span>
+<span class="fc" id="L138">    public static final StrMatcher DEFAULT_SUFFIX = StrMatcher.stringMatcher(&quot;}&quot;);</span>
     /**
      * Constant for the default value delimiter of a variable.
      */
-<span class="fc" id="L140">    public static final StrMatcher DEFAULT_VALUE_DELIMITER = StrMatcher.stringMatcher(&quot;:-&quot;);</span>
+<span class="fc" id="L142">    public static final StrMatcher DEFAULT_VALUE_DELIMITER = StrMatcher.stringMatcher(&quot;:-&quot;);</span>
 
     /**
      * Stores the escape character.
@@ -166,7 +168,7 @@ public class StrSubstitutor {
     /**
      * Whether escapes should be preserved.  Default is false;
      */
-<span class="fc" id="L169">    private boolean preserveEscapes = false;</span>
+<span class="fc" id="L171">    private boolean preserveEscapes = false;</span>
 
     //-----------------------------------------------------------------------
     /**
@@ -179,12 +181,12 @@ public class StrSubstitutor {
      * @return the result of the replace operation
      */
     public static &lt;V&gt; String replace(final Object source, final Map&lt;String, V&gt; valueMap) {
-<span class="fc" id="L182">        return new StrSubstitutor(valueMap).replace(source);</span>
+<span class="fc" id="L184">        return new StrSubstitutor(valueMap).replace(source);</span>
     }
 
     /**
      * Replaces all the occurrences of variables in the given source object with
-     * their matching values from the map. This method allows to specifiy a
+     * their matching values from the map. This method allows to specify a
      * custom variable prefix and suffix
      *
      * @param &lt;V&gt; the type of the values in the map
@@ -199,7 +201,7 @@ public class StrSubstitutor {
                                      final Map&lt;String, V&gt; valueMap,
                                      final String prefix,
                                      final String suffix) {
-<span class="fc" id="L202">        return new StrSubstitutor(valueMap, prefix, suffix).replace(source);</span>
+<span class="fc" id="L204">        return new StrSubstitutor(valueMap, prefix, suffix).replace(source);</span>
     }
 
     /**
@@ -211,17 +213,17 @@ public class StrSubstitutor {
      * @return the result of the replace operation
      */
     public static String replace(final Object source, final Properties valueProperties) {
-<span class="pc bpc" id="L214" title="1 of 2 branches missed.">        if (valueProperties == null) {</span>
-<span class="nc" id="L215">            return source.toString();</span>
+<span class="pc bpc" id="L216" title="1 of 2 branches missed.">        if (valueProperties == null) {</span>
+<span class="nc" id="L217">            return source.toString();</span>
         }
-<span class="fc" id="L217">        final Map&lt;String, String&gt; valueMap = new HashMap&lt;&gt;();</span>
-<span class="fc" id="L218">        final Enumeration&lt;?&gt; propNames = valueProperties.propertyNames();</span>
-<span class="fc bfc" id="L219" title="All 2 branches covered.">        while (propNames.hasMoreElements()) {</span>
-<span class="fc" id="L220">            final String propName = (String) propNames.nextElement();</span>
-<span class="fc" id="L221">            final String propValue = valueProperties.getProperty(propName);</span>
-<span class="fc" id="L222">            valueMap.put(propName, propValue);</span>
-<span class="fc" id="L223">        }</span>
-<span class="fc" id="L224">        return StrSubstitutor.replace(source, valueMap);</span>
+<span class="fc" id="L219">        final Map&lt;String, String&gt; valueMap = new HashMap&lt;&gt;();</span>
+<span class="fc" id="L220">        final Enumeration&lt;?&gt; propNames = valueProperties.propertyNames();</span>
+<span class="fc bfc" id="L221" title="All 2 branches covered.">        while (propNames.hasMoreElements()) {</span>
+<span class="fc" id="L222">            final String propName = (String) propNames.nextElement();</span>
+<span class="fc" id="L223">            final String propValue = valueProperties.getProperty(propName);</span>
+<span class="fc" id="L224">            valueMap.put(propName, propValue);</span>
+<span class="fc" id="L225">        }</span>
+<span class="fc" id="L226">        return StrSubstitutor.replace(source, valueMap);</span>
     }
 
     /**
@@ -232,7 +234,7 @@ public class StrSubstitutor {
      * @return the result of the replace operation
      */
     public static String replaceSystemProperties(final Object source) {
-<span class="fc" id="L235">        return new StrSubstitutor(StrLookup.systemPropertiesLookup()).replace(source);</span>
+<span class="fc" id="L237">        return new StrSubstitutor(StrLookup.systemPropertiesLookup()).replace(source);</span>
     }
 
     //-----------------------------------------------------------------------
@@ -241,8 +243,8 @@ public class StrSubstitutor {
      * and the escaping character.
      */
     public StrSubstitutor() {
-<span class="fc" id="L244">        this((StrLookup&lt;?&gt;) null, DEFAULT_PREFIX, DEFAULT_SUFFIX, DEFAULT_ESCAPE);</span>
-<span class="fc" id="L245">    }</span>
+<span class="fc" id="L246">        this((StrLookup&lt;?&gt;) null, DEFAULT_PREFIX, DEFAULT_SUFFIX, DEFAULT_ESCAPE);</span>
+<span class="fc" id="L247">    }</span>
 
     /**
      * Creates a new instance and initializes it. Uses defaults for variable
@@ -252,8 +254,8 @@ public class StrSubstitutor {
      * @param valueMap  the map with the variables' values, may be null
      */
     public &lt;V&gt; StrSubstitutor(final Map&lt;String, V&gt; valueMap) {
-<span class="fc" id="L255">        this(StrLookup.mapLookup(valueMap), DEFAULT_PREFIX, DEFAULT_SUFFIX, DEFAULT_ESCAPE);</span>
-<span class="fc" id="L256">    }</span>
+<span class="fc" id="L257">        this(StrLookup.mapLookup(valueMap), DEFAULT_PREFIX, DEFAULT_SUFFIX, DEFAULT_ESCAPE);</span>
+<span class="fc" id="L258">    }</span>
 
     /**
      * Creates a new instance and initializes it. Uses a default escaping character.
@@ -265,8 +267,8 @@ public class StrSubstitutor {
      * @throws IllegalArgumentException if the prefix or suffix is null
      */
     public &lt;V&gt; StrSubstitutor(final Map&lt;String, V&gt; valueMap, final String prefix, final String suffix) {
-<span class="fc" id="L268">        this(StrLookup.mapLookup(valueMap), prefix, suffix, DEFAULT_ESCAPE);</span>
-<span class="fc" id="L269">    }</span>
+<span class="fc" id="L270">        this(StrLookup.mapLookup(valueMap), prefix, suffix, DEFAULT_ESCAPE);</span>
+<span class="fc" id="L271">    }</span>
 
     /**
      * Creates a new instance and initializes it.
@@ -280,8 +282,8 @@ public class StrSubstitutor {
      */
     public &lt;V&gt; StrSubstitutor(final Map&lt;String, V&gt; valueMap, final String prefix, final String suffix,
                               final char escape) {
-<span class="fc" id="L283">        this(StrLookup.mapLookup(valueMap), prefix, suffix, escape);</span>
-<span class="fc" id="L284">    }</span>
+<span class="fc" id="L285">        this(StrLookup.mapLookup(valueMap), prefix, suffix, escape);</span>
+<span class="fc" id="L286">    }</span>
 
     /**
      * Creates a new instance and initializes it.
@@ -296,8 +298,8 @@ public class StrSubstitutor {
      */
     public &lt;V&gt; StrSubstitutor(final Map&lt;String, V&gt; valueMap, final String prefix, final String suffix,
                               final char escape, final String valueDelimiter) {
-<span class="fc" id="L299">        this(StrLookup.mapLookup(valueMap), prefix, suffix, escape, valueDelimiter);</span>
-<span class="fc" id="L300">    }</span>
+<span class="fc" id="L301">        this(StrLookup.mapLookup(valueMap), prefix, suffix, escape, valueDelimiter);</span>
+<span class="fc" id="L302">    }</span>
 
     /**
      * Creates a new instance and initializes it.
@@ -305,8 +307,8 @@ public class StrSubstitutor {
      * @param variableResolver  the variable resolver, may be null
      */
     public StrSubstitutor(final StrLookup&lt;?&gt; variableResolver) {
-<span class="fc" id="L308">        this(variableResolver, DEFAULT_PREFIX, DEFAULT_SUFFIX, DEFAULT_ESCAPE);</span>
-<span class="fc" id="L309">    }</span>
+<span class="fc" id="L310">        this(variableResolver, DEFAULT_PREFIX, DEFAULT_SUFFIX, DEFAULT_ESCAPE);</span>
+<span class="fc" id="L311">    }</span>
 
     /**
      * Creates a new instance and initializes it.
@@ -318,13 +320,13 @@ public class StrSubstitutor {
      * @throws IllegalArgumentException if the prefix or suffix is null
      */
     public StrSubstitutor(final StrLookup&lt;?&gt; variableResolver, final String prefix, final String suffix,
-<span class="fc" id="L321">                          final char escape) {</span>
-<span class="fc" id="L322">        this.setVariableResolver(variableResolver);</span>
-<span class="fc" id="L323">        this.setVariablePrefix(prefix);</span>
-<span class="fc" id="L324">        this.setVariableSuffix(suffix);</span>
-<span class="fc" id="L325">        this.setEscapeChar(escape);</span>
-<span class="fc" id="L326">        this.setValueDelimiterMatcher(DEFAULT_VALUE_DELIMITER);</span>
-<span class="fc" id="L327">    }</span>
+<span class="fc" id="L323">                          final char escape) {</span>
+<span class="fc" id="L324">        this.setVariableResolver(variableResolver);</span>
+<span class="fc" id="L325">        this.setVariablePrefix(prefix);</span>
+<span class="fc" id="L326">        this.setVariableSuffix(suffix);</span>
+<span class="fc" id="L327">        this.setEscapeChar(escape);</span>
+<span class="fc" id="L328">        this.setValueDelimiterMatcher(DEFAULT_VALUE_DELIMITER);</span>
+<span class="fc" id="L329">    }</span>
 
     /**
      * Creates a new instance and initializes it.
@@ -337,13 +339,13 @@ public class StrSubstitutor {
      * @throws IllegalArgumentException if the prefix or suffix is null
      */
     public StrSubstitutor(final StrLookup&lt;?&gt; variableResolver, final String prefix, final String suffix,
-<span class="fc" id="L340">                          final char escape, final String valueDelimiter) {</span>
-<span class="fc" id="L341">        this.setVariableResolver(variableResolver);</span>
-<span class="fc" id="L342">        this.setVariablePrefix(prefix);</span>
-<span class="fc" id="L343">        this.setVariableSuffix(suffix);</span>
-<span class="fc" id="L344">        this.setEscapeChar(escape);</span>
-<span class="fc" id="L345">        this.setValueDelimiter(valueDelimiter);</span>
-<span class="fc" id="L346">    }</span>
+<span class="fc" id="L342">                          final char escape, final String valueDelimiter) {</span>
+<span class="fc" id="L343">        this.setVariableResolver(variableResolver);</span>
+<span class="fc" id="L344">        this.setVariablePrefix(prefix);</span>
+<span class="fc" id="L345">        this.setVariableSuffix(suffix);</span>
+<span class="fc" id="L346">        this.setEscapeChar(escape);</span>
+<span class="fc" id="L347">        this.setValueDelimiter(valueDelimiter);</span>
+<span class="fc" id="L348">    }</span>
 
     /**
      * Creates a new instance and initializes it.
@@ -357,8 +359,8 @@ public class StrSubstitutor {
     public StrSubstitutor(
             final StrLookup&lt;?&gt; variableResolver, final StrMatcher prefixMatcher, final StrMatcher suffixMatcher,
             final char escape) {
-<span class="fc" id="L360">        this(variableResolver, prefixMatcher, suffixMatcher, escape, DEFAULT_VALUE_DELIMITER);</span>
-<span class="fc" id="L361">    }</span>
+<span class="fc" id="L362">        this(variableResolver, prefixMatcher, suffixMatcher, escape, DEFAULT_VALUE_DELIMITER);</span>
+<span class="fc" id="L363">    }</span>
 
     /**
      * Creates a new instance and initializes it.
@@ -372,13 +374,13 @@ public class StrSubstitutor {
      */
     public StrSubstitutor(
             final StrLookup&lt;?&gt; variableResolver, final StrMatcher prefixMatcher, final StrMatcher suffixMatcher,
-<span class="fc" id="L375">            final char escape, final StrMatcher valueDelimiterMatcher) {</span>
-<span class="fc" id="L376">        this.setVariableResolver(variableResolver);</span>
-<span class="fc" id="L377">        this.setVariablePrefixMatcher(prefixMatcher);</span>
-<span class="fc" id="L378">        this.setVariableSuffixMatcher(suffixMatcher);</span>
-<span class="fc" id="L379">        this.setEscapeChar(escape);</span>
-<span class="fc" id="L380">        this.setValueDelimiterMatcher(valueDelimiterMatcher);</span>
-<span class="fc" id="L381">    }</span>
+<span class="fc" id="L377">            final char escape, final StrMatcher valueDelimiterMatcher) {</span>
+<span class="fc" id="L378">        this.setVariableResolver(variableResolver);</span>
+<span class="fc" id="L379">        this.setVariablePrefixMatcher(prefixMatcher);</span>
+<span class="fc" id="L380">        this.setVariableSuffixMatcher(suffixMatcher);</span>
+<span class="fc" id="L381">        this.setEscapeChar(escape);</span>
+<span class="fc" id="L382">        this.setValueDelimiterMatcher(valueDelimiterMatcher);</span>
+<span class="fc" id="L383">    }</span>
 
     //-----------------------------------------------------------------------
     /**
@@ -389,14 +391,14 @@ public class StrSubstitutor {
      * @return the result of the replace operation
      */
     public String replace(final String source) {
-<span class="fc bfc" id="L392" title="All 2 branches covered.">        if (source == null) {</span>
-<span class="fc" id="L393">            return null;</span>
+<span class="fc bfc" id="L394" title="All 2 branches covered.">        if (source == null) {</span>
+<span class="fc" id="L395">            return null;</span>
         }
-<span class="fc" id="L395">        final StrBuilder buf = new StrBuilder(source);</span>
-<span class="fc bfc" id="L396" title="All 2 branches covered.">        if (!substitute(buf, 0, source.length())) {</span>
-<span class="fc" id="L397">            return source;</span>
+<span class="fc" id="L397">        final StrBuilder buf = new StrBuilder(source);</span>
+<span class="fc bfc" id="L398" title="All 2 branches covered.">        if (!substitute(buf, 0, source.length())) {</span>
+<span class="fc" id="L399">            return source;</span>
         }
-<span class="fc" id="L399">        return buf.toString();</span>
+<span class="fc" id="L401">        return buf.toString();</span>
     }
 
     /**
@@ -412,14 +414,14 @@ public class StrSubstitutor {
      * @return the result of the replace operation
      */
     public String replace(final String source, final int offset, final int length) {
-<span class="fc bfc" id="L415" title="All 2 branches covered.">        if (source == null) {</span>
-<span class="fc" id="L416">            return null;</span>
+<span class="fc bfc" id="L417" title="All 2 branches covered.">        if (source == null) {</span>
+<span class="fc" id="L418">            return null;</span>
         }
-<span class="fc" id="L418">        final StrBuilder buf = new StrBuilder(length).append(source, offset, length);</span>
-<span class="fc bfc" id="L419" title="All 2 branches covered.">        if (!substitute(buf, 0, length)) {</span>
-<span class="fc" id="L420">            return source.substring(offset, offset + length);</span>
+<span class="fc" id="L420">        final StrBuilder buf = new StrBuilder(length).append(source, offset, length);</span>
+<span class="fc bfc" id="L421" title="All 2 branches covered.">        if (!substitute(buf, 0, length)) {</span>
+<span class="fc" id="L422">            return source.substring(offset, offset + length);</span>
         }
-<span class="fc" id="L422">        return buf.toString();</span>
+<span class="fc" id="L424">        return buf.toString();</span>
     }
 
     //-----------------------------------------------------------------------
@@ -432,12 +434,12 @@ public class StrSubstitutor {
      * @return the result of the replace operation
      */
     public String replace(final char[] source) {
-<span class="fc bfc" id="L435" title="All 2 branches covered.">        if (source == null) {</span>
-<span class="fc" id="L436">            return null;</span>
+<span class="fc bfc" id="L437" title="All 2 branches covered.">        if (source == null) {</span>
+<span class="fc" id="L438">            return null;</span>
         }
-<span class="fc" id="L438">        final StrBuilder buf = new StrBuilder(source.length).append(source);</span>
-<span class="fc" id="L439">        substitute(buf, 0, source.length);</span>
-<span class="fc" id="L440">        return buf.toString();</span>
+<span class="fc" id="L440">        final StrBuilder buf = new StrBuilder(source.length).append(source);</span>
+<span class="fc" id="L441">        substitute(buf, 0, source.length);</span>
+<span class="fc" id="L442">        return buf.toString();</span>
     }
 
     /**
@@ -454,12 +456,12 @@ public class StrSubstitutor {
      * @return the result of the replace operation
      */
     public String replace(final char[] source, final int offset, final int length) {
-<span class="fc bfc" id="L457" title="All 2 branches covered.">        if (source == null) {</span>
-<span class="fc" id="L458">            return null;</span>
+<span class="fc bfc" id="L459" title="All 2 branches covered.">        if (source == null) {</span>
+<span class="fc" id="L460">            return null;</span>
         }
-<span class="fc" id="L460">        final StrBuilder buf = new StrBuilder(length).append(source, offset, length);</span>
-<span class="fc" id="L461">        substitute(buf, 0, length);</span>
-<span class="fc" id="L462">        return buf.toString();</span>
+<span class="fc" id="L462">        final StrBuilder buf = new StrBuilder(length).append(source, offset, length);</span>
+<span class="fc" id="L463">        substitute(buf, 0, length);</span>
+<span class="fc" id="L464">        return buf.toString();</span>
     }
 
     //-----------------------------------------------------------------------
@@ -472,12 +474,12 @@ public class StrSubstitutor {
      * @return the result of the replace operation
      */
     public String replace(final StringBuffer source) {
-<span class="fc bfc" id="L475" title="All 2 branches covered.">        if (source == null) {</span>
-<span class="fc" id="L476">            return null;</span>
+<span class="fc bfc" id="L477" title="All 2 branches covered.">        if (source == null) {</span>
+<span class="fc" id="L478">            return null;</span>
         }
-<span class="fc" id="L478">        final StrBuilder buf = new StrBuilder(source.length()).append(source);</span>
-<span class="fc" id="L479">        substitute(buf, 0, buf.length());</span>
-<span class="fc" id="L480">        return buf.toString();</span>
+<span class="fc" id="L480">        final StrBuilder buf = new StrBuilder(source.length()).append(source);</span>
+<span class="fc" id="L481">        substitute(buf, 0, buf.length());</span>
+<span class="fc" id="L482">        return buf.toString();</span>
     }
 
     /**
@@ -494,12 +496,12 @@ public class StrSubstitutor {
      * @return the result of the replace operation
      */
     public String replace(final StringBuffer source, final int offset, final int length) {
-<span class="fc bfc" id="L497" title="All 2 branches covered.">        if (source == null) {</span>
-<span class="fc" id="L498">            return null;</span>
+<span class="fc bfc" id="L499" title="All 2 branches covered.">        if (source == null) {</span>
+<span class="fc" id="L500">            return null;</span>
         }
-<span class="fc" id="L500">        final StrBuilder buf = new StrBuilder(length).append(source, offset, length);</span>
-<span class="fc" id="L501">        substitute(buf, 0, length);</span>
-<span class="fc" id="L502">        return buf.toString();</span>
+<span class="fc" id="L502">        final StrBuilder buf = new StrBuilder(length).append(source, offset, length);</span>
+<span class="fc" id="L503">        substitute(buf, 0, length);</span>
+<span class="fc" id="L504">        return buf.toString();</span>
     }
 
     /**
@@ -511,10 +513,10 @@ public class StrSubstitutor {
      * @return the result of the replace operation
      */
     public String replace(final CharSequence source) {
-<span class="pc bpc" id="L514" title="1 of 2 branches missed.">        if (source == null) {</span>
-<span class="nc" id="L515">            return null;</span>
+<span class="pc bpc" id="L516" title="1 of 2 branches missed.">        if (source == null) {</span>
+<span class="nc" id="L517">            return null;</span>
         }
-<span class="fc" id="L517">        return replace(source, 0, source.length());</span>
+<span class="fc" id="L519">        return replace(source, 0, source.length());</span>
     }
 
     /**
@@ -531,12 +533,12 @@ public class StrSubstitutor {
      * @return the result of the replace operation
      */
     public String replace(final CharSequence source, final int offset, final int length) {
-<span class="pc bpc" id="L534" title="1 of 2 branches missed.">        if (source == null) {</span>
-<span class="nc" id="L535">            return null;</span>
+<span class="pc bpc" id="L536" title="1 of 2 branches missed.">        if (source == null) {</span>
+<span class="nc" id="L537">            return null;</span>
         }
-<span class="fc" id="L537">        final StrBuilder buf = new StrBuilder(length).append(source, offset, length);</span>
-<span class="fc" id="L538">        substitute(buf, 0, length);</span>
-<span class="fc" id="L539">        return buf.toString();</span>
+<span class="fc" id="L539">        final StrBuilder buf = new StrBuilder(length).append(source, offset, length);</span>
+<span class="fc" id="L540">        substitute(buf, 0, length);</span>
+<span class="fc" id="L541">        return buf.toString();</span>
     }
 
     //-----------------------------------------------------------------------
@@ -549,12 +551,12 @@ public class StrSubstitutor {
      * @return the result of the replace operation
      */
     public String replace(final StrBuilder source) {
-<span class="fc bfc" id="L552" title="All 2 branches covered.">        if (source == null) {</span>
-<span class="fc" id="L553">            return null;</span>
+<span class="fc bfc" id="L554" title="All 2 branches covered.">        if (source == null) {</span>
+<span class="fc" id="L555">            return null;</span>
         }
-<span class="fc" id="L555">        final StrBuilder buf = new StrBuilder(source.length()).append(source);</span>
-<span class="fc" id="L556">        substitute(buf, 0, buf.length());</span>
-<span class="fc" id="L557">        return buf.toString();</span>
+<span class="fc" id="L557">        final StrBuilder buf = new StrBuilder(source.length()).append(source);</span>
+<span class="fc" id="L558">        substitute(buf, 0, buf.length());</span>
+<span class="fc" id="L559">        return buf.toString();</span>
     }
 
     /**
@@ -571,12 +573,12 @@ public class StrSubstitutor {
      * @return the result of the replace operation
      */
     public String replace(final StrBuilder source, final int offset, final int length) {
-<span class="fc bfc" id="L574" title="All 2 branches covered.">        if (source == null) {</span>
-<span class="fc" id="L575">            return null;</span>
+<span class="fc bfc" id="L576" title="All 2 branches covered.">        if (source == null) {</span>
+<span class="fc" id="L577">            return null;</span>
         }
-<span class="fc" id="L577">        final StrBuilder buf = new StrBuilder(length).append(source, offset, length);</span>
-<span class="fc" id="L578">        substitute(buf, 0, length);</span>
-<span class="fc" id="L579">        return buf.toString();</span>
+<span class="fc" id="L579">        final StrBuilder buf = new StrBuilder(length).append(source, offset, length);</span>
+<span class="fc" id="L580">        substitute(buf, 0, length);</span>
+<span class="fc" id="L581">        return buf.toString();</span>
     }
 
     //-----------------------------------------------------------------------
@@ -589,12 +591,12 @@ public class StrSubstitutor {
      * @return the result of the replace operation
      */
     public String replace(final Object source) {
-<span class="fc bfc" id="L592" title="All 2 branches covered.">        if (source == null) {</span>
-<span class="fc" id="L593">            return null;</span>
+<span class="fc bfc" id="L594" title="All 2 branches covered.">        if (source == null) {</span>
+<span class="fc" id="L595">            return null;</span>
         }
-<span class="fc" id="L595">        final StrBuilder buf = new StrBuilder().append(source);</span>
-<span class="fc" id="L596">        substitute(buf, 0, buf.length());</span>
-<span class="fc" id="L597">        return buf.toString();</span>
+<span class="fc" id="L597">        final StrBuilder buf = new StrBuilder().append(source);</span>
+<span class="fc" id="L598">        substitute(buf, 0, buf.length());</span>
+<span class="fc" id="L599">        return buf.toString();</span>
     }
 
     //-----------------------------------------------------------------------
@@ -607,10 +609,10 @@ public class StrSubstitutor {
      * @return true if altered
      */
     public boolean replaceIn(final StringBuffer source) {
-<span class="fc bfc" id="L610" title="All 2 branches covered.">        if (source == null) {</span>
-<span class="fc" id="L611">            return false;</span>
+<span class="fc bfc" id="L612" title="All 2 branches covered.">        if (source == null) {</span>
+<span class="fc" id="L613">            return false;</span>
         }
-<span class="fc" id="L613">        return replaceIn(source, 0, source.length());</span>
+<span class="fc" id="L615">        return replaceIn(source, 0, source.length());</span>
     }
 
     /**
@@ -627,15 +629,15 @@ public class StrSubstitutor {
      * @return true if altered
      */
     public boolean replaceIn(final StringBuffer source, final int offset, final int length) {
-<span class="fc bfc" id="L630" title="All 2 branches covered.">        if (source == null) {</span>
-<span class="fc" id="L631">            return false;</span>
+<span class="fc bfc" id="L632" title="All 2 branches covered.">        if (source == null) {</span>
+<span class="fc" id="L633">            return false;</span>
         }
-<span class="fc" id="L633">        final StrBuilder buf = new StrBuilder(length).append(source, offset, length);</span>
-<span class="pc bpc" id="L634" title="1 of 2 branches missed.">        if (!substitute(buf, 0, length)) {</span>
-<span class="nc" id="L635">            return false;</span>
+<span class="fc" id="L635">        final StrBuilder buf = new StrBuilder(length).append(source, offset, length);</span>
+<span class="pc bpc" id="L636" title="1 of 2 branches missed.">        if (!substitute(buf, 0, length)) {</span>
+<span class="nc" id="L637">            return false;</span>
         }
-<span class="fc" id="L637">        source.replace(offset, offset + length, buf.toString());</span>
-<span class="fc" id="L638">        return true;</span>
+<span class="fc" id="L639">        source.replace(offset, offset + length, buf.toString());</span>
+<span class="fc" id="L640">        return true;</span>
     }
 
   //-----------------------------------------------------------------------
@@ -648,10 +650,10 @@ public class StrSubstitutor {
      * @return true if altered
      */
     public boolean replaceIn(final StringBuilder source) {
-<span class="pc bpc" id="L651" title="1 of 2 branches missed.">        if (source == null) {</span>
-<span class="nc" id="L652">            return false;</span>
+<span class="pc bpc" id="L653" title="1 of 2 branches missed.">        if (source == null) {</span>
+<span class="nc" id="L654">            return false;</span>
         }
-<span class="fc" id="L654">        return replaceIn(source, 0, source.length());</span>
+<span class="fc" id="L656">        return replaceIn(source, 0, source.length());</span>
     }
 
     /**
@@ -668,15 +670,15 @@ public class StrSubstitutor {
      * @return true if altered
      */
     public boolean replaceIn(final StringBuilder source, final int offset, final int length) {
-<span class="pc bpc" id="L671" title="1 of 2 branches missed.">        if (source == null) {</span>
-<span class="nc" id="L672">            return false;</span>
+<span class="pc bpc" id="L673" title="1 of 2 branches missed.">        if (source == null) {</span>
+<span class="nc" id="L674">            return false;</span>
         }
-<span class="fc" id="L674">        final StrBuilder buf = new StrBuilder(length).append(source, offset, length);</span>
-<span class="pc bpc" id="L675" title="1 of 2 branches missed.">        if (!substitute(buf, 0, length)) {</span>
-<span class="nc" id="L676">            return false;</span>
+<span class="fc" id="L676">        final StrBuilder buf = new StrBuilder(length).append(source, offset, length);</span>
+<span class="pc bpc" id="L677" title="1 of 2 branches missed.">        if (!substitute(buf, 0, length)) {</span>
+<span class="nc" id="L678">            return false;</span>
         }
-<span class="fc" id="L678">        source.replace(offset, offset + length, buf.toString());</span>
-<span class="fc" id="L679">        return true;</span>
+<span class="fc" id="L680">        source.replace(offset, offset + length, buf.toString());</span>
+<span class="fc" id="L681">        return true;</span>
     }
 
     //-----------------------------------------------------------------------
@@ -688,10 +690,10 @@ public class StrSubstitutor {
      * @return true if altered
      */
     public boolean replaceIn(final StrBuilder source) {
-<span class="fc bfc" id="L691" title="All 2 branches covered.">        if (source == null) {</span>
-<span class="fc" id="L692">            return false;</span>
+<span class="fc bfc" id="L693" title="All 2 branches covered.">        if (source == null) {</span>
+<span class="fc" id="L694">            return false;</span>
         }
-<span class="fc" id="L694">        return substitute(source, 0, source.length());</span>
+<span class="fc" id="L696">        return substitute(source, 0, source.length());</span>
     }
 
     /**
@@ -707,10 +709,10 @@ public class StrSubstitutor {
      * @return true if altered
      */
     public boolean replaceIn(final StrBuilder source, final int offset, final int length) {
-<span class="fc bfc" id="L710" title="All 2 branches covered.">        if (source == null) {</span>
-<span class="fc" id="L711">            return false;</span>
+<span class="fc bfc" id="L712" title="All 2 branches covered.">        if (source == null) {</span>
+<span class="fc" id="L713">            return false;</span>
         }
-<span class="fc" id="L713">        return substitute(source, offset, length);</span>
+<span class="fc" id="L715">        return substitute(source, offset, length);</span>
     }
 
     //-----------------------------------------------------------------------
@@ -729,7 +731,7 @@ public class StrSubstitutor {
      * @return true if altered
      */
     protected boolean substitute(final StrBuilder buf, final int offset, final int length) {
-<span class="fc bfc" id="L732" title="All 2 branches covered.">        return substitute(buf, offset, length, null) &gt; 0;</span>
+<span class="fc bfc" id="L734" title="All 2 branches covered.">        return substitute(buf, offset, length, null) &gt; 0;</span>
     }
 
     /**
@@ -745,146 +747,146 @@ public class StrSubstitutor {
      *  represents a boolean flag as to whether any change occurred.
      */
     private int substitute(final StrBuilder buf, final int offset, final int length, List&lt;String&gt; priorVariables) {
-<span class="fc" id="L748">        final StrMatcher pfxMatcher = getVariablePrefixMatcher();</span>
-<span class="fc" id="L749">        final StrMatcher suffMatcher = getVariableSuffixMatcher();</span>
-<span class="fc" id="L750">        final char escape = getEscapeChar();</span>
-<span class="fc" id="L751">        final StrMatcher valueDelimMatcher = getValueDelimiterMatcher();</span>
-<span class="fc" id="L752">        final boolean substitutionInVariablesEnabled = isEnableSubstitutionInVariables();</span>
-
-<span class="fc bfc" id="L754" title="All 2 branches covered.">        final boolean top = priorVariables == null;</span>
-<span class="fc" id="L755">        boolean altered = false;</span>
-<span class="fc" id="L756">        int lengthChange = 0;</span>
-<span class="fc" id="L757">        char[] chars = buf.buffer;</span>
-<span class="fc" id="L758">        int bufEnd = offset + length;</span>
-<span class="fc" id="L759">        int pos = offset;</span>
-<span class="fc bfc" id="L760" title="All 2 branches covered.">        while (pos &lt; bufEnd) {</span>
-<span class="fc" id="L761">            final int startMatchLen = pfxMatcher.isMatch(chars, pos, offset,</span>
+<span class="fc" id="L750">        final StrMatcher pfxMatcher = getVariablePrefixMatcher();</span>
+<span class="fc" id="L751">        final StrMatcher suffMatcher = getVariableSuffixMatcher();</span>
+<span class="fc" id="L752">        final char escape = getEscapeChar();</span>
+<span class="fc" id="L753">        final StrMatcher valueDelimMatcher = getValueDelimiterMatcher();</span>
+<span class="fc" id="L754">        final boolean substitutionInVariablesEnabled = isEnableSubstitutionInVariables();</span>
+
+<span class="fc bfc" id="L756" title="All 2 branches covered.">        final boolean top = priorVariables == null;</span>
+<span class="fc" id="L757">        boolean altered = false;</span>
+<span class="fc" id="L758">        int lengthChange = 0;</span>
+<span class="fc" id="L759">        char[] chars = buf.buffer;</span>
+<span class="fc" id="L760">        int bufEnd = offset + length;</span>
+<span class="fc" id="L761">        int pos = offset;</span>
+<span class="fc bfc" id="L762" title="All 2 branches covered.">        while (pos &lt; bufEnd) {</span>
+<span class="fc" id="L763">            final int startMatchLen = pfxMatcher.isMatch(chars, pos, offset,</span>
                     bufEnd);
-<span class="fc bfc" id="L763" title="All 2 branches covered.">            if (startMatchLen == 0) {</span>
-<span class="fc" id="L764">                pos++;</span>
+<span class="fc bfc" id="L765" title="All 2 branches covered.">            if (startMatchLen == 0) {</span>
+<span class="fc" id="L766">                pos++;</span>
             } else {
                 // found variable start marker
-<span class="fc bfc" id="L767" title="All 4 branches covered.">                if (pos &gt; offset &amp;&amp; chars[pos - 1] == escape) {</span>
+<span class="fc bfc" id="L769" title="All 4 branches covered.">                if (pos &gt; offset &amp;&amp; chars[pos - 1] == escape) {</span>
                     // escaped
-<span class="fc bfc" id="L769" title="All 2 branches covered.">                    if (preserveEscapes) {</span>
-<span class="fc" id="L770">                        pos++;</span>
-<span class="fc" id="L771">                        continue;</span>
+<span class="fc bfc" id="L771" title="All 2 branches covered.">                    if (preserveEscapes) {</span>
+<span class="fc" id="L772">                        pos++;</span>
+<span class="fc" id="L773">                        continue;</span>
                     }
-<span class="fc" id="L773">                    buf.deleteCharAt(pos - 1);</span>
-<span class="fc" id="L774">                    chars = buf.buffer; // in case buffer was altered</span>
-<span class="fc" id="L775">                    lengthChange--;</span>
-<span class="fc" id="L776">                    altered = true;</span>
-<span class="fc" id="L777">                    bufEnd--;</span>
+<span class="fc" id="L775">                    buf.deleteCharAt(pos - 1);</span>
+<span class="fc" id="L776">                    chars = buf.buffer; // in case buffer was altered</span>
+<span class="fc" id="L777">                    lengthChange--;</span>
+<span class="fc" id="L778">                    altered = true;</span>
+<span class="fc" id="L779">                    bufEnd--;</span>
                 } else {
                     // find suffix
-<span class="fc" id="L780">                    final int startPos = pos;</span>
-<span class="fc" id="L781">                    pos += startMatchLen;</span>
-<span class="fc" id="L782">                    int endMatchLen = 0;</span>
-<span class="fc" id="L783">                    int nestedVarCount = 0;</span>
-<span class="fc bfc" id="L784" title="All 2 branches covered.">                    while (pos &lt; bufEnd) {</span>
-<span class="fc bfc" id="L785" title="All 2 branches covered.">                        if (substitutionInVariablesEnabled</span>
-<span class="fc bfc" id="L786" title="All 2 branches covered.">                                &amp;&amp; pfxMatcher.isMatch(chars,</span>
+<span class="fc" id="L782">                    final int startPos = pos;</span>
+<span class="fc" id="L783">                    pos += startMatchLen;</span>
+<span class="fc" id="L784">                    int endMatchLen = 0;</span>
+<span class="fc" id="L785">                    int nestedVarCount = 0;</span>
+<span class="fc bfc" id="L786" title="All 2 branches covered.">                    while (pos &lt; bufEnd) {</span>
+<span class="fc bfc" id="L787" title="All 2 branches covered.">                        if (substitutionInVariablesEnabled</span>
+<span class="fc bfc" id="L788" title="All 2 branches covered.">                                &amp;&amp; pfxMatcher.isMatch(chars,</span>
                                         pos, offset, bufEnd) != 0) {
                             // found a nested variable start
-<span class="fc" id="L789">                            endMatchLen = pfxMatcher.isMatch(chars,</span>
+<span class="fc" id="L791">                            endMatchLen = pfxMatcher.isMatch(chars,</span>
                                     pos, offset, bufEnd);
-<span class="fc" id="L791">                            nestedVarCount++;</span>
-<span class="fc" id="L792">                            pos += endMatchLen;</span>
-<span class="fc" id="L793">                            continue;</span>
+<span class="fc" id="L793">                            nestedVarCount++;</span>
+<span class="fc" id="L794">                            pos += endMatchLen;</span>
+<span class="fc" id="L795">                            continue;</span>
                         }
 
-<span class="fc" id="L796">                        endMatchLen = suffMatcher.isMatch(chars, pos, offset,</span>
+<span class="fc" id="L798">                        endMatchLen = suffMatcher.isMatch(chars, pos, offset,</span>
                                 bufEnd);
-<span class="fc bfc" id="L798" title="All 2 branches covered.">                        if (endMatchLen == 0) {</span>
-<span class="fc" id="L799">                            pos++;</span>
+<span class="fc bfc" id="L800" title="All 2 branches covered.">                        if (endMatchLen == 0) {</span>
+<span class="fc" id="L801">                            pos++;</span>
                         } else {
                             // found variable end marker
-<span class="fc bfc" id="L802" title="All 2 branches covered.">                            if (nestedVarCount == 0) {</span>
-<span class="fc" id="L803">                                String varNameExpr = new String(chars, startPos</span>
+<span class="fc bfc" id="L804" title="All 2 branches covered.">                            if (nestedVarCount == 0) {</span>
+<span class="fc" id="L805">                                String varNameExpr = new String(chars, startPos</span>
                                         + startMatchLen, pos - startPos
                                         - startMatchLen);
-<span class="fc bfc" id="L806" title="All 2 branches covered.">                                if (substitutionInVariablesEnabled) {</span>
-<span class="fc" id="L807">                                    final StrBuilder bufName = new StrBuilder(varNameExpr);</span>
-<span class="fc" id="L808">                                    substitute(bufName, 0, bufName.length());</span>
-<span class="fc" id="L809">                                    varNameExpr = bufName.toString();</span>
+<span class="fc bfc" id="L808" title="All 2 branches covered.">                                if (substitutionInVariablesEnabled) {</span>
+<span class="fc" id="L809">                                    final StrBuilder bufName = new StrBuilder(varNameExpr);</span>
+<span class="fc" id="L810">                                    substitute(bufName, 0, bufName.length());</span>
+<span class="fc" id="L811">                                    varNameExpr = bufName.toString();</span>
                                 }
-<span class="fc" id="L811">                                pos += endMatchLen;</span>
-<span class="fc" id="L812">                                final int endPos = pos;</span>
+<span class="fc" id="L813">                                pos += endMatchLen;</span>
+<span class="fc" id="L814">                                final int endPos = pos;</span>
 
-<span class="fc" id="L814">                                String varName = varNameExpr;</span>
-<span class="fc" id="L815">                                String varDefaultValue = null;</span>
+<span class="fc" id="L816">                                String varName = varNameExpr;</span>
+<span class="fc" id="L817">                                String varDefaultValue = null;</span>
 
-<span class="fc bfc" id="L817" title="All 2 branches covered.">                                if (valueDelimMatcher != null) {</span>
-<span class="fc" id="L818">                                    final char [] varNameExprChars = varNameExpr.toCharArray();</span>
-<span class="fc" id="L819">                                    int valueDelimiterMatchLen = 0;</span>
-<span class="fc bfc" id="L820" title="All 2 branches covered.">                                    for (int i = 0; i &lt; varNameExprChars.length; i++) {</span>
+<span class="fc bfc" id="L819" title="All 2 branches covered.">                                if (valueDelimMatcher != null) {</span>
+<span class="fc" id="L820">                                    final char [] varNameExprChars = varNameExpr.toCharArray();</span>
+<span class="fc" id="L821">                                    int valueDelimiterMatchLen = 0;</span>
+<span class="fc bfc" id="L822" title="All 2 branches covered.">                                    for (int i = 0; i &lt; varNameExprChars.length; i++) {</span>
                                         // if there's any nested variable when nested variable substitution disabled,
                                         // then stop resolving name and default value.
-<span class="fc bfc" id="L823" title="All 2 branches covered.">                                        if (!substitutionInVariablesEnabled</span>
-<span class="fc bfc" id="L824" title="All 2 branches covered.">                                                &amp;&amp; pfxMatcher.isMatch(varNameExprChars,</span>
+<span class="fc bfc" id="L825" title="All 2 branches covered.">                                        if (!substitutionInVariablesEnabled</span>
+<span class="fc bfc" id="L826" title="All 2 branches covered.">                                                &amp;&amp; pfxMatcher.isMatch(varNameExprChars,</span>
                                                                         i,
                                                                         i,
                                                                         varNameExprChars.length) != 0) {
-<span class="fc" id="L828">                                            break;</span>
+<span class="fc" id="L830">                                            break;</span>
                                         }
-<span class="fc bfc" id="L830" title="All 2 branches covered.">                                        if (valueDelimMatcher.isMatch(varNameExprChars, i) != 0) {</span>
-<span class="fc" id="L831">                                            valueDelimiterMatchLen = valueDelimMatcher.isMatch(varNameExprChars, i);</span>
-<span class="fc" id="L832">                                            varName = varNameExpr.substring(0, i);</span>
-<span class="fc" id="L833">                                            varDefaultValue = varNameExpr.substring(i + valueDelimiterMatchLen);</span>
-<span class="fc" id="L834">                                            break;</span>
+<span class="fc bfc" id="L832" title="All 2 branches covered.">                                        if (valueDelimMatcher.isMatch(varNameExprChars, i) != 0) {</span>
+<span class="fc" id="L833">                                            valueDelimiterMatchLen = valueDelimMatcher.isMatch(varNameExprChars, i);</span>
+<span class="fc" id="L834">                                            varName = varNameExpr.substring(0, i);</span>
+<span class="fc" id="L835">                                            varDefaultValue = varNameExpr.substring(i + valueDelimiterMatchLen);</span>
+<span class="fc" id="L836">                                            break;</span>
                                         }
                                     }
                                 }
 
                                 // on the first call initialize priorVariables
-<span class="fc bfc" id="L840" title="All 2 branches covered.">                                if (priorVariables == null) {</span>
-<span class="fc" id="L841">                                    priorVariables = new ArrayList&lt;&gt;();</span>
-<span class="fc" id="L842">                                    priorVariables.add(new String(chars,</span>
+<span class="fc bfc" id="L842" title="All 2 branches covered.">                                if (priorVariables == null) {</span>
+<span class="fc" id="L843">                                    priorVariables = new ArrayList&lt;&gt;();</span>
+<span class="fc" id="L844">                                    priorVariables.add(new String(chars,</span>
                                             offset, length));
                                 }
 
                                 // handle cyclic substitution
-<span class="fc" id="L847">                                checkCyclicSubstitution(varName, priorVariables);</span>
-<span class="fc" id="L848">                                priorVariables.add(varName);</span>
+<span class="fc" id="L849">                                checkCyclicSubstitution(varName, priorVariables);</span>
+<span class="fc" id="L850">                                priorVariables.add(varName);</span>
 
                                 // resolve the variable
-<span class="fc" id="L851">                                String varValue = resolveVariable(varName, buf,</span>
+<span class="fc" id="L853">                                String varValue = resolveVariable(varName, buf,</span>
                                         startPos, endPos);
-<span class="fc bfc" id="L853" title="All 2 branches covered.">                                if (varValue == null) {</span>
-<span class="fc" id="L854">                                    varValue = varDefaultValue;</span>
+<span class="fc bfc" id="L855" title="All 2 branches covered.">                                if (varValue == null) {</span>
+<span class="fc" id="L856">                                    varValue = varDefaultValue;</span>
                                 }
-<span class="fc bfc" id="L856" title="All 2 branches covered.">                                if (varValue != null) {</span>
+<span class="fc bfc" id="L858" title="All 2 branches covered.">                                if (varValue != null) {</span>
                                     // recursive replace
-<span class="fc" id="L858">                                    final int varLen = varValue.length();</span>
-<span class="fc" id="L859">                                    buf.replace(startPos, endPos, varValue);</span>
-<span class="fc" id="L860">                                    altered = true;</span>
-<span class="fc" id="L861">                                    int change = substitute(buf, startPos,</span>
+<span class="fc" id="L860">                                    final int varLen = varValue.length();</span>
+<span class="fc" id="L861">                                    buf.replace(startPos, endPos, varValue);</span>
+<span class="fc" id="L862">                                    altered = true;</span>
+<span class="fc" id="L863">                                    int change = substitute(buf, startPos,</span>
                                             varLen, priorVariables);
-<span class="fc" id="L863">                                    change = change</span>
+<span class="fc" id="L865">                                    change = change</span>
                                             + varLen - (endPos - startPos);
-<span class="fc" id="L865">                                    pos += change;</span>
-<span class="fc" id="L866">                                    bufEnd += change;</span>
-<span class="fc" id="L867">                                    lengthChange += change;</span>
-<span class="fc" id="L868">                                    chars = buf.buffer; // in case buffer was</span>
+<span class="fc" id="L867">                                    pos += change;</span>
+<span class="fc" id="L868">                                    bufEnd += change;</span>
+<span class="fc" id="L869">                                    lengthChange += change;</span>
+<span class="fc" id="L870">                                    chars = buf.buffer; // in case buffer was</span>
                                                         // altered
                                 }
 
                                 // remove variable from the cyclic stack
-<span class="fc" id="L873">                                priorVariables</span>
-<span class="fc" id="L874">                                        .remove(priorVariables.size() - 1);</span>
-<span class="fc" id="L875">                                break;</span>
+<span class="fc" id="L875">                                priorVariables</span>
+<span class="fc" id="L876">                                        .remove(priorVariables.size() - 1);</span>
+<span class="fc" id="L877">                                break;</span>
                             }
-<span class="fc" id="L877">                            nestedVarCount--;</span>
-<span class="fc" id="L878">                            pos += endMatchLen;</span>
+<span class="fc" id="L879">                            nestedVarCount--;</span>
+<span class="fc" id="L880">                            pos += endMatchLen;</span>
                         }
                     }
                 }
             }
-<span class="fc" id="L883">        }</span>
-<span class="fc bfc" id="L884" title="All 2 branches covered.">        if (top) {</span>
-<span class="fc bfc" id="L885" title="All 2 branches covered.">            return altered ? 1 : 0;</span>
+<span class="fc" id="L885">        }</span>
+<span class="fc bfc" id="L886" title="All 2 branches covered.">        if (top) {</span>
+<span class="fc bfc" id="L887" title="All 2 branches covered.">            return altered ? 1 : 0;</span>
         }
-<span class="fc" id="L887">        return lengthChange;</span>
+<span class="fc" id="L889">        return lengthChange;</span>
     }
 
     /**
@@ -894,15 +896,15 @@ public class StrSubstitutor {
      * @param priorVariables  the list of prior variables
      */
     private void checkCyclicSubstitution(final String varName, final List&lt;String&gt; priorVariables) {
-<span class="fc bfc" id="L897" title="All 2 branches covered.">        if (!priorVariables.contains(varName)) {</span>
-<span class="fc" id="L898">            return;</span>
+<span class="fc bfc" id="L899" title="All 2 branches covered.">        if (!priorVariables.contains(varName)) {</span>
+<span class="fc" id="L900">            return;</span>
         }
-<span class="fc" id="L900">        final StrBuilder buf = new StrBuilder(256);</span>
-<span class="fc" id="L901">        buf.append(&quot;Infinite loop in property interpolation of &quot;);</span>
-<span class="fc" id="L902">        buf.append(priorVariables.remove(0));</span>
-<span class="fc" id="L903">        buf.append(&quot;: &quot;);</span>
-<span class="fc" id="L904">        buf.appendWithSeparators(priorVariables, &quot;-&gt;&quot;);</span>
-<span class="fc" id="L905">        throw new IllegalStateException(buf.toString());</span>
+<span class="fc" id="L902">        final StrBuilder buf = new StrBuilder(256);</span>
+<span class="fc" id="L903">        buf.append(&quot;Infinite loop in property interpolation of &quot;);</span>
+<span class="fc" id="L904">        buf.append(priorVariables.remove(0));</span>
+<span class="fc" id="L905">        buf.append(&quot;: &quot;);</span>
+<span class="fc" id="L906">        buf.appendWithSeparators(priorVariables, &quot;-&gt;&quot;);</span>
+<span class="fc" id="L907">        throw new IllegalStateException(buf.toString());</span>
     }
 
     /**
@@ -926,11 +928,11 @@ public class StrSubstitutor {
                                      final StrBuilder buf,
                                      final int startPos,
                                      final int endPos) {
-<span class="fc" id="L929">        final StrLookup&lt;?&gt; resolver = getVariableResolver();</span>
-<span class="fc bfc" id="L930" title="All 2 branches covered.">        if (resolver == null) {</span>
-<span class="fc" id="L931">            return null;</span>
+<span class="fc" id="L931">        final StrLookup&lt;?&gt; resolver = getVariableResolver();</span>
+<span class="fc bfc" id="L932" title="All 2 branches covered.">        if (resolver == null) {</span>
+<span class="fc" id="L933">            return null;</span>
         }
-<span class="fc" id="L933">        return resolver.lookup(variableName);</span>
+<span class="fc" id="L935">        return resolver.lookup(variableName);</span>
     }
 
     // Escape
@@ -941,7 +943,7 @@ public class StrSubstitutor {
      * @return the character used for escaping variable references
      */
     public char getEscapeChar() {
-<span class="fc" id="L944">        return this.escapeChar;</span>
+<span class="fc" id="L946">        return this.escapeChar;</span>
     }
 
     /**
@@ -952,28 +954,28 @@ public class StrSubstitutor {
      * @param escapeCharacter  the escape character (0 for disabling escaping)
      */
     public void setEscapeChar(final char escapeCharacter) {
-<span class="fc" id="L955">        this.escapeChar = escapeCharacter;</span>
-<span class="fc" id="L956">    }</span>
+<span class="fc" id="L957">        this.escapeChar = escapeCharacter;</span>
+<span class="fc" id="L958">    }</span>
 
     // Prefix
     //-----------------------------------------------------------------------
     /**
      * Gets the variable prefix matcher currently in use.
      * &lt;p&gt;
-     * The variable prefix is the characer or characters that identify the
+     * The variable prefix is the character or characters that identify the
      * start of a variable. This prefix is expressed in terms of a matcher
      * allowing advanced prefix matches.
      *
      * @return the prefix matcher in use
      */
     public StrMatcher getVariablePrefixMatcher() {
-<span class="fc" id="L970">        return prefixMatcher;</span>
+<span class="fc" id="L972">        return prefixMatcher;</span>
     }
 
     /**
      * Sets the variable prefix matcher currently in use.
      * &lt;p&gt;
-     * The variable prefix is the characer or characters that identify the
+     * The variable prefix is the character or characters that identify the
      * start of a variable. This prefix is expressed in terms of a matcher
      * allowing advanced prefix matches.
      *
@@ -982,9 +984,7 @@ public class StrSubstitutor {
      * @throws IllegalArgumentException if the prefix matcher is null
      */
     public StrSubstitutor setVariablePrefixMatcher(final StrMatcher prefixMatcher) {
-<span class="fc bfc" id="L985" title="All 2 branches covered.">        if (prefixMatcher == null) {</span>
-<span class="fc" id="L986">            throw new IllegalArgumentException(&quot;Variable prefix matcher must not be null!&quot;);</span>
-        }
+<span class="fc bfc" id="L987" title="All 2 branches covered.">        Validate.isTrue(prefixMatcher != null, &quot;Variable prefix matcher must not be null!&quot;);</span>
 <span class="fc" id="L988">        this.prefixMatcher = prefixMatcher;</span>
 <span class="fc" id="L989">        return this;</span>
     }
@@ -1006,7 +1006,7 @@ public class StrSubstitutor {
     /**
      * Sets the variable prefix to use.
      * &lt;p&gt;
-     * The variable prefix is the characer or characters that identify the
+     * The variable prefix is the character or characters that identify the
      * start of a variable. This method allows a string prefix to be easily set.
      *
      * @param prefix  the prefix for variables, not null
@@ -1014,10 +1014,8 @@ public class StrSubstitutor {
      * @throws IllegalArgumentException if the prefix is null
      */
     public StrSubstitutor setVariablePrefix(final String prefix) {
-<span class="fc bfc" id="L1017" title="All 2 branches covered.">       if (prefix == null) {</span>
-<span class="fc" id="L1018">            throw new IllegalArgumentException(&quot;Variable prefix must not be null!&quot;);</span>
-        }
-<span class="fc" id="L1020">        return setVariablePrefixMatcher(StrMatcher.stringMatcher(prefix));</span>
+<span class="fc bfc" id="L1017" title="All 2 branches covered.">        Validate.isTrue(prefix != null, &quot;Variable prefix must not be null!&quot;);</span>
+<span class="fc" id="L1018">        return setVariablePrefixMatcher(StrMatcher.stringMatcher(prefix));</span>
     }
 
     // Suffix
@@ -1025,20 +1023,20 @@ public class StrSubstitutor {
     /**
      * Gets the variable suffix matcher currently in use.
      * &lt;p&gt;
-     * The variable suffix is the characer or characters that identify the
+     * The variable suffix is the character or characters that identify the
      * end of a variable. This suffix is expressed in terms of a matcher
      * allowing advanced suffix matches.
      *
      * @return the suffix matcher in use
      */
     public StrMatcher getVariableSuffixMatcher() {
-<span class="fc" id="L1035">        return suffixMatcher;</span>
+<span class="fc" id="L1033">        return suffixMatcher;</span>
     }
 
     /**
      * Sets the variable suffix matcher currently in use.
      * &lt;p&gt;
-     * The variable suffix is the characer or characters that identify the
+     * The variable suffix is the character or characters that identify the
      * end of a variable. This suffix is expressed in terms of a matcher
      * allowing advanced suffix matches.
      *
@@ -1047,17 +1045,15 @@ public class StrSubstitutor {
      * @throws IllegalArgumentException if the suffix matcher is null
      */
     public StrSubstitutor setVariableSuffixMatcher(final StrMatcher suffixMatcher) {
-<span class="fc bfc" id="L1050" title="All 2 branches covered.">        if (suffixMatcher == null) {</span>
-<span class="fc" id="L1051">            throw new IllegalArgumentException(&quot;Variable suffix matcher must not be null!&quot;);</span>
-        }
-<span class="fc" id="L1053">        this.suffixMatcher = suffixMatcher;</span>
-<span class="fc" id="L1054">        return this;</span>
+<span class="fc bfc" id="L1048" title="All 2 branches covered.">        Validate.isTrue(suffixMatcher != null, &quot;Variable suffix matcher must not be null!&quot;);</span>
+<span class="fc" id="L1049">        this.suffixMatcher = suffixMatcher;</span>
+<span class="fc" id="L1050">        return this;</span>
     }
 
     /**
      * Sets the variable suffix to use.
      * &lt;p&gt;
-     * The variable suffix is the characer or characters that identify the
+     * The variable suffix is the character or characters that identify the
      * end of a variable. This method allows a single character suffix to
      * be easily set.
      *
@@ -1065,7 +1061,7 @@ public class StrSubstitutor {
      * @return this, to enable chaining
      */
     public StrSubstitutor setVariableSuffix(final char suffix) {
-<span class="fc" id="L1068">        return setVariableSuffixMatcher(StrMatcher.charMatcher(suffix));</span>
+<span class="fc" id="L1064">        return setVariableSuffixMatcher(StrMatcher.charMatcher(suffix));</span>
     }
 
     /**
@@ -1079,10 +1075,8 @@ public class StrSubstitutor {
      * @throws IllegalArgumentException if the suffix is null
      */
     public StrSubstitutor setVariableSuffix(final String suffix) {
-<span class="fc bfc" id="L1082" title="All 2 branches covered.">       if (suffix == null) {</span>
-<span class="fc" id="L1083">            throw new IllegalArgumentException(&quot;Variable suffix must not be null!&quot;);</span>
-        }
-<span class="fc" id="L1085">        return setVariableSuffixMatcher(StrMatcher.stringMatcher(suffix));</span>
+<span class="fc bfc" id="L1078" title="All 2 branches covered.">        Validate.isTrue(suffix != null, &quot;Variable suffix must not be null!&quot;);</span>
+<span class="fc" id="L1079">        return setVariableSuffixMatcher(StrMatcher.stringMatcher(suffix));</span>
     }
 
     // Variable Default Value Delimiter
@@ -1090,7 +1084,7 @@ public class StrSubstitutor {
     /**
      * Gets the variable default value delimiter matcher currently in use.
      * &lt;p&gt;
-     * The variable default value delimiter is the characer or characters that delimite the
+     * The variable default value delimiter is the character or characters that delimite the
      * variable name and the variable default value. This delimiter is expressed in terms of a matcher
      * allowing advanced variable default value delimiter matches.
      * &lt;p&gt;
@@ -1099,13 +1093,13 @@ public class StrSubstitutor {
      * @return the variable default value delimiter matcher in use, may be null
      */
     public StrMatcher getValueDelimiterMatcher() {
-<span class="fc" id="L1102">        return valueDelimiterMatcher;</span>
+<span class="fc" id="L1096">        return valueDelimiterMatcher;</span>
     }
 
     /**
      * Sets the variable default value delimiter matcher to use.
      * &lt;p&gt;
-     * The variable default value delimiter is the characer or characters that delimite the
+     * The variable default value delimiter is the character or characters that delimite the
      * variable name and the variable default value. This delimiter is expressed in terms of a matcher
      * allowing advanced variable default value delimiter matches.
      * &lt;p&gt;
@@ -1116,14 +1110,14 @@ public class StrSubstitutor {
      * @return this, to enable chaining
      */
     public StrSubstitutor setValueDelimiterMatcher(final StrMatcher valueDelimiterMatcher) {
-<span class="fc" id="L1119">        this.valueDelimiterMatcher = valueDelimiterMatcher;</span>
-<span class="fc" id="L1120">        return this;</span>
+<span class="fc" id="L1113">        this.valueDelimiterMatcher = valueDelimiterMatcher;</span>
+<span class="fc" id="L1114">        return this;</span>
     }
 
     /**
      * Sets the variable default value delimiter to use.
      * &lt;p&gt;
-     * The variable default value delimiter is the characer or characters that delimite the
+     * The variable default value delimiter is the character or characters that delimite the
      * variable name and the variable default value. This method allows a single character
      * variable default value delimiter to be easily set.
      *
@@ -1131,13 +1125,13 @@ public class StrSubstitutor {
      * @return this, to enable chaining
      */
     public StrSubstitutor setValueDelimiter(final char valueDelimiter) {
-<span class="fc" id="L1134">        return setValueDelimiterMatcher(StrMatcher.charMatcher(valueDelimiter));</span>
+<span class="fc" id="L1128">        return setValueDelimiterMatcher(StrMatcher.charMatcher(valueDelimiter));</span>
     }
 
     /**
      * Sets the variable default value delimiter to use.
      * &lt;p&gt;
-     * The variable default value delimiter is the characer or characters that delimite the
+     * The variable default value delimiter is the character or characters that delimite the
      * variable name and the variable default value. This method allows a string
      * variable default value delimiter to be easily set.
      * &lt;p&gt;
@@ -1148,11 +1142,11 @@ public class StrSubstitutor {
      * @return this, to enable chaining
      */
     public StrSubstitutor setValueDelimiter(final String valueDelimiter) {
-<span class="fc bfc" id="L1151" title="All 4 branches covered.">        if (valueDelimiter == null || valueDelimiter.length() == 0) {</span>
-<span class="fc" id="L1152">            setValueDelimiterMatcher(null);</span>
-<span class="fc" id="L1153">            return this;</span>
+<span class="fc bfc" id="L1145" title="All 4 branches covered.">        if (valueDelimiter == null || valueDelimiter.length() == 0) {</span>
+<span class="fc" id="L1146">            setValueDelimiterMatcher(null);</span>
+<span class="fc" id="L1147">            return this;</span>
         }
-<span class="fc" id="L1155">        return setValueDelimiterMatcher(StrMatcher.stringMatcher(valueDelimiter));</span>
+<span class="fc" id="L1149">        return setValueDelimiterMatcher(StrMatcher.stringMatcher(valueDelimiter));</span>
     }
 
     // Resolver
@@ -1163,7 +1157,7 @@ public class StrSubstitutor {
      * @return the VariableResolver
      */
     public StrLookup&lt;?&gt; getVariableResolver() {
-<span class="fc" id="L1166">        return this.variableResolver;</span>
+<span class="fc" id="L1160">        return this.variableResolver;</span>
     }
 
     /**
@@ -1172,8 +1166,8 @@ public class StrSubstitutor {
      * @param variableResolver  the VariableResolver
      */
     public void setVariableResolver(final StrLookup&lt;?&gt; variableResolver) {
-<span class="fc" id="L1175">        this.variableResolver = variableResolver;</span>
-<span class="fc" id="L1176">    }</span>
+<span class="fc" id="L1169">        this.variableResolver = variableResolver;</span>
+<span class="fc" id="L1170">    }</span>
 
     // Substitution support in variable names
     //-----------------------------------------------------------------------
@@ -1183,7 +1177,7 @@ public class StrSubstitutor {
      * @return the substitution in variable names flag
      */
     public boolean isEnableSubstitutionInVariables() {
-<span class="fc" id="L1186">        return enableSubstitutionInVariables;</span>
+<span class="fc" id="L1180">        return enableSubstitutionInVariables;</span>
     }
 
     /**
@@ -1196,8 +1190,8 @@ public class StrSubstitutor {
      */
     public void setEnableSubstitutionInVariables(
             final boolean enableSubstitutionInVariables) {
-<span class="fc" id="L1199">        this.enableSubstitutionInVariables = enableSubstitutionInVariables;</span>
-<span class="fc" id="L1200">    }</span>
+<span class="fc" id="L1193">        this.enableSubstitutionInVariables = enableSubstitutionInVariables;</span>
+<span class="fc" id="L1194">    }</span>
 
     /**
      * Returns the flag controlling whether escapes are preserved during
@@ -1206,7 +1200,7 @@ public class StrSubstitutor {
      * @return the preserve escape flag
      */
     public boolean isPreserveEscapes() {
-<span class="fc" id="L1209">        return preserveEscapes;</span>
+<span class="fc" id="L1203">        return preserveEscapes;</span>
     }
 
     /**
@@ -1221,7 +1215,7 @@ public class StrSubstitutor {
      * @param preserveEscapes true if escapes are to be preserved
      */
     public void setPreserveEscapes(final boolean preserveEscapes) {
-<span class="fc" id="L1224">        this.preserveEscapes = preserveEscapes;</span>
-<span class="fc" id="L1225">    }</span>
+<span class="fc" id="L1218">        this.preserveEscapes = preserveEscapes;</span>
+<span class="fc" id="L1219">    }</span>
 }
 </pre><div class="footer"><span class="right">Created with <a href="http://www.jacoco.org/jacoco">JaCoCo</a> 0.7.8.201612092310</span></div></body></html>
\ No newline at end of file

Added: websites/production/commons/content/proper/commons-text/jacoco/org.apache.commons.text/WordUtils.html
==============================================================================
--- websites/production/commons/content/proper/commons-text/jacoco/org.apache.commons.text/WordUtils.html (added)
+++ websites/production/commons/content/proper/commons-text/jacoco/org.apache.commons.text/WordUtils.html Tue May 23 13:12:41 2017
@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"><html xmlns="http://www.w3.org/1999/xhtml" lang="en"><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8"/><link rel="stylesheet" href="../jacoco-resources/report.css" type="text/css"/><link rel="shortcut icon" href="../jacoco-resources/report.gif" type="image/gif"/><title>WordUtils</title><script type="text/javascript" src="../jacoco-resources/sort.js"></script></head><body onload="initialSort(['breadcrumb'])"><div class="breadcrumb" id="breadcrumb"><span class="info"><a href="../jacoco-sessions.html" class="el_session">Sessions</a></span><a href="../index.html" class="el_report">Apache Commons Text</a> &gt; <a href="index.html" class="el_package">org.apache.commons.text</a> &gt; <span class="el_class">WordUtils</span></div><h1>WordUtils</h1><table class="coverage" cellspacing="0" id="coveragetable"><thead><tr><td clas
 s="sortable" id="a" onclick="toggleSort(this)">Element</td><td class="down sortable bar" id="b" onclick="toggleSort(this)">Missed Instructions</td><td class="sortable ctr2" id="c" onclick="toggleSort(this)">Cov.</td><td class="sortable bar" id="d" onclick="toggleSort(this)">Missed Branches</td><td class="sortable ctr2" id="e" onclick="toggleSort(this)">Cov.</td><td class="sortable ctr1" id="f" onclick="toggleSort(this)">Missed</td><td class="sortable ctr2" id="g" onclick="toggleSort(this)">Cxty</td><td class="sortable ctr1" id="h" onclick="toggleSort(this)">Missed</td><td class="sortable ctr2" id="i" onclick="toggleSort(this)">Lines</td><td class="sortable ctr1" id="j" onclick="toggleSort(this)">Missed</td><td class="sortable ctr2" id="k" onclick="toggleSort(this)">Methods</td></tr></thead><tfoot><tr><td>Total</td><td class="bar">0 of 748</td><td class="ctr2">100%</td><td class="bar">1 of 122</td><td class="ctr2">99%</td><td class="ctr1">1</td><td class="ctr2">78</td><td class="ctr1
 ">0</td><td class="ctr2">187</td><td class="ctr1">0</td><td class="ctr2">17</td></tr></tfoot><tbody><tr><td id="a16"><a href="WordUtils.java.html#L280" class="el_method">wrap(String, int, String, boolean, String)</a></td><td class="bar" id="b0"><img src="../jacoco-resources/greenbar.gif" width="120" height="10" title="176" alt="176"/></td><td class="ctr2" id="c0">100%</td><td class="bar" id="d1"><img src="../jacoco-resources/greenbar.gif" width="120" height="10" title="26" alt="26"/></td><td class="ctr2" id="e0">100%</td><td class="ctr1" id="f1">0</td><td class="ctr2" id="g0">14</td><td class="ctr1" id="h0">0</td><td class="ctr2" id="i0">45</td><td class="ctr1" id="j0">0</td><td class="ctr2" id="k0">1</td></tr><tr><td id="a0"><a href="WordUtils.java.html#L829" class="el_method">abbreviate(String, int, int, String)</a></td><td class="bar" id="b1"><img src="../jacoco-resources/greenbar.gif" width="71" height="10" title="105" alt="105"/></td><td class="ctr2" id="c1">100%</td><td class=
 "bar" id="d2"><img src="../jacoco-resources/greenbar.gif" width="92" height="10" title="20" alt="20"/></td><td class="ctr2" id="e1">100%</td><td class="ctr1" id="f2">0</td><td class="ctr2" id="g1">11</td><td class="ctr1" id="h1">0</td><td class="ctr2" id="i4">20</td><td class="ctr1" id="j1">0</td><td class="ctr2" id="k1">1</td></tr><tr><td id="a2"><a href="WordUtils.java.html#L414" class="el_method">capitalize(String, char[])</a></td><td class="bar" id="b2"><img src="../jacoco-resources/greenbar.gif" width="58" height="10" title="86" alt="86"/></td><td class="ctr2" id="c2">100%</td><td class="bar" id="d3"><img src="../jacoco-resources/greenbar.gif" width="55" height="10" title="12" alt="12"/></td><td class="ctr2" id="e2">100%</td><td class="ctr1" id="f3">0</td><td class="ctr2" id="g2">7</td><td class="ctr1" id="h2">0</td><td class="ctr2" id="i2">23</td><td class="ctr1" id="j2">0</td><td class="ctr2" id="k2">1</td></tr><tr><td id="a12"><a href="WordUtils.java.html#L548" class="el_met
 hod">uncapitalize(String, char[])</a></td><td class="bar" id="b3"><img src="../jacoco-resources/greenbar.gif" width="58" height="10" title="86" alt="86"/></td><td class="ctr2" id="c3">100%</td><td class="bar" id="d4"><img src="../jacoco-resources/greenbar.gif" width="55" height="10" title="12" alt="12"/></td><td class="ctr2" id="e3">100%</td><td class="ctr1" id="f4">0</td><td class="ctr2" id="g3">7</td><td class="ctr1" id="h3">0</td><td class="ctr2" id="i3">23</td><td class="ctr1" id="j3">0</td><td class="ctr2" id="k3">1</td></tr><tr><td id="a10"><a href="WordUtils.java.html#L601" class="el_method">swapCase(String)</a></td><td class="bar" id="b4"><img src="../jacoco-resources/greenbar.gif" width="54" height="10" title="80" alt="80"/></td><td class="ctr2" id="c4">100%</td><td class="bar" id="d5"><img src="../jacoco-resources/greenbar.gif" width="55" height="10" title="12" alt="12"/></td><td class="ctr2" id="e4">100%</td><td class="ctr1" id="f5">0</td><td class="ctr2" id="g4">7</td><t
 d class="ctr1" id="h4">0</td><td class="ctr2" id="i1">25</td><td class="ctr1" id="j4">0</td><td class="ctr2" id="k4">1</td></tr><tr><td id="a7"><a href="WordUtils.java.html#L685" class="el_method">initials(String, char[])</a></td><td class="bar" id="b5"><img src="../jacoco-resources/greenbar.gif" width="40" height="10" title="60" alt="60"/></td><td class="ctr2" id="c5">100%</td><td class="bar" id="d6"><img src="../jacoco-resources/greenbar.gif" width="55" height="10" title="12" alt="12"/></td><td class="ctr2" id="e5">100%</td><td class="ctr1" id="f6">0</td><td class="ctr2" id="g5">7</td><td class="ctr1" id="h5">0</td><td class="ctr2" id="i5">16</td><td class="ctr1" id="j5">0</td><td class="ctr2" id="k5">1</td></tr><tr><td id="a5"><a href="WordUtils.java.html#L733" class="el_method">containsAllWords(CharSequence, CharSequence[])</a></td><td class="bar" id="b6"><img src="../jacoco-resources/greenbar.gif" width="34" height="10" title="50" alt="50"/></td><td class="ctr2" id="c6">100%</t
 d><td class="bar" id="d0"><img src="../jacoco-resources/redbar.gif" width="4" height="10" title="1" alt="1"/><img src="../jacoco-resources/greenbar.gif" width="41" height="10" title="9" alt="9"/></td><td class="ctr2" id="e9">90%</td><td class="ctr1" id="f0">1</td><td class="ctr2" id="g6">6</td><td class="ctr1" id="h6">0</td><td class="ctr2" id="i6">9</td><td class="ctr1" id="j6">0</td><td class="ctr2" id="k6">1</td></tr><tr><td id="a8"><a href="WordUtils.java.html#L757" class="el_method">isDelimiter(char, char[])</a></td><td class="bar" id="b7"><img src="../jacoco-resources/greenbar.gif" width="19" height="10" title="28" alt="28"/></td><td class="ctr2" id="c7">100%</td><td class="bar" id="d7"><img src="../jacoco-resources/greenbar.gif" width="27" height="10" title="6" alt="6"/></td><td class="ctr2" id="e6">100%</td><td class="ctr1" id="f7">0</td><td class="ctr2" id="g7">4</td><td class="ctr1" id="h7">0</td><td class="ctr2" id="i8">6</td><td class="ctr1" id="j7">0</td><td class="ctr2
 " id="k7">1</td></tr><tr><td id="a9"><a href="WordUtils.java.html#L777" class="el_method">isDelimiter(int, char[])</a></td><td class="bar" id="b8"><img src="../jacoco-resources/greenbar.gif" width="16" height="10" title="24" alt="24"/></td><td class="ctr2" id="c8">100%</td><td class="bar" id="d8"><img src="../jacoco-resources/greenbar.gif" width="27" height="10" title="6" alt="6"/></td><td class="ctr2" id="e7">100%</td><td class="ctr1" id="f8">0</td><td class="ctr2" id="g8">4</td><td class="ctr1" id="h8">0</td><td class="ctr2" id="i7">7</td><td class="ctr1" id="j8">0</td><td class="ctr2" id="k8">1</td></tr><tr><td id="a4"><a href="WordUtils.java.html#L493" class="el_method">capitalizeFully(String, char[])</a></td><td class="bar" id="b9"><img src="../jacoco-resources/greenbar.gif" width="14" height="10" title="21" alt="21"/></td><td class="ctr2" id="c9">100%</td><td class="bar" id="d9"><img src="../jacoco-resources/greenbar.gif" width="27" height="10" title="6" alt="6"/></td><td clas
 s="ctr2" id="e8">100%</td><td class="ctr1" id="f9">0</td><td class="ctr2" id="g9">4</td><td class="ctr1" id="h9">0</td><td class="ctr2" id="i9">5</td><td class="ctr1" id="j9">0</td><td class="ctr2" id="k9">1</td></tr><tr><td id="a15"><a href="WordUtils.java.html#L181" class="el_method">wrap(String, int, String, boolean)</a></td><td class="bar" id="b10"><img src="../jacoco-resources/greenbar.gif" width="4" height="10" title="7" alt="7"/></td><td class="ctr2" id="c10">100%</td><td class="bar" id="d10"/><td class="ctr2" id="e10">n/a</td><td class="ctr1" id="f10">0</td><td class="ctr2" id="g10">1</td><td class="ctr1" id="h10">0</td><td class="ctr2" id="i11">1</td><td class="ctr1" id="j10">0</td><td class="ctr2" id="k10">1</td></tr><tr><td id="a14"><a href="WordUtils.java.html#L100" class="el_method">wrap(String, int)</a></td><td class="bar" id="b11"><img src="../jacoco-resources/greenbar.gif" width="4" height="10" title="6" alt="6"/></td><td class="ctr2" id="c11">100%</td><td class="bar
 " id="d11"/><td class="ctr2" id="e11">n/a</td><td class="ctr1" id="f11">0</td><td class="ctr2" id="g11">1</td><td class="ctr1" id="h11">0</td><td class="ctr2" id="i12">1</td><td class="ctr1" id="j11">0</td><td class="ctr2" id="k11">1</td></tr><tr><td id="a1"><a href="WordUtils.java.html#L382" class="el_method">capitalize(String)</a></td><td class="bar" id="b12"><img src="../jacoco-resources/greenbar.gif" width="2" height="10" title="4" alt="4"/></td><td class="ctr2" id="c12">100%</td><td class="bar" id="d12"/><td class="ctr2" id="e12">n/a</td><td class="ctr1" id="f12">0</td><td class="ctr2" id="g12">1</td><td class="ctr1" id="h12">0</td><td class="ctr2" id="i13">1</td><td class="ctr1" id="j12">0</td><td class="ctr2" id="k12">1</td></tr><tr><td id="a3"><a href="WordUtils.java.html#L464" class="el_method">capitalizeFully(String)</a></td><td class="bar" id="b13"><img src="../jacoco-resources/greenbar.gif" width="2" height="10" title="4" alt="4"/></td><td class="ctr2" id="c13">100%</td>
 <td class="bar" id="d13"/><td class="ctr2" id="e13">n/a</td><td class="ctr1" id="f13">0</td><td class="ctr2" id="g13">1</td><td class="ctr1" id="h13">0</td><td class="ctr2" id="i14">1</td><td class="ctr1" id="j13">0</td><td class="ctr2" id="k13">1</td></tr><tr><td id="a11"><a href="WordUtils.java.html#L520" class="el_method">uncapitalize(String)</a></td><td class="bar" id="b14"><img src="../jacoco-resources/greenbar.gif" width="2" height="10" title="4" alt="4"/></td><td class="ctr2" id="c14">100%</td><td class="bar" id="d14"/><td class="ctr2" id="e14">n/a</td><td class="ctr1" id="f14">0</td><td class="ctr2" id="g14">1</td><td class="ctr1" id="h14">0</td><td class="ctr2" id="i15">1</td><td class="ctr1" id="j14">0</td><td class="ctr2" id="k14">1</td></tr><tr><td id="a6"><a href="WordUtils.java.html#L656" class="el_method">initials(String)</a></td><td class="bar" id="b15"><img src="../jacoco-resources/greenbar.gif" width="2" height="10" title="4" alt="4"/></td><td class="ctr2" id="c15"
 >100%</td><td class="bar" id="d15"/><td class="ctr2" id="e15">n/a</td><td class="ctr1" id="f15">0</td><td class="ctr2" id="g15">1</td><td class="ctr1" id="h15">0</td><td class="ctr2" id="i16">1</td><td class="ctr1" id="j15">0</td><td class="ctr2" id="k15">1</td></tr><tr><td id="a13"><a href="WordUtils.java.html#L46" class="el_method">WordUtils()</a></td><td class="bar" id="b16"><img src="../jacoco-resources/greenbar.gif" width="2" height="10" title="3" alt="3"/></td><td class="ctr2" id="c16">100%</td><td class="bar" id="d16"/><td class="ctr2" id="e16">n/a</td><td class="ctr1" id="f16">0</td><td class="ctr2" id="g16">1</td><td class="ctr1" id="h16">0</td><td class="ctr2" id="i10">2</td><td class="ctr1" id="j16">0</td><td class="ctr2" id="k16">1</td></tr></tbody></table><div class="footer"><span class="right">Created with <a href="http://www.jacoco.org/jacoco">JaCoCo</a> 0.7.8.201612092310</span></div></body></html>
\ No newline at end of file



Mime
View raw message