Support for arbitrary radix encoding/parsing and fix test for number encoding

fixes #6, #20

Author: patrickfav

CHANGELOG

@@ -2,6 +2,8 @@
 
 ## v0.8.0
 
+* add radix encoding/parsing and fix radix tests #6, #20
+
 ## v0.7.1
 
 * sign AFTER ProGuard so optimized version has correct jar signature

README.md

@@ -285,7 +285,7 @@ Bytes.wrap(array).transform(shuffle());
 ### Parser and Encoder for Binary-Text-Encodings
 
 This library can parse and encode a variety of encodings: binary, decimal, [octal](https://en.wikipedia.org/wiki/Octal),
-[hex](https://en.wikipedia.org/wiki/Hexadecimal), [base36](https://en.wikipedia.org/wiki/Base36) and
+[hex](https://en.wikipedia.org/wiki/Hexadecimal) and
 [base64](https://en.wikipedia.org/wiki/Base64). Additionally custom parsers are supported by providing your own
 implementation:
 
@@ -318,7 +318,7 @@ Additionally the following encodings are supported:
 Bytes.from(array).encodeBinary(); //1110110110101111
 Bytes.from(array).encodeDec(); //20992966904426477
 Bytes.from(array).encodeOctal(); //1124517677707527755
-Bytes.from(array).encodeBase36(); //5qpdvuwjvu5
+Bytes.from(array).encodeRadix(36); //5qpdvuwjvu5
 ```
 
 ### Handling Strings

src/main/java/at/favre/lib/bytes/BinaryToTextEncoding.java

@@ -159,10 +159,13 @@ public byte[] decode(String encoded) {
     /**
      * Simple radix encoder which internally uses {@link BigInteger#toString(int)}
      */
-    class BaseRadix implements EncoderDecoder {
+    class BaseRadixNumber implements EncoderDecoder {
         private final int radix;
 
-        BaseRadix(int radix) {
+        BaseRadixNumber(int radix) {
+            if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) {
+                throw new IllegalArgumentException("supported radix is between " + Character.MIN_RADIX + " and " + Character.MAX_RADIX);
+            }
             this.radix = radix;
         }
 
@@ -181,9 +184,5 @@ public byte[] decode(String encoded) {
             }
             return array;
         }
-
-//        private int maxLength(byte[] data, int radix) {
-//            return BigInteger.valueOf(2).pow(BigInteger.valueOf(data.length).multiply(BigInteger.valueOf(8)).intValue()).toString(radix).length();
-//        }
     }
 }

src/main/java/at/favre/lib/bytes/Bytes.java

@@ -518,7 +518,7 @@ public static Bytes from(UUID uuid) {
      * @return decoded instance
      */
     public static Bytes parseBinary(String binaryString) {
-        return parse(binaryString, new BinaryToTextEncoding.BaseRadix(2));
+        return parseRadix(binaryString, 2);
     }
 
     /**
@@ -528,7 +528,7 @@ public static Bytes parseBinary(String binaryString) {
      * @return decoded instance
      */
     public static Bytes parseOctal(String octalString) {
-        return parse(octalString, new BinaryToTextEncoding.BaseRadix(8));
+        return parseRadix(octalString, 8);
     }
 
     /**
@@ -538,7 +538,22 @@ public static Bytes parseOctal(String octalString) {
      * @return decoded instance
      */
     public static Bytes parseDec(String decString) {
-        return parse(decString, new BinaryToTextEncoding.BaseRadix(10));
+        return parseRadix(decString, 10);
+    }
+
+    /**
+     * Encodes with given radix string representation (e.g. radix 16 would be hex).
+     * See also {@link BigInteger#toString(int)}.
+     * <p>
+     * This is usually a number encoding, not a data encoding (ie. leading zeros are not preserved), but this implementation
+     * tries to preserve the leading zeros, to keep the in/output byte length size the same, but use at your own risk!
+     *
+     * @param radixNumberString the encoded string
+     * @param radix             radix of the String representation (supported are 2-36)
+     * @return decoded instance
+     */
+    public static Bytes parseRadix(String radixNumberString, int radix) {
+        return parse(radixNumberString, new BinaryToTextEncoding.BaseRadixNumber(radix));
     }
 
     /**
@@ -554,12 +569,17 @@ public static Bytes parseHex(String hexString) {
 
     /**
      * Parsing of base36 encoded byte arrays.
+     * <p>
+     * This is usually a number encoding, not a data encoding (ie. leading zeros are not preserved), but this implementation
+     * tries to preserve the leading zeros, to keep the in/output byte length size the same.
      *
      * @param base36String the encoded string
      * @return decoded instance
+     * @deprecated use {@link #parseRadix(String, int)} with 36 instead; will be removed in v1.0+
      */
+    @Deprecated
     public static Bytes parseBase36(String base36String) {
-        return parse(base36String, new BinaryToTextEncoding.BaseRadix(36));
+        return parse(base36String, new BinaryToTextEncoding.BaseRadixNumber(36));
     }
 
     /**
@@ -1447,7 +1467,7 @@ byte[] internalArray() {
      * @see <a href="https://en.wikipedia.org/wiki/Binary_number">Binary number</a>
      */
     public String encodeBinary() {
-        return encode(new BinaryToTextEncoding.BaseRadix(2));
+        return encodeRadix(2);
     }
 
     /**
@@ -1459,7 +1479,7 @@ public String encodeBinary() {
      * @see <a href="https://en.wikipedia.org/wiki/Octal">Octal</a>
      */
     public String encodeOctal() {
-        return encode(new BinaryToTextEncoding.BaseRadix(8));
+        return encodeRadix(8);
     }
 
     /**
@@ -1471,7 +1491,27 @@ public String encodeOctal() {
      * @see <a href="https://en.wikipedia.org/wiki/Decimal">Decimal</a>
      */
     public String encodeDec() {
-        return encode(new BinaryToTextEncoding.BaseRadix(10));
+        return encodeRadix(10);
+    }
+
+    /**
+     * Encodes the internal array in given radix representation (e.g. 2 = binary, 10 = decimal, 16 = hex).
+     * <p>
+     * This is usually a number encoding, not a data encoding (ie. leading zeros are not preserved), but this implementation
+     * tries to preserve the leading zeros, to keep the in/output byte length size the same. To preserve the length padding
+     * would be required, but is not supported in this implementation.
+     * <p>
+     * But still full disclaimer:
+     *
+     * <strong>This is NOT recommended for data encoding, only for number encoding</strong>
+     * <p>
+     * See <a href="https://en.wikipedia.org/wiki/Radix_economy">Radix Economy</a> and {@link BigInteger#toString(int)}.
+     *
+     * @param radix of the String representation (supported are 2-36)
+     * @return string in given radix representation
+     */
+    public String encodeRadix(int radix) {
+        return encode(new BinaryToTextEncoding.BaseRadixNumber(radix));
     }
 
     /**
@@ -1499,16 +1539,20 @@ public String encodeHex(boolean upperCase) {
     }
 
     /**
+     * DO NOT USE AS DATA ENCODING, ONLY FOR NUMBERS!
+     * <p>
      * Base36 (aka Hexatrigesimal) representation. The choice of 36 is convenient in that the digits can be
      * represented using the Arabic numerals 0–9 and the Latin letters A–Z. This encoding has a space efficiency of 64.6%.
      * <p>
      * Example: <code>5qpdvuwjvu5</code>
      *
      * @return base36 string
      * @see <a href="https://en.wikipedia.org/wiki/Base36">Base36</a>
+     * @deprecated use {@link #encodeRadix(int)} instead; will be removed in v1.0+
      */
+    @Deprecated
     public String encodeBase36() {
-        return encode(new BinaryToTextEncoding.BaseRadix(36));
+        return encodeRadix(36);
     }
 
     /**

src/test/java/at/favre/lib/bytes/BinaryToTextEncodingTest.java

@@ -21,7 +21,6 @@
 
 package at.favre.lib.bytes;
 
-import org.junit.Ignore;
 import org.junit.Test;
 
 import java.nio.ByteOrder;
@@ -43,40 +42,50 @@ public void decodeHexShouldFail() {
 
     @Test
     public void encodeBaseRadix() {
-        assertEquals("100211", new BinaryToTextEncoding.BaseRadix(16).encode(new byte[]{16, 2, 17}, ByteOrder.BIG_ENDIAN));
-        assertEquals("110210", new BinaryToTextEncoding.BaseRadix(16).encode(new byte[]{16, 2, 17}, ByteOrder.LITTLE_ENDIAN));
-        assertNotEquals(new BinaryToTextEncoding.BaseRadix(2).encode(new byte[]{1, 2, 3}, ByteOrder.LITTLE_ENDIAN), new BinaryToTextEncoding.BaseRadix(2).encode(new byte[]{1, 2, 3}, ByteOrder.BIG_ENDIAN));
+        assertEquals("100211", new BinaryToTextEncoding.BaseRadixNumber(16).encode(new byte[]{16, 2, 17}, ByteOrder.BIG_ENDIAN));
+        assertEquals("110210", new BinaryToTextEncoding.BaseRadixNumber(16).encode(new byte[]{16, 2, 17}, ByteOrder.LITTLE_ENDIAN));
+        assertNotEquals(new BinaryToTextEncoding.BaseRadixNumber(2).encode(new byte[]{1, 2, 3}, ByteOrder.LITTLE_ENDIAN), new BinaryToTextEncoding.BaseRadixNumber(2).encode(new byte[]{1, 2, 3}, ByteOrder.BIG_ENDIAN));
     }
 
     @Test
     public void encodeDecodeRadix() {
-        for (int i = 0; i < 32; i++) {
-            Bytes rnd = Bytes.random(i);
+        int leadingZeroHits = 0;
+        int encodings = 0;
+        for (int i = 0; i < 64; i++) {
+            Bytes rnd = Bytes.random(i % 256);
             System.out.println("\n\nNEW TEST: " + i + " bytes\n");
-            for (int j = 16; j < 36; j++) {
-                BinaryToTextEncoding.EncoderDecoder encoding = new BinaryToTextEncoding.BaseRadix(j);
+            for (int j = 2; j <= 36; j++) {
+                encodings++;
+                BinaryToTextEncoding.EncoderDecoder encoding = new BinaryToTextEncoding.BaseRadixNumber(j);
                 String encodedBigEndian = encoding.encode(rnd.array(), ByteOrder.BIG_ENDIAN);
                 byte[] decoded = encoding.decode(encodedBigEndian);
                 System.out.println("radix" + j + ":\t" + encodedBigEndian);
                 System.out.println("orig   :\t" + rnd.encodeHex());
                 System.out.println("enc    :\t" + Bytes.wrap(decoded).encodeHex());
-                assertArrayEquals(rnd.array(), decoded);
+
+
+                if (rnd.length() <= 0 || rnd.byteAt(0) != 0) {
+                    assertArrayEquals(rnd.array(), decoded);
+                } else { //since this is a number, we allow different lengths due to leading zero
+                    leadingZeroHits++;
+                    assertArrayEquals(rnd.resize(rnd.length() - 1).array(), decoded);
+                }
             }
         }
+        System.out.println(leadingZeroHits + " leading zero mismatches of " + encodings + " encodings");
     }
 
     @Test
-    @Ignore("should fix")
     public void encodeDecodeRadixZeros() {
         Bytes bytes = Bytes.wrap(new byte[]{0, 0, 0, 0});
-        BinaryToTextEncoding.EncoderDecoder encoding = new BinaryToTextEncoding.BaseRadix(36);
+        BinaryToTextEncoding.EncoderDecoder encoding = new BinaryToTextEncoding.BaseRadixNumber(36);
         String encodedBigEndian = encoding.encode(bytes.array(), ByteOrder.BIG_ENDIAN);
         byte[] decoded = encoding.decode(encodedBigEndian);
 
         System.out.println("radix36:\t" + encodedBigEndian);
         System.out.println("orig   :\t" + bytes.encodeHex());
         System.out.println("enc    :\t" + Bytes.wrap(decoded).encodeHex());
-        assertArrayEquals(bytes.array(), decoded);
+        assertArrayEquals(new byte[]{}, decoded);
     }
 
     @Test
@@ -114,12 +123,12 @@ public void encodeDecodeHex() {
 
     @Test(expected = IllegalArgumentException.class)
     public void decodeInvalidRadix16() {
-        new BinaryToTextEncoding.BaseRadix(16).decode("AAI=");
+        new BinaryToTextEncoding.BaseRadixNumber(16).decode("AAI=");
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void decodeInvalidRadix36() {
-        new BinaryToTextEncoding.BaseRadix(36).decode("AAI=");
+        new BinaryToTextEncoding.BaseRadixNumber(36).decode("AAI=");
     }
 
     @Test
@@ -139,4 +148,24 @@ public void decodeInvalidBase64() {
     public void decodeHalfInvalidBase64() {
         new BinaryToTextEncoding.Base64Encoding().decode("EAI`");
     }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void encodeRadixIllegalTooHigh2() {
+        new BinaryToTextEncoding.BaseRadixNumber(38);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void encodeRadixIllegalTooHigh() {
+        new BinaryToTextEncoding.BaseRadixNumber(37);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void encodeRadixIllegalTooLow() {
+        new BinaryToTextEncoding.BaseRadixNumber(1);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void encodeRadixIllegalTooLow2() {
+        new BinaryToTextEncoding.BaseRadixNumber(0);
+    }
 }

src/test/java/at/favre/lib/bytes/BytesParseAndEncodingTest.java

@@ -125,4 +125,42 @@ public void encodeBase36() {
         assertEquals("69zbn", Bytes.from(defaultArray).encodeBase36());
         assertEquals("5qpdvuwjvu5", Bytes.from(encodingExample).encodeBase36());
     }
-}
+
+    @Test
+    public void parseRadix() {
+        assertArrayEquals(encodingExample, Bytes.parseRadix("1001010100101001111110111111111000111101010111111101101", 2).array());
+        assertArrayEquals(encodingExample, Bytes.parseRadix("10202221221221000222101012210121012", 3).array());
+        assertArrayEquals(encodingExample, Bytes.parseRadix("1022211033313333013222333231", 4).array());
+        assertArrayEquals(encodingExample, Bytes.parseRadix("134003042232210013121402", 5).array());
+        assertArrayEquals(encodingExample, Bytes.parseRadix("542412151505231515005", 6).array());
+        assertArrayEquals(encodingExample, Bytes.parseRadix("1124517677707527755", 8).array());
+        assertArrayEquals(encodingExample, Bytes.parseRadix("20992966904426477", 10).array());
+        assertArrayEquals(encodingExample, Bytes.parseRadix("4a94fdff1eafed", 16).array());
+        assertArrayEquals(encodingExample, Bytes.parseRadix("5iibpp5dgpgp", 26).array());
+        assertArrayEquals(encodingExample, Bytes.parseRadix("5qpdvuwjvu5", 36).array());
+    }
+
+    @Test
+    public void encodeRadix() {
+        assertEquals("1001010100101001111110111111111000111101010111111101101", Bytes.from(encodingExample).encodeRadix(2));
+        assertEquals("10202221221221000222101012210121012", Bytes.from(encodingExample).encodeRadix(3));
+        assertEquals("1022211033313333013222333231", Bytes.from(encodingExample).encodeRadix(4));
+        assertEquals("134003042232210013121402", Bytes.from(encodingExample).encodeRadix(5));
+        assertEquals("542412151505231515005", Bytes.from(encodingExample).encodeRadix(6));
+        assertEquals("1124517677707527755", Bytes.from(encodingExample).encodeRadix(8));
+        assertEquals("20992966904426477", Bytes.from(encodingExample).encodeRadix(10));
+        assertEquals("4a94fdff1eafed", Bytes.from(encodingExample).encodeRadix(16));
+        assertEquals("5iibpp5dgpgp", Bytes.from(encodingExample).encodeRadix(26));
+        assertEquals("5qpdvuwjvu5", Bytes.from(encodingExample).encodeRadix(36));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void encodeRadixIllegalTooHigh() {
+        Bytes.from(encodingExample).encodeRadix(37);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void encodeRadixIllegalTooLow() {
+        Bytes.from(encodingExample).encodeRadix(1);
+    }
+}