removed unused code

Author: scottf

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

@@ -16,7 +16,6 @@
 import java.io.UnsupportedEncodingException;
 import java.net.URLDecoder;
 import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
 import java.util.Base64;
 
 public abstract class Encoding {
@@ -134,89 +133,6 @@ public static String base64UrlDecodeToString(String input) {
         return new String(Base64.getUrlDecoder().decode(input));
     }
 
-    // http://en.wikipedia.org/wiki/Base_32
-    private static final String BASE32_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
-    private static final int[] BASE32_LOOKUP;
-    private static final int MASK = 31;
-    private static final int SHIFT = 5;
-    public static char[] base32Encode(final byte[] input) {
-        int last = input.length;
-        char[] charBuff = new char[(last + 7) * 8 / SHIFT];
-        int offset = 0;
-        int buffer = input[offset++];
-        int bitsLeft = 8;
-        int i = 0;
-
-        while (bitsLeft > 0 || offset < last) {
-            if (bitsLeft < SHIFT) {
-                if (offset < last) {
-                    buffer <<= 8;
-                    buffer |= (input[offset++] & 0xff);
-                    bitsLeft += 8;
-                } else {
-                    int pad = SHIFT - bitsLeft;
-                    buffer <<= pad;
-                    bitsLeft += pad;
-                }
-            }
-            int index = MASK & (buffer >> (bitsLeft - SHIFT));
-            bitsLeft -= SHIFT;
-            charBuff[i] = BASE32_CHARS.charAt(index);
-            i++;
-        }
-
-        int nonBlank;
-
-        for (nonBlank=charBuff.length-1;nonBlank>=0;nonBlank--) {
-            if (charBuff[nonBlank] != 0) {
-                break;
-            }
-        }
-
-        char[] retVal = new char[nonBlank+1];
-
-        System.arraycopy(charBuff, 0, retVal, 0, retVal.length);
-
-        Arrays.fill(charBuff, '\0');
-
-        return retVal;
-    }
-    static {
-        BASE32_LOOKUP = new int[256];
-
-        Arrays.fill(BASE32_LOOKUP, 0xFF);
-
-        for (int i = 0; i < BASE32_CHARS.length(); i++) {
-            int index = BASE32_CHARS.charAt(i) - '0';
-            BASE32_LOOKUP[index] = i;
-        }
-    }
-
-    public static byte[] base32Decode(final char[] input) {
-        byte[] bytes = new byte[input.length * SHIFT / 8];
-        int buffer = 0;
-        int next = 0;
-        int bitsLeft = 0;
-
-        for (int i = 0; i < input.length; i++) {
-            int lookup = input[i] - '0';
-
-            if (lookup < 0 || lookup >= BASE32_LOOKUP.length) {
-                continue;
-            }
-
-            int c = BASE32_LOOKUP[lookup];
-            buffer <<= SHIFT;
-            buffer |= c & MASK;
-            bitsLeft += SHIFT;
-            if (bitsLeft >= 8) {
-                bytes[next++] = (byte) (buffer >> (bitsLeft - 8));
-                bitsLeft -= 8;
-            }
-        }
-        return bytes;
-    }
-
     public static String jsonDecode(String s) {
         int len = s.length();
         StringBuilder sb = new StringBuilder(len);
@@ -317,48 +233,4 @@ public static String uriDecode(String source) {
             return source;
         }
     }
-
-    /**
-     * @deprecated Use {@link #base64UrlEncode(byte[])} instead.
-     * base64 url encode a byte array to a byte array
-     * @param input the input byte array to encode
-     * @return the encoded byte array
-     */
-    @Deprecated
-    public static byte[] base64Encode(byte[] input) {
-        return Base64.getUrlEncoder().withoutPadding().encode(input);
-    }
-
-    /**
-     * @deprecated Use {@link #base64UrlEncodeToString(byte[])} instead.
-     * base64 url encode a byte array to a string
-     * @param input the input byte array to encode
-     * @return the encoded string
-     */
-    @Deprecated
-    public static String toBase64Url(byte[] input) {
-        return base64UrlEncodeToString(input);
-    }
-
-    /**
-     * @deprecated Use {@link #base64UrlEncodeToString(String)} instead.
-     * base64 url encode a string to a string
-     * @param input the input string to encode
-     * @return the encoded string
-     */
-    @Deprecated
-    public static String toBase64Url(String input) {
-        return base64UrlEncodeToString(input);
-    }
-
-    /**
-     * @deprecated Use {@link #base64UrlDecodeToString(String)} instead.
-     * get a string from a base64 url encoded byte array
-     * @param input the input string to decode
-     * @return the decoded string
-     */
-    @Deprecated
-    public static String fromBase64Url(String input) {
-        return base64UrlDecodeToString(input);
-    }
 }

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

