From c14e41637db7b2d4d87b905db4c306268bc0319b Mon Sep 17 00:00:00 2001
From: ifly6 <ifly6@me.com>
Date: Sun, 13 Dec 2020 14:31:17 -0500
Subject: [PATCH 01/10] numeric entity unescaper new behaviour in range [128,
 159]

for that range, translate to Windows 1252 encoding; re-throw illegal argument exception with input if restrictions are violated

add test which tests numeric entities that are improperly encoded in cp-1252 and including code points before and after range [128, 159].

algorithm for numeric entity applies in very restrictive conditions: it must be in the range where ISO 8859-1 and Windows-1252 decohere, it must be a non-hex numeric entity (this is to avoid tripping one of StringEscapeUtilsTests), it must also not be an invalid Windows-1252 point in that range.
---
 .../translate/NumericEntityUnescaper.java     | 37 ++++++++++-
 .../commons/text/StringEscapeUtilsTest.java   | 64 ++++++++++++++-----
 2 files changed, 85 insertions(+), 16 deletions(-)

diff --git a/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java b/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java
index d41e5b54b2..795e7de6cc 100644
--- a/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java
+++ b/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java
@@ -18,8 +18,13 @@
 
 import java.io.IOException;
 import java.io.Writer;
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.nio.charset.CodingErrorAction;
 import java.util.Arrays;
 import java.util.EnumSet;
+import java.util.HashSet;
+import java.util.Set;
 
 /**
  * Translate XML numeric entities of the form &amp;#[xX]?\d+;? to
@@ -53,6 +58,9 @@ public enum OPTION {
     /** EnumSet of OPTIONS, given from the constructor. */
     private final EnumSet<OPTION> options;
 
+    /** Code points which are invalid Windows-1252 points. */
+    private static final Set<Integer> INVALID_POINTS = new HashSet<>(Arrays.asList(129, 141, 143, 144, 157));
+
     /**
      * Create a UnicodeUnescaper.
      *
@@ -128,7 +136,7 @@ public int translate(final CharSequence input, final int index, final Writer out
                 }
             }
 
-            int entityValue;
+            final int entityValue;
             try {
                 if (isHex) {
                     entityValue = Integer.parseInt(input.subSequence(start, end).toString(), 16);
@@ -143,8 +151,35 @@ public int translate(final CharSequence input, final int index, final Writer out
                 final char[] chrs = Character.toChars(entityValue);
                 out.write(chrs[0]);
                 out.write(chrs[1]);
+
+            } else if (128 <= entityValue && entityValue <= 159  // must be within the windows-1252 extension range
+                    && !isHex  // must be a NUMERIC entity, not hex entity (see StringEscapeUtilsTest for hex)
+                    && !INVALID_POINTS.contains(entityValue)  // must not be an invalid code point for windows-1252
+            ) {
+                System.err.println(entityValue);
+                try {
+                    final String newChar = Charset.forName("Windows-1252").newDecoder()
+                            .onMalformedInput(CodingErrorAction.REPORT)
+                            .onUnmappableCharacter(CodingErrorAction.REPORT)
+                            .decode(ByteBuffer.wrap(new byte[] {(byte) entityValue}))
+                            .toString();
+                    out.write(newChar);
+
+                } catch (final IllegalArgumentException e) {
+                    /*
+                     * Rethrow exception with causal input, as throw from Charset.decode does not include it.
+                     *
+                     * That said, the input should always be a valid byte due to the restrictions that are imposed by
+                     * the if statement; all characters should be mappable as well, as entity values that are not so are
+                     * excluded by the if statement. If something happens to violate the restrictions meant to ensure
+                     * that translation is valid and should always work, user ought to know.
+                     */
+                    throw new IllegalArgumentException(String.format("input %s is malformed input", e));
+                }
+
             } else {
                 out.write(entityValue);
+
             }
 
             return 2 + end - start + (isHex ? 1 : 0) + (semiNext ? 1 : 0);
