Merge pull request #11 from nats-io/encoding-update

Update Encoding API

Author: scottf

src/main/java/io/nats/json/Encoding.java

@@ -21,15 +21,32 @@
 public abstract class Encoding {
     private Encoding() {}  /* ensures cannot be constructed */
 
+    /**
+     * base64 encode a byte array to a byte array
+     * @param input the input byte array to encode
+     * @return the encoded byte array
+     */
+    public static byte[] base64BasicEncode(byte[] input) {
+        return Base64.getEncoder().encode(input);
+    }
+
+    /**
+     * base64 encode a byte array to a byte array
+     * @param input the input byte array to encode
+     * @return the encoded byte array
+     */
+    public static String base64BasicEncodeToString(byte[] input) {
+        return Base64.getEncoder().encodeToString(input);
+    }
+
     /**
      * base64 url encode a byte array to a byte array
      * @param input the input byte array to encode
      * @return the encoded byte array
-     * @deprecated prefer base64UrlEncode
      */
-    @Deprecated
-    public static byte[] base64Encode(byte[] input) {
-        return Base64.getUrlEncoder().withoutPadding().encode(input);
+    public static String base64BasicEncodeToString(String input) {
+        return Base64.getEncoder()
+            .encodeToString(input.getBytes(StandardCharsets.UTF_8));
     }
 
     /**
@@ -42,21 +59,50 @@ public static byte[] base64UrlEncode(byte[] input) {
     }
 
     /**
-     * base64 url encode a byte array to a string
+     * base64 url encode a byte array to a byte array
      * @param input the input byte array to encode
-     * @return the encoded string
+     * @return the encoded byte array
      */
-    public static String toBase64Url(byte[] input) {
-        return new String(base64UrlEncode(input));
+    public static String base64UrlEncodeToString(byte[] input) {
+        return Base64.getUrlEncoder().withoutPadding().encodeToString(input);
     }
 
     /**
-     * base64 url encode a string to a string
-     * @param input the input string to encode
-     * @return the encoded string
+     * base64 url encode a byte array to a byte array
+     * @param input the input byte array to encode
+     * @return the encoded byte array
      */
-    public static String toBase64Url(String input) {
-        return new String(base64UrlEncode(input.getBytes(StandardCharsets.US_ASCII)));
+    public static String base64UrlEncodeToString(String input) {
+        return Base64.getUrlEncoder()
+            .withoutPadding()
+            .encodeToString(input.getBytes(StandardCharsets.UTF_8));
+    }
+
+    /**
+     * base64 decode a byte array
+     * @param input the input byte array to decode
+     * @return the decoded byte array
+     */
+    public static byte[] base64BasicDecode(byte[] input) {
+        return Base64.getDecoder().decode(input);
+    }
+
+    /**
+     * base64 decode a base64 encoded string
+     * @param input the input string to decode
+     * @return the decoded byte array
+     */
+    public static byte[] base64BasicDecode(String input) {
+        return Base64.getDecoder().decode(input);
+    }
+
+    /**
+     * base64 decode a base64 encoded string
+     * @param input the input string to decode
+     * @return the decoded string
+     */
+    public static String base64BasicDecodeToString(String input) {
+        return new String(Base64.getDecoder().decode(input));
     }
 
     /**
@@ -69,12 +115,21 @@ public static byte[] base64UrlDecode(byte[] input) {
     }
 
     /**
-     * get a string from a base64 url encoded byte array
+     * base64 url decode a base64 url encoded string
+     * @param input the input string to decode
+     * @return the decoded byte array
+     */
+    public static byte[] base64UrlDecode(String input) {
+        return Base64.getUrlDecoder().decode(input);
+    }
+
+    /**
+     * base64 url decode a base64 url encoded string
      * @param input the input string to decode
      * @return the decoded string
      */
-    public static String fromBase64Url(String input) {
-        return new String(base64UrlDecode(input.getBytes(StandardCharsets.US_ASCII)));
+    public static String base64UrlDecodeToString(String input) {
+        return new String(Base64.getUrlDecoder().decode(input));
     }
 
     public static String jsonDecode(String s) {
@@ -86,7 +141,6 @@ public static String jsonDecode(String s) {
                 char nextChar = (x == len - 1) ? '\\' : s.charAt(x + 1);
                 switch (nextChar) {
                     case '\\':
-                        ch = '\\';
                         break;
                     case 'b':
                         ch = '\b';

src/test/java/io/nats/json/EncodingTests.java

@@ -0,0 +1,183 @@
+// Copyright 2015-2024 The NATS Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at:
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package io.nats.json;
+
+import static io.nats.json.Encoding.base64BasicDecode;
+import static io.nats.json.Encoding.base64BasicDecodeToString;
+import static io.nats.json.Encoding.base64BasicEncode;
+import static io.nats.json.Encoding.base64BasicEncodeToString;
+import static io.nats.json.Encoding.base64UrlDecode;
+import static io.nats.json.Encoding.base64UrlEncode;
+import static io.nats.json.Encoding.base64UrlEncodeToString;
+import static io.nats.json.Encoding.jsonDecode;
+import static io.nats.json.Encoding.jsonEncode;
+import static io.nats.json.Encoding.uriDecode;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+import io.ResourceUtils;
+
+public final class EncodingTests {
+    @Test
+    public void testJsonEncodeDecode() {
+        _testJsonEncodeDecode("b4\\\\after", "b4\\after", null); // a single slash with a meaningless letter after it
+        _testJsonEncodeDecode("b4\\\\tafter", "b4\\tafter", null); // a single slash with a char that can be part of an escape
+
+        _testJsonEncodeDecode("b4\\bafter", "b4\bafter", null);
+        _testJsonEncodeDecode("b4\\fafter", "b4\fafter", null);
+        _testJsonEncodeDecode("b4\\nafter", "b4\nafter", null);
+        _testJsonEncodeDecode("b4\\rafter", "b4\rafter", null);
+        _testJsonEncodeDecode("b4\\tafter", "b4\tafter", null);
+
+        _testJsonEncodeDecode("b4\\u0000after", "b4" + (char) 0 + "after", null);
+        _testJsonEncodeDecode("b4\\u001fafter", "b4" + (char) 0x1f + "after", "b4\\u001fafter");
+        _testJsonEncodeDecode("b4\\u0020after", "b4 after", "b4 after");
+        _testJsonEncodeDecode("b4\\u0022after", "b4\"after", "b4\\\"after");
+        _testJsonEncodeDecode("b4\\u0027after", "b4'after", "b4'after");
+        _testJsonEncodeDecode("b4\\u003dafter", "b4=after", "b4=after");
+        _testJsonEncodeDecode("b4\\u003Dafter", "b4=after", "b4=after");
+        _testJsonEncodeDecode("b4\\u003cafter", "b4<after", "b4<after");
+        _testJsonEncodeDecode("b4\\u003Cafter", "b4<after", "b4<after");
+        _testJsonEncodeDecode("b4\\u003eafter", "b4>after", "b4>after");
+        _testJsonEncodeDecode("b4\\u003Eafter", "b4>after", "b4>after");
+        _testJsonEncodeDecode("b4\\u0060after", "b4`after", "b4`after");
+        _testJsonEncodeDecode("b4\\xafter", "b4xafter", "b4xafter"); // unknown escape
+        _testJsonEncodeDecode("b4\\", "b4\\", "b4\\\\"); // last char is \
+        _testJsonEncodeDecode("b4\\/after", "b4/after", null);
+
+        List<String> utfs = ResourceUtils.resourceAsLines("utf8-only-no-ws-test-strings.txt");
+        for (String u : utfs) {
+            String uu = "b4\\b\\f\\n\\r\\t" + u + "after";
+            _testJsonEncodeDecode(uu, "b4\b\f\n\r\t" + u + "after", uu);
+        }
+    }
+
+    private void _testJsonEncodeDecode(String encodedInput, String targetDecode, String targetEncode) {
+        String decoded = jsonDecode(encodedInput);
+        assertEquals(targetDecode, decoded);
+        String encoded = jsonEncode(new StringBuilder(), decoded).toString();
+        if (targetEncode == null) {
+            assertEquals(encodedInput, encoded);
+        }
+        else {
+            assertEquals(targetEncode, encoded);
+        }
+    }
+
+    @Test
+    public void testBase64BasicEncoding() {
+        String text = "blahblah";
+        byte[] btxt = text.getBytes();
+
+        byte[] encBytesFromBytes = base64BasicEncode(btxt);
+        String encFromBytes = base64BasicEncodeToString(btxt);
+        String encFromString = base64BasicEncodeToString(text);
+        assertEquals("YmxhaGJsYWg=", new String(encBytesFromBytes));
+        assertEquals("YmxhaGJsYWg=", encFromBytes);
+        assertEquals("YmxhaGJsYWg=", encFromString);
+
+        assertArrayEquals(btxt, base64BasicDecode(encBytesFromBytes));
+        assertArrayEquals(btxt, base64BasicDecode(encFromBytes));
+        assertEquals(text, base64BasicDecodeToString(encFromBytes));
+
+        String data = ResourceUtils.resourceAsString("test_bytes_000100.txt");
+        String check = ResourceUtils.resourceAsString("basic_encoded_000100.txt");
+        byte[] bytes = data.getBytes(StandardCharsets.UTF_8);
+        String enc = base64BasicEncodeToString(data.getBytes());
+        assertEquals(check, enc);
+        assertArrayEquals(bytes, base64BasicDecode(enc));
+
+        data = ResourceUtils.resourceAsString("test_bytes_001000.txt");
+        check = ResourceUtils.resourceAsString("basic_encoded_001000.txt");
+        bytes = data.getBytes(StandardCharsets.UTF_8);
+        enc = base64BasicEncodeToString(data.getBytes());
+        assertEquals(check, enc);
+        assertArrayEquals(bytes, base64BasicDecode(enc));
+
+        data = ResourceUtils.resourceAsString("test_bytes_010000.txt");
+        check = ResourceUtils.resourceAsString("basic_encoded_010000.txt");
+        bytes = data.getBytes(StandardCharsets.UTF_8);
+        enc = base64BasicEncodeToString(data.getBytes());
+        assertEquals(check, enc);
+        assertArrayEquals(bytes, base64BasicDecode(enc));
+
+        data = ResourceUtils.resourceAsString("test_bytes_100000.txt");
+        check = ResourceUtils.resourceAsString("basic_encoded_100000.txt");
+        bytes = data.getBytes(StandardCharsets.UTF_8);
+        enc = base64BasicEncodeToString(data.getBytes());
+        assertEquals(check, enc);
+        assertArrayEquals(bytes, base64BasicDecode(enc));
+    }
+
+    @Test
+    public void testBase64UrlEncoding() {
+        String text = "blahblah";
+        byte[] btxt = text.getBytes();
+        String surl = "https://nats.io/";
+        byte[] burl = surl.getBytes();
+
+        byte[] uencBytes = base64UrlEncode(btxt);
+        assertEquals("YmxhaGJsYWg", base64UrlEncodeToString(text));
+        assertEquals("YmxhaGJsYWg", new String(uencBytes));
+        assertArrayEquals(btxt, base64UrlDecode(uencBytes));
+
+        uencBytes = base64UrlEncode(burl);
+        assertEquals("aHR0cHM6Ly9uYXRzLmlvLw", base64UrlEncodeToString(surl));
+        assertEquals("aHR0cHM6Ly9uYXRzLmlvLw", new String(uencBytes));
+        assertArrayEquals(burl, base64UrlDecode(uencBytes));
+
+        assertEquals("+ hello world", uriDecode("+%20hello%20world"));
+
+        String str = ResourceUtils.resourceAsString("test_bytes_000100.txt");
+        String check = ResourceUtils.resourceAsString("url_encoded_000100.txt");
+        byte[] bytes = str.getBytes(StandardCharsets.UTF_8);
+        String senc = base64UrlEncodeToString(str);
+        assertEquals(check, senc);
+        String benc = base64UrlEncodeToString(bytes);
+        assertEquals(check, benc);
+        assertArrayEquals(bytes, base64UrlDecode(benc));
+
+        str = ResourceUtils.resourceAsString("test_bytes_001000.txt");
+        check = ResourceUtils.resourceAsString("url_encoded_001000.txt");
+        bytes = str.getBytes(StandardCharsets.UTF_8);
+        senc = base64UrlEncodeToString(str);
+        assertEquals(check, senc);
+        benc = base64UrlEncodeToString(bytes);
+        assertEquals(check, benc);
+        assertArrayEquals(bytes, base64UrlDecode(benc));
+
+        str = ResourceUtils.resourceAsString("test_bytes_010000.txt");
+        check = ResourceUtils.resourceAsString("url_encoded_010000.txt");
+        bytes = str.getBytes(StandardCharsets.UTF_8);
+        senc = base64UrlEncodeToString(str);
+        assertEquals(check, senc);
+        benc = base64UrlEncodeToString(bytes);
+        assertEquals(check, benc);
+        assertArrayEquals(bytes, base64UrlDecode(benc));
+
+        str = ResourceUtils.resourceAsString("test_bytes_100000.txt");
+        check = ResourceUtils.resourceAsString("url_encoded_100000.txt");
+        bytes = str.getBytes(StandardCharsets.UTF_8);
+        senc = base64UrlEncodeToString(str);
+        assertEquals(check, senc);
+        benc = base64UrlEncodeToString(bytes);
+        assertEquals(check, benc);
+        assertArrayEquals(bytes, base64UrlDecode(benc));
+    }
+}