Add more encoding tests

src/test/java/rife/render/TestRenderUtils.java

@@ -31,8 +31,8 @@ import java.util.stream.Stream;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-class
+@SuppressWarnings("PMD.AvoidDuplicateLiterals")
-TestRenderUtils {
+class TestRenderUtils {
     static final String SAMPLE_GERMAN = "Möchten Sie ein paar Äpfel?";
 
     @Test
@@ -72,7 +72,8 @@ TestRenderUtils {
     class AbbreviateTests {
         @Test
         void abbreviateWithEllipsis() {
-            assertThat(RenderUtils.abbreviate(TestCase.SAMPLE_TEXT, 10, "…")).isEqualTo("This is a…");
+            assertThat(RenderUtils.abbreviate(TestCase.SAMPLE_TEXT, 10, "…"))
+                    .isEqualTo("This is a…");
         }
 
         @Test
@@ -82,7 +83,8 @@ TestRenderUtils {
 
         @Test
         void abbreviateWithMarker() {
-            assertThat(RenderUtils.abbreviate(TestCase.SAMPLE_TEXT, 12, "...")).isEqualTo("This is a...");
+            assertThat(RenderUtils.abbreviate(TestCase.SAMPLE_TEXT, 12, "..."))
+                    .isEqualTo("This is a...");
         }
 
         @Test
@@ -136,6 +138,102 @@ TestRenderUtils {
         }
     }
 
+    @Nested
+    @DisplayName("Encoding Tests")
+    class EncodingTests {
+        private Properties createProperties(String encodingType) {
+            var props = new Properties();
+            props.setProperty(RenderUtils.ENCODING_PROPERTY, encodingType);
+            return props;
+        }
+
+        @Test
+        void encodeHtml() {
+            var p = createProperties("html");
+            assertThat(RenderUtils.encode("<a test &>", p)).isEqualTo("&lt;a test &amp;&gt;");
+        }
+
+        @Test
+        void encodeJs() {
+            var p = createProperties("js");
+            assertThat(RenderUtils.encode("\"test'", p)).isEqualTo("\\\"test\\'");
+        }
+
+        @Test
+        void encodeJson() {
+            var p = createProperties("json");
+            assertThat(RenderUtils.encode("This is a \"•test\"", p))
+                    .isEqualTo("This is a \\\"\\u2022test\\\"");
+        }
+
+        @Test
+        void encodeUnicode() {
+            var p = createProperties("unicode");
+            assertThat(RenderUtils.encode("test", p)).isEqualTo("\\u0074\\u0065\\u0073\\u0074");
+        }
+
+        @Test
+        void encodeUrl() {
+            var p = createProperties("url");
+            assertThat(RenderUtils.encode("a = test", p)).isEqualTo("a%20%3D%20test");
+        }
+
+        @Test
+        void encodeWhenEncodingPropertyIsEmptyString() {
+            var src = "testString";
+            var p = createProperties(""); // Encoding property is ""
+            assertThat(RenderUtils.encode(src, p)).isEqualTo(src);
+        }
+
+        @Test
+        void encodeWhenEncodingPropertyIsMissing() {
+            var src = "testString";
+            var p = new Properties();
+            p.setProperty("some.other.property", "value"); // Not empty, but no ENCODING_PROPERTY
+            assertThat(RenderUtils.encode(src, p)).isEqualTo(src);
+        }
+
+        @Test
+        void encodeWhenEncodingPropertyIsUnknown() {
+            var src = "testString";
+            var p = createProperties("unknown_encoding_type");
+            assertThat(RenderUtils.encode(src, p)).isEqualTo(src);
+        }
+
+        @Test
+        void encodeWhenPropertiesIsEmpty() {
+            var src = "testString";
+            var p = new Properties();
+            assertThat(RenderUtils.encode(src, p)).isEqualTo(src);
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {"", "   ", "\t", "\n"})
+        void encodeWhenSrcIsBlank(String blankSrc) {
+            var p = createProperties("html"); // Properties are not empty
+            assertThat(RenderUtils.encode(blankSrc, p)).as("encode(%s)", blankSrc)
+                    .isEqualTo(blankSrc);
+        }
+
+        @Test
+        void encodeWhenSrcIsNull() {
+            var p = createProperties("html"); // Properties are not empty
+            assertThat(RenderUtils.encode(null, p)).isNull();
+        }
+
+        @Test
+        void encodeWithInvalidFormat() {
+            var p = createProperties("blah");
+            assertThat(RenderUtils.encode(TestCase.SAMPLE_TEXT, p)).isEqualTo(TestCase.SAMPLE_TEXT);
+        }
+
+        @Test
+        void encodeXml() {
+            var p = createProperties("xml");
+            assertThat(RenderUtils.encode("Joe's Café & Bar", p)).isEqualTo("Joe&apos;s Café &amp; Bar");
+        }
+
+
         @Nested
         @DisplayName("Encode JavaScript Tests")
         class EncodeJavaScriptTests {
@@ -155,160 +253,115 @@ TestRenderUtils {
             }
 
             @Test
-        void encodeJsAllSpecialChars() {
+            void encodeJsWithAllSpecialChars() {
-            String input = "'\"\\/\b\n\t\f\r";
+                var input = "'\"\\/\b\n\t\f\r";
-            String expected = "\\'\\\"\\\\\\/\\b\\n\\t\\f\\r";
+                var expected = "\\'\\\"\\\\\\/\\b\\n\\t\\f\\r";
                 assertThat(RenderUtils.encodeJs(input)).isEqualTo(expected);
             }
 
             @Test
-        void encodeJsBackslash() {
+            void encodeJsWithBackslash() {
                 assertThat(RenderUtils.encodeJs("This is a test \\string\\"))
                         .isEqualTo("This is a test \\\\string\\\\");
             }
 
             @Test
-        void encodeJsBackspace() {
+            void encodeJsWithBackspace() {
                 assertThat(RenderUtils.encodeJs("abc\bdef")).isEqualTo("abc\\bdef");
             }
 
             @Test
-        void encodeJsBlankInput() {
+            void encodeJsWithBlankInput() {
                 assertThat(RenderUtils.encodeJs("   ")).isEqualTo("   ");
             }
 
             @Test
-        void encodeJsCarriageReturn() {
+            void encodeJsWithCarriageReturn() {
                 assertThat(RenderUtils.encodeJs("abc\rdef")).isEqualTo("abc\\rdef");
             }
 
             @Test
-        void encodeJsConsecutiveSpecialChars() {
+            void encodeJsWithConsecutiveSpecialChars() {
                 assertThat(RenderUtils.encodeJs("''\"\"\\\\")).isEqualTo("\\'\\'\\\"\\\"\\\\\\\\");
             }
 
             @Test
-        void encodeJsDoubleQuote() {
+            void encodeJsWithDoubleQuote() {
-            assertThat(RenderUtils.encodeJs("This is a test \"string\"")).isEqualTo("This is a test \\\"string\\\"");
+                assertThat(RenderUtils.encodeJs("This is a test \"string\""))
+                        .isEqualTo("This is a test \\\"string\\\"");
             }
 
             @Test
-        void encodeJsEmptyInput() {
+            void encodeJsWithEmptyInput() {
                 assertThat(RenderUtils.encodeJs("")).isEqualTo("");
             }
 
-        @Test
-        void encodeJsFormFeed() {
-            assertThat(RenderUtils.encodeJs("abc\fdef")).isEqualTo("abc\\fdef");
-        }
-
-        @Test
-        void encodeJsForwardSlash() {
-            assertThat(RenderUtils.encodeJs("This is a test /string/")).isEqualTo("This is a test \\/string\\/");
-        }
-
-        @Test
-        void encodeJsMixedChars() {
-            String input = "Hello 'World' and \"JavaScript\" with \\slashes/ and \nnewlines.";
-            String expected = "Hello \\'World\\' and \\\"JavaScript\\\" with \\\\slashes\\/ and \\nnewlines.";
-            assertThat(RenderUtils.encodeJs(input)).isEqualTo(expected);
-        }
-
-        @Test
-        void encodeJsNewline() {
-            assertThat(RenderUtils.encodeJs("abc\ndef")).isEqualTo("abc\\ndef");
-        }
-
-        @Test
-        void encodeJsNoSpecialChars() {
-            String input = "Hello World 123!";
-            assertThat(input).isEqualTo(RenderUtils.encodeJs(input));
-        }
-
             @ParameterizedTest
             @NullAndEmptySource
             @ValueSource(strings = {" ", "  ", "\t", "\n"})
-            // isBlank() handles these
+            void encodeJsWithEmptyOrBlankInputs(String input) {
-        void encodeJsNullEmptyOrBlankInputs(String input) {
                 assertThat(RenderUtils.encodeJs(input)).isEqualTo(input);
             }
 
             @Test
-        void encodeJsNullInput() {
+            void encodeJsWithFormFeed() {
+                assertThat(RenderUtils.encodeJs("abc\fdef")).isEqualTo("abc\\fdef");
+            }
+
+            @Test
+            void encodeJsWithForwardSlash() {
+                assertThat(RenderUtils.encodeJs("This is a test /string/"))
+                        .isEqualTo("This is a test \\/string\\/");
+            }
+
+            @Test
+            void encodeJsWithMixedChars() {
+                var input = "Hello 'World' and \"JavaScript\" with \\slashes/ and \nnewlines.";
+                var expected = "Hello \\'World\\' and \\\"JavaScript\\\" with \\\\slashes\\/ and \\nnewlines.";
+                assertThat(RenderUtils.encodeJs(input)).isEqualTo(expected);
+            }
+
+            @Test
+            void encodeJsWithNewline() {
+                assertThat(RenderUtils.encodeJs("abc\ndef")).isEqualTo("abc\\ndef");
+            }
+
+            @Test
+            void encodeJsWithNoSpecialChars() {
+                var input = "Hello World 123!";
+                assertThat(input).isEqualTo(RenderUtils.encodeJs(input));
+            }
+
+            @Test
+            void encodeJsWithNullInput() {
                 assertThat(RenderUtils.encodeJs(null)).isNull();
             }
 
             @Test
-        void encodeJsSingleQuote() {
+            void encodeJsWithSingleQuote() {
-            assertThat(RenderUtils.encodeJs("This is a test 'string'")).isEqualTo("This is a test \\'string\\'");
+                assertThat(RenderUtils.encodeJs("This is a test 'string'"))
+                        .isEqualTo("This is a test \\'string\\'");
             }
 
             @Test
-        void encodeJsSpecialCharsAtStartAndEnd() {
+            void encodeJsWithSpecialCharsAtStartAndEnd() {
                 assertThat(RenderUtils.encodeJs("'test'")).isEqualTo("\\'test\\'");
                 assertThat(RenderUtils.encodeJs("\"test\"")).isEqualTo("\\\"test\\\"");
                 assertThat(RenderUtils.encodeJs("\\test\\")).isEqualTo("\\\\test\\\\");
             }
 
             @Test
-        void encodeJsTab() {
+            void encodeJsWithTab() {
                 assertThat(RenderUtils.encodeJs("abc\tdef")).isEqualTo("abc\\tdef");
             }
 
             @ParameterizedTest
             @MethodSource("javascriptEscapeTestCases")
-        void encodeJsVariousSpecialCharsParameterized(String input, String expected) {
+            void encodeJsWithVariousSpecialCharsParameterized(String input, String expected) {
                 assertThat(RenderUtils.encodeJs(input)).as("encodeJs(%s,%s)", input, expected).isEqualTo(expected);
             }
         }
 
-    @Nested
-    @DisplayName("Encode Tests")
-    class EncodeTests {
-        private final Properties p = new Properties();
-
-        @Test
-        void encodeHtml() {
-            p.put(RenderUtils.ENCODING_PROPERTY, "html");
-            assertThat(RenderUtils.encode("<a test &>", p)).isEqualTo("&lt;a test &amp;&gt;");
-        }
-
-        @Test
-        void encodeJs() {
-            p.put(RenderUtils.ENCODING_PROPERTY, "js");
-            assertThat(RenderUtils.encode("\"test'", p)).isEqualTo("\\\"test\\'");
-        }
-
-        @Test
-        void encodeJson() {
-            p.put(RenderUtils.ENCODING_PROPERTY, "json");
-            assertThat(RenderUtils.encode("This is a \"•test\"", p))
-                    .isEqualTo("This is a \\\"\\u2022test\\\"");
-        }
-
-        @Test
-        void encodeUnicode() {
-            p.put(RenderUtils.ENCODING_PROPERTY, "unicode");
-            assertThat(RenderUtils.encode("test", p)).isEqualTo("\\u0074\\u0065\\u0073\\u0074");
-        }
-
-        @Test
-        void encodeUrl() {
-            p.put(RenderUtils.ENCODING_PROPERTY, "url");
-            assertThat(RenderUtils.encode("a = test", p)).isEqualTo("a%20%3D%20test");
-        }
-
-        @Test
-        void encodeWithInvalidFormat() {
-            p.put(RenderUtils.ENCODING_PROPERTY, "blah");
-            assertThat(RenderUtils.encode(TestCase.SAMPLE_TEXT, p)).isEqualTo(TestCase.SAMPLE_TEXT);
-        }
-
-        @Test
-        void encodeXml() {
-            p.put(RenderUtils.ENCODING_PROPERTY, "xml");
-            assertThat(RenderUtils.encode("Joe's Café & Bar", p)).isEqualTo("Joe&apos;s Café &amp; Bar");
-        }
     }
 
     @Nested