diff --git a/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java b/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java
index d0c6ef5288..6145de61e0 100644
--- a/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java
+++ b/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java
@@ -49,6 +49,7 @@ public class StringEscapeUtilsTest {
     private static final String FOO = "foo";
 
     private static final String[][] HTML_ESCAPES = {
+            // name, expected, original
             {"no escaping", "plain text", "plain text"},
             {"no escaping", "plain text", "plain text"},
             {"empty string", "", ""},
@@ -63,6 +64,24 @@ public class StringEscapeUtilsTest {
             {"8-bit ascii shouldn't number-escape", "\u0080\u009F", "\u0080\u009F"},
     };
 
+    private static final String[][] HTML_ESCAPES_ONEWAY = {
+            // name, expected, original
+            /* these are one-way tests; ie they are only decoded. because HTML says to re-encode with unicode points
+             * instead of CP-1252 points and we probably ought to prefer named entities if possible, they should not
+             * be re-encoded regardless. */
+            {
+                    // try a series of characters before, through, and after the cp-1252 inconsistency range
+                    // assume HTML numeric entities are encoded as cp-1252 code points
+                    "cp1252",
+                    "&#124;&#125;&#126;&#128;&#130;&#131;&#132;&#133;&#134;&#135;&#136;&#137;&#138;&#139;&#140;" +
+                            "&#142;&#145;&#146;&#147;&#148;&#149;&#150;&#151;&#152;&#153;&#154;&#155;&#156;&#158;" +
+                            "&#159;&#161;&#162;&#163;",
+                    "\u007c\u007d\u007e\u20ac\u201a\u0192\u201e\u2026\u2020\u2021\u02c6\u2030\u0160\u2039\u0152" +
+                            "\u017d\u2018\u2019\u201c\u201d\u2022\u2013\u2014\u02dc\u2122\u0161\u203a\u0153\u017e" +
+                            "\u0178\u00a1\u00a2\u00a3"
+            }
+    };
+
     private void assertEscapeJava(final String escaped, final String original) throws IOException {
         assertEscapeJava(escaped, original, null);
     }
@@ -226,26 +245,41 @@ public void testEscapeHtml3() {
             final String actual = original == null ? null : sw.toString();
             assertEquals(expected, actual, message);
         }
+
+        for (final String[] e : HTML_ESCAPES_ONEWAY) {
+            final String message = e[0];
+            final String input = e[1];
+            final String answer = e[2];
+            assertEquals(answer, StringEscapeUtils.unescapeHtml3(input), message);
+        }
+
     }
 
     @Test
-        public void testEscapeHtml4() {
-            for (final String[] element : HTML_ESCAPES) {
-                final String message = element[0];
-                final String expected = element[1];
-                final String original = element[2];
-                assertEquals(expected, StringEscapeUtils.escapeHtml4(original), message);
-                final StringWriter sw = new StringWriter();
-                try {
-                    StringEscapeUtils.ESCAPE_HTML4.translate(original, sw);
-                } catch (final IOException e) {
-                    // expected
-                }
-                final String actual = original == null ? null : sw.toString();
-                assertEquals(expected, actual, message);
+    public void testEscapeHtml4() {
+        for (final String[] element : HTML_ESCAPES) {
+            final String message = element[0];
+            final String expected = element[1];
+            final String original = element[2];
+            assertEquals(expected, StringEscapeUtils.escapeHtml4(original), message);
+            final StringWriter sw = new StringWriter();
+            try {
+                StringEscapeUtils.ESCAPE_HTML4.translate(original, sw);
+            } catch (final IOException e) {
+                // expected
             }
+            final String actual = original == null ? null : sw.toString();
+            assertEquals(expected, actual, message);
         }
 
+        for (final String[] e : HTML_ESCAPES_ONEWAY) {
+            final String message = e[0];
+            final String input = e[1];
+            final String answer = e[2];
+            assertEquals(answer, StringEscapeUtils.unescapeHtml4(input), message);
+        }
+    }
+
     /**
      * Tests // https://issues.apache.org/jira/browse/LANG-480
      */
@@ -257,7 +291,7 @@ public void testEscapeHtmlHighUnicode() {
         // codepoint: U+1D362
         final byte[] data = {(byte) 0xF0, (byte) 0x9D, (byte) 0x8D, (byte) 0xA2};
 
-        final String original = new String(data, Charset.forName("UTF8"));
+        final String original = new String(data, StandardCharsets.UTF_8);
 
         final String escaped = StringEscapeUtils.escapeHtml4(original);
         assertEquals(original, escaped, "High Unicode should not have been escaped");

From 7d222b4409d489eaecc54340ff0e977326c1d695 Mon Sep 17 00:00:00 2001
From: ifly6 <ifly6@me.com>
Date: Sun, 13 Dec 2020 14:35:19 -0500
Subject: [PATCH 02/10] clarify the test added

---
 .../java/org/apache/commons/text/StringEscapeUtilsTest.java    | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java b/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java
index 6145de61e0..6bf418570b 100644
--- a/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java
+++ b/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java
@@ -70,8 +70,7 @@ public class StringEscapeUtilsTest {
              * instead of CP-1252 points and we probably ought to prefer named entities if possible, they should not
              * be re-encoded regardless. */
             {
-                    // try a series of characters before, through, and after the cp-1252 inconsistency range
-                    // assume HTML numeric entities are encoded as cp-1252 code points
+                    // tests for all CP-1252 characters between 128 and 159, with chars 123-126 and chars 161-163
                     "cp1252",
                     "&#124;&#125;&#126;&#128;&#130;&#131;&#132;&#133;&#134;&#135;&#136;&#137;&#138;&#139;&#140;" +
                             "&#142;&#145;&#146;&#147;&#148;&#149;&#150;&#151;&#152;&#153;&#154;&#155;&#156;&#158;" +

From eaad9b137d9a4c103c5db4afff750a39b13942ae Mon Sep 17 00:00:00 2001
From: ifly6 <ifly6@me.com>
Date: Sun, 13 Dec 2020 14:47:43 -0500
Subject: [PATCH 03/10] Update NumericEntityUnescaper.java

invalid points shouldn't be modifiable
---
 .../apache/commons/text/translate/NumericEntityUnescaper.java | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java b/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java
index 795e7de6cc..ed4c2503c7 100644
--- a/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java
+++ b/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java
@@ -22,6 +22,7 @@
 import java.nio.charset.Charset;
 import java.nio.charset.CodingErrorAction;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.EnumSet;
 import java.util.HashSet;
 import java.util.Set;
@@ -59,7 +60,8 @@ public enum OPTION {
     private final EnumSet<OPTION> options;
 
     /** Code points which are invalid Windows-1252 points. */
-    private static final Set<Integer> INVALID_POINTS = new HashSet<>(Arrays.asList(129, 141, 143, 144, 157));
+    private static final Set<Integer> INVALID_POINTS =
+            Collections.unmodifiableSet(new HashSet<>(Arrays.asList(129, 141, 143, 144, 157)));
 
     /**
      * Create a UnicodeUnescaper.

From f473b6f970a183039b20e9ee2069bd23571604e7 Mon Sep 17 00:00:00 2001
From: ifly6 <ifly6@me.com>
Date: Sun, 13 Dec 2020 15:04:51 -0500
Subject: [PATCH 04/10] Update NumericEntityUnescaper.java

stopped creating a new decoder every time it is invoked; use static decoder instead.

renamed to cp-1252 to save characters; fixed documentation in the constructor. also reformatted it to match what i think was intended by original author
---
 .../translate/NumericEntityUnescaper.java     | 37 +++++++++++--------
 1 file changed, 21 insertions(+), 16 deletions(-)

diff --git a/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java b/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java
index ed4c2503c7..67072f0789 100644
--- a/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java
+++ b/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java
@@ -20,6 +20,7 @@
 import java.io.Writer;
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
 import java.nio.charset.CodingErrorAction;
 import java.util.Arrays;
 import java.util.Collections;
@@ -37,7 +38,7 @@
  */
 public class NumericEntityUnescaper extends CharSequenceTranslator {
 
-    /** Enumerates NumericEntityUnescaper options for unescaping. */
+    /** Enumerates {@code NumericEntityUnescaper} options for unescaping. */
     public enum OPTION {
 
         /**
@@ -60,22 +61,28 @@ public enum OPTION {
     private final EnumSet<OPTION> options;
 
     /** Code points which are invalid Windows-1252 points. */
-    private static final Set<Integer> INVALID_POINTS =
+    private static final Set<Integer> INVALID_CP1252_POINTS =
             Collections.unmodifiableSet(new HashSet<>(Arrays.asList(129, 141, 143, 144, 157)));
 
+    /** Decoder for Windows-1252 characters */
+    // Windows-1252 is supported. See https://docs.oracle.com/javase/8/docs/technotes/guides/intl/encoding.doc.html.
+    private static final CharsetDecoder CP_1252_DECODER = Charset.forName("Windows-1252").newDecoder()
+            .onMalformedInput(CodingErrorAction.REPORT)
+            .onUnmappableCharacter(CodingErrorAction.REPORT);
+
     /**
-     * Create a UnicodeUnescaper.
-     *
-     * The constructor takes a list of options, only one type of which is currently
-     * available (whether to allow, error or ignore the semi-colon on the end of a
+     * Create a {@code NumericEntityUnescaper}. The constructor takes a list of options, only one type of which is
+     * currently available (whether to allow, error or ignore the semi-colon on the end of a
      * numeric entity to being missing).
      *
-     * For example, to support numeric entities without a ';':
-     *    new NumericEntityUnescaper(NumericEntityUnescaper.OPTION.semiColonOptional)
-     * and to throw an IllegalArgumentException when they're missing:
-     *    new NumericEntityUnescaper(NumericEntityUnescaper.OPTION.errorIfNoSemiColon)
+     * <br />
+     * <p>For example, to support numeric entities without a ';':</p>
+     *    <ul><code>new NumericEntityUnescaper(NumericEntityUnescaper.OPTION.semiColonOptional)</code></ul>
+     *
+     * <p>and to throw an IllegalArgumentException when they're missing:</p>
+     *    <ul><code>new NumericEntityUnescaper(NumericEntityUnescaper.OPTION.errorIfNoSemiColon)</code></ul>
      *
-     * Note that the default behavior is to ignore them.
+     * <p>Note that the default behavior is to ignore them.</p>
      *
      * @param options to apply to this unescaper
      */
@@ -154,15 +161,13 @@ public int translate(final CharSequence input, final int index, final Writer out
                 out.write(chrs[0]);
                 out.write(chrs[1]);
 
-            } else if (128 <= entityValue && entityValue <= 159  // must be within the windows-1252 extension range
+            } else if (128 <= entityValue && entityValue <= 159  // must be within the cp-1252 extension range
                     && !isHex  // must be a NUMERIC entity, not hex entity (see StringEscapeUtilsTest for hex)
-                    && !INVALID_POINTS.contains(entityValue)  // must not be an invalid code point for windows-1252
+                    && !INVALID_CP1252_POINTS.contains(entityValue)  // must not be an invalid code point for cp-1252
             ) {
                 System.err.println(entityValue);
                 try {
-                    final String newChar = Charset.forName("Windows-1252").newDecoder()
-                            .onMalformedInput(CodingErrorAction.REPORT)
-                            .onUnmappableCharacter(CodingErrorAction.REPORT)
+                    final String newChar = CP_1252_DECODER
                             .decode(ByteBuffer.wrap(new byte[] {(byte) entityValue}))
                             .toString();
                     out.write(newChar);

From fc1b4f27858a8b735f2045203aeead31f4b6fd7b Mon Sep 17 00:00:00 2001
From: ifly6 <ifly6@me.com>
Date: Sun, 13 Dec 2020 15:15:16 -0500
Subject: [PATCH 05/10] fix javadoc

---
 .../commons/text/translate/NumericEntityUnescaper.java      | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java b/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java
index 67072f0789..471f513913 100644
--- a/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java
+++ b/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java
@@ -75,12 +75,12 @@ public enum OPTION {
      * currently available (whether to allow, error or ignore the semi-colon on the end of a
      * numeric entity to being missing).
      *
-     * <br />
+     * <br>
      * <p>For example, to support numeric entities without a ';':</p>
-     *    <ul><code>new NumericEntityUnescaper(NumericEntityUnescaper.OPTION.semiColonOptional)</code></ul>
+     *    <ul>{@code new NumericEntityUnescaper(NumericEntityUnescaper.OPTION.semiColonOptional)}</ul>
      *
      * <p>and to throw an IllegalArgumentException when they're missing:</p>
-     *    <ul><code>new NumericEntityUnescaper(NumericEntityUnescaper.OPTION.errorIfNoSemiColon)</code></ul>
+     *    <ul>{@code new NumericEntityUnescaper(NumericEntityUnescaper.OPTION.errorIfNoSemiColon)}</ul>
      *
      * <p>Note that the default behavior is to ignore them.</p>
      *

From b5244d0a0d64af22ce548ed9539519c995a2c501 Mon Sep 17 00:00:00 2001
From: ifly6 <ifly6@me.com>
Date: Sun, 13 Dec 2020 15:20:11 -0500
Subject: [PATCH 06/10] fix javadoc again

---
 .../apache/commons/text/translate/NumericEntityUnescaper.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java b/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java
index 471f513913..f15fb29910 100644
--- a/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java
+++ b/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java
@@ -77,10 +77,10 @@ public enum OPTION {
      *
      * <br>
      * <p>For example, to support numeric entities without a ';':</p>
-     *    <ul>{@code new NumericEntityUnescaper(NumericEntityUnescaper.OPTION.semiColonOptional)}</ul>
+     *     <pre>{@code new NumericEntityUnescaper(NumericEntityUnescaper.OPTION.semiColonOptional)}</pre>
      *
      * <p>and to throw an IllegalArgumentException when they're missing:</p>
-     *    <ul>{@code new NumericEntityUnescaper(NumericEntityUnescaper.OPTION.errorIfNoSemiColon)}</ul>
+     *     <pre>{@code new NumericEntityUnescaper(NumericEntityUnescaper.OPTION.errorIfNoSemiColon)}</pre>
      *
      * <p>Note that the default behavior is to ignore them.</p>
      *

From ab6a7902c4096dc31ca10d1e1e50c482b4611dc9 Mon Sep 17 00:00:00 2001
From: ifly6 <ifly6@me.com>
Date: Sun, 13 Dec 2020 15:33:55 -0500
Subject: [PATCH 07/10] fix check style violations

---
 .../text/translate/NumericEntityUnescaper.java       |  2 +-
 .../apache/commons/text/StringEscapeUtilsTest.java   | 12 ++++++------
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java b/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java
index f15fb29910..ea616aed14 100644
--- a/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java
+++ b/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java
@@ -64,7 +64,7 @@ public enum OPTION {
     private static final Set<Integer> INVALID_CP1252_POINTS =
             Collections.unmodifiableSet(new HashSet<>(Arrays.asList(129, 141, 143, 144, 157)));
 
-    /** Decoder for Windows-1252 characters */
+    /** Decoder for Windows-1252 characters. */
     // Windows-1252 is supported. See https://docs.oracle.com/javase/8/docs/technotes/guides/intl/encoding.doc.html.
     private static final CharsetDecoder CP_1252_DECODER = Charset.forName("Windows-1252").newDecoder()
             .onMalformedInput(CodingErrorAction.REPORT)
diff --git a/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java b/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java
index 6bf418570b..6052d09eae 100644
--- a/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java
+++ b/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java
@@ -72,12 +72,12 @@ public class StringEscapeUtilsTest {
             {
                     // tests for all CP-1252 characters between 128 and 159, with chars 123-126 and chars 161-163
                     "cp1252",
-                    "&#124;&#125;&#126;&#128;&#130;&#131;&#132;&#133;&#134;&#135;&#136;&#137;&#138;&#139;&#140;" +
-                            "&#142;&#145;&#146;&#147;&#148;&#149;&#150;&#151;&#152;&#153;&#154;&#155;&#156;&#158;" +
-                            "&#159;&#161;&#162;&#163;",
-                    "\u007c\u007d\u007e\u20ac\u201a\u0192\u201e\u2026\u2020\u2021\u02c6\u2030\u0160\u2039\u0152" +
-                            "\u017d\u2018\u2019\u201c\u201d\u2022\u2013\u2014\u02dc\u2122\u0161\u203a\u0153\u017e" +
-                            "\u0178\u00a1\u00a2\u00a3"
+                    "&#124;&#125;&#126;&#128;&#130;&#131;&#132;&#133;&#134;&#135;&#136;&#137;&#138;&#139;&#140;"
+                            + "&#142;&#145;&#146;&#147;&#148;&#149;&#150;&#151;&#152;&#153;&#154;&#155;&#156;&#158;"
+                            + "&#159;&#161;&#162;&#163;",
+                    "\u007c\u007d\u007e\u20ac\u201a\u0192\u201e\u2026\u2020\u2021\u02c6\u2030\u0160\u2039\u0152"
+                            + "\u017d\u2018\u2019\u201c\u201d\u2022\u2013\u2014\u02dc\u2122\u0161\u203a\u0153\u017e"
+                            + "\u0178\u00a1\u00a2\u00a3"
             }
     };
 

From c66e327c5f8cf3c5cc4de0ca5ce44544bd475f15 Mon Sep 17 00:00:00 2001
From: ifly6 <ifly6@me.com>
Date: Sun, 13 Dec 2020 15:37:45 -0500
Subject: [PATCH 08/10] fix check style violation

---
 src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java b/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java
index 6052d09eae..59cc52fcbe 100644
--- a/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java
+++ b/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java
@@ -30,7 +30,6 @@
 import java.io.StringWriter;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Modifier;
-import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Paths;

From 033cff718cf45558929f38d0c10f79cee71618ba Mon Sep 17 00:00:00 2001
From: ifly6 <ifly6@me.com>
Date: Sun, 13 Dec 2020 15:41:45 -0500
Subject: [PATCH 09/10] code style change

capitalise the unicode escapes in the test because that seems to be the prevailing code style
---
 .../java/org/apache/commons/text/StringEscapeUtilsTest.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java b/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java
index 59cc52fcbe..26679f8d81 100644
--- a/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java
+++ b/src/test/java/org/apache/commons/text/StringEscapeUtilsTest.java
@@ -74,9 +74,9 @@ public class StringEscapeUtilsTest {
                     "&#124;&#125;&#126;&#128;&#130;&#131;&#132;&#133;&#134;&#135;&#136;&#137;&#138;&#139;&#140;"
                             + "&#142;&#145;&#146;&#147;&#148;&#149;&#150;&#151;&#152;&#153;&#154;&#155;&#156;&#158;"
                             + "&#159;&#161;&#162;&#163;",
-                    "\u007c\u007d\u007e\u20ac\u201a\u0192\u201e\u2026\u2020\u2021\u02c6\u2030\u0160\u2039\u0152"
-                            + "\u017d\u2018\u2019\u201c\u201d\u2022\u2013\u2014\u02dc\u2122\u0161\u203a\u0153\u017e"
-                            + "\u0178\u00a1\u00a2\u00a3"
+                    "\u007C\u007D\u007E\u20AC\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\u017D"
+                            + "\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\u017E\u0178"
+                            + "\u00A1\u00A2\u00A3"
             }
     };
 

From f5c12c993ec867b0fc9d2ebb0b9a70c818112738 Mon Sep 17 00:00:00 2001
From: ifly6 <ifly6@me.com>
Date: Sun, 13 Dec 2020 15:43:31 -0500
Subject: [PATCH 10/10] remove accidentally left serr call

---
 .../apache/commons/text/translate/NumericEntityUnescaper.java    | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java b/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java
index ea616aed14..15a71ba6d5 100644
--- a/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java
+++ b/src/main/java/org/apache/commons/text/translate/NumericEntityUnescaper.java
@@ -165,7 +165,6 @@ public int translate(final CharSequence input, final int index, final Writer out
                     && !isHex  // must be a NUMERIC entity, not hex entity (see StringEscapeUtilsTest for hex)
                     && !INVALID_CP1252_POINTS.contains(entityValue)  // must not be an invalid code point for cp-1252
             ) {
-                System.err.println(entityValue);
                 try {
                     final String newChar = CP_1252_DECODER
                             .decode(ByteBuffer.wrap(new byte[] {(byte) entityValue}))