@@ -17,14 +17,11 @@
 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.base64Encode;
 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.fromBase64Url;
 import static io.nats.json.Encoding.jsonDecode;
 import static io.nats.json.Encoding.jsonEncode;
-import static io.nats.json.Encoding.toBase64Url;
 import static io.nats.json.Encoding.uriDecode;
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -128,64 +125,58 @@ public void testBase64BasicEncoding() {
         assertArrayEquals(bytes, base64BasicDecode(enc));
     }
 
-    @SuppressWarnings("deprecation")
     @Test
     public void testBase64UrlEncoding() {
         String text = "blahblah";
         byte[] btxt = text.getBytes();
         String surl = "https://nats.io/";
         byte[] burl = surl.getBytes();
 
-        byte[] encBytes = base64Encode(btxt); //deprecated for base64UrlEncode
         byte[] uencBytes = base64UrlEncode(btxt);
-        assertEquals("YmxhaGJsYWg", new String(encBytes));
         assertEquals("YmxhaGJsYWg", new String(uencBytes));
-        assertEquals("YmxhaGJsYWg", toBase64Url(text));   //deprecated
-        assertEquals("YmxhaGJsYWg", toBase64Url(btxt));   //deprecated
-        assertEquals(text, fromBase64Url("YmxhaGJsYWg")); //deprecated
-        assertArrayEquals(btxt, base64UrlDecode(encBytes));
         assertArrayEquals(btxt, base64UrlDecode(uencBytes));
 
-        //noinspection deprecation
-        encBytes = base64Encode(burl);
         uencBytes = base64UrlEncode(burl);
-        assertEquals("aHR0cHM6Ly9uYXRzLmlvLw", new String(encBytes));
         assertEquals("aHR0cHM6Ly9uYXRzLmlvLw", new String(uencBytes));
-        assertEquals("aHR0cHM6Ly9uYXRzLmlvLw", toBase64Url(surl)); //deprecated
-        assertEquals("aHR0cHM6Ly9uYXRzLmlvLw", toBase64Url(burl)); //deprecated
-        assertEquals(surl, fromBase64Url("aHR0cHM6Ly9uYXRzLmlvLw")); //deprecated
-        assertArrayEquals(burl, base64UrlDecode(encBytes));
         assertArrayEquals(burl, base64UrlDecode(uencBytes));
 
         assertEquals("+ hello world", uriDecode("+%20hello%20world"));
 
-        String data = ResourceUtils.resourceAsString("test_bytes_000100.txt");
+        String str = ResourceUtils.resourceAsString("test_bytes_000100.txt");
         String check = ResourceUtils.resourceAsString("url_encoded_000100.txt");
-        byte[] bytes = data.getBytes(StandardCharsets.UTF_8);
-        String enc = base64UrlEncodeToString(bytes);
-        assertEquals(check, enc);
-        assertArrayEquals(bytes, base64UrlDecode(enc));
-
-        data = ResourceUtils.resourceAsString("test_bytes_001000.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 = data.getBytes(StandardCharsets.UTF_8);
-        enc = base64UrlEncodeToString(bytes);
-        assertEquals(check, enc);
-        assertArrayEquals(bytes, base64UrlDecode(enc));
-
-        data = ResourceUtils.resourceAsString("test_bytes_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_010000.txt");
         check = ResourceUtils.resourceAsString("url_encoded_010000.txt");
-        bytes = data.getBytes(StandardCharsets.UTF_8);
-        enc = base64UrlEncodeToString(bytes);
-        assertEquals(check, enc);
-        assertArrayEquals(bytes, base64UrlDecode(enc));
-
-        data = ResourceUtils.resourceAsString("test_bytes_100000.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 = data.getBytes(StandardCharsets.UTF_8);
-        enc = base64UrlEncodeToString(bytes);
-        assertEquals(check, enc);
-        assertArrayEquals(bytes, base64UrlDecode(enc));
+        bytes = str.getBytes(StandardCharsets.UTF_8);
+        senc = base64UrlEncodeToString(str);
+        assertEquals(check, senc);
+        benc = base64UrlEncodeToString(bytes);
+        assertEquals(check, benc);
+        assertArrayEquals(bytes, base64UrlDecode(benc));
 
     }
 }