Add some more tests and small fixes

Author: patrickfav

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

@@ -30,12 +30,12 @@
  *
  * @see <a href="https://en.wikipedia.org/wiki/Binary-to-text_encoding">Binary To Text Encoding</a>
  */
-public final class BinaryToTextEncoding {
+public interface BinaryToTextEncoding {
 
     /**
      * Interface for encoding bytes
      */
-    public interface Encoder {
+    interface Encoder {
 
         /**
          * Encodes given array with given byte order to a string
@@ -50,7 +50,7 @@ public interface Encoder {
     /**
      * Interface for decoding encoded strings
      */
-    public interface Decoder {
+    interface Decoder {
 
         /**
          * Decodes given encoded string
@@ -64,7 +64,7 @@ public interface Decoder {
     /**
      * Hex or Base16
      */
-    public static class Hex implements Encoder, Decoder {
+    class Hex implements Encoder, Decoder {
         private final boolean upperCase;
 
         public Hex() {
@@ -111,7 +111,7 @@ public byte[] decode(String hexString) {
         }
     }
 
-    public static class Base64Encoding implements Encoder, Decoder {
+    class Base64Encoding implements Encoder, Decoder {
         @Override
         public String encode(byte[] array, ByteOrder byteOrder) {
             return Base64.encode(array);
@@ -123,7 +123,7 @@ public byte[] decode(String encoded) {
         }
     }
 
-    public static class BaseRadix implements Encoder, Decoder {
+    class BaseRadix implements Encoder, Decoder {
         private final int radix;
 
         BaseRadix(int radix) {

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

@@ -85,6 +85,17 @@ public static Bytes allocate(int length, byte defaultValue) {
         return wrap(array);
     }
 
+    /**
+     * Creates a new reference backed by the same byte array.
+     * Inherits all attributes (readonly, etc.)
+     *
+     * @param bytes to use as template
+     * @return new instance
+     */
+    public static Bytes wrap(Bytes bytes) {
+        return new Bytes(bytes.internalArray(), bytes.byteOrder, bytes.mutable, bytes.readonly);
+    }
+
     /**
      * Creates a new instance with given byte array.
      * <p>
@@ -374,22 +385,23 @@ public static Bytes random(int length, Random random) {
     private final boolean readonly;
 
     /**
-     * Creates a new immutable instance with Big-Endian ordering
+     * Creates a new immutable instance
      *
      * @param byteArray internal byte array
+     * @param byteOrder the internal byte order - this is used to interpret given array, not to change it
      */
-    Bytes(byte[] byteArray) {
-        this(byteArray, ByteOrder.BIG_ENDIAN, false, false);
+    Bytes(byte[] byteArray, ByteOrder byteOrder) {
+        this(byteArray, byteOrder, false, false);
     }
 
     /**
-     * Creates a new immutable instance
+     * Creates a new instance with given array and copies all attributes from old instance
      *
-     * @param byteArray internal byte array
-     * @param byteOrder the internal byte order - this is used to interpret given array, not to change it
+     * @param byteArray   internal byte array
+     * @param oldInstance old instance to copy all internal attributes
      */
-    Bytes(byte[] byteArray, ByteOrder byteOrder) {
-        this(byteArray, byteOrder, false, false);
+    Bytes(byte[] byteArray, Bytes oldInstance) {
+        this(byteArray, oldInstance.byteOrder(), oldInstance.mutable, oldInstance.readonly);
     }
 
     /**
@@ -706,16 +718,17 @@ public Bytes resize(int newByteLength) {
         }
 
         if (newByteLength == 0) {
-            return wrap(new byte[0]);
+            return new Bytes(new byte[0], this);
         }
 
-        byte[] newSize = new byte[newByteLength];
+        byte[] resizedArray = new byte[newByteLength];
         if (newByteLength > length()) {
-            System.arraycopy(internalArray(), 0, newSize, Math.max(0, Math.abs(newByteLength - length())), Math.min(newByteLength, length()));
+            System.arraycopy(internalArray(), 0, resizedArray, Math.max(0, Math.abs(newByteLength - length())), Math.min(newByteLength, length()));
         } else {
-            System.arraycopy(internalArray(), Math.max(0, Math.abs(newByteLength - length())), newSize, Math.min(0, Math.abs(newByteLength - length())), Math.min(newByteLength, length()));
+            System.arraycopy(internalArray(), Math.max(0, Math.abs(newByteLength - length())), resizedArray, Math.min(0, Math.abs(newByteLength - length())), Math.min(newByteLength, length()));
         }
-        return wrap(newSize);
+
+        return new Bytes(resizedArray, this);
     }
 
 
@@ -864,9 +877,10 @@ public double entropy() {
      * @return new instance backed by the same data
      */
     public Bytes duplicate() {
-        return wrap(internalArray());
+        return wrap(this);
     }
 
+
     /**
      * Set the byte order or endianness of this instance. Default in Java is {@link ByteOrder#BIG_ENDIAN}.
      * <p>
@@ -878,7 +892,7 @@ public Bytes duplicate() {
      */
     public Bytes byteOrder(ByteOrder byteOrder) {
         if (byteOrder != this.byteOrder) {
-            return new Bytes(internalArray(), byteOrder);
+            return new Bytes(internalArray(), byteOrder, mutable, readonly);
         }
         return this;
     }

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

@@ -194,6 +194,12 @@ static void shuffle(byte[] array, Random random) {
 
     private static final int BUF_SIZE = 0x1000; // 4K
 
+    /**
+     * Read all bytes, buffered, from given input stream
+     *
+     * @param inputStream to read from
+     * @return all bytes from the stream
+     */
     static byte[] readFromStream(InputStream inputStream) {
         try {
             ByteArrayOutputStream out = new ByteArrayOutputStream();
@@ -211,6 +217,13 @@ static byte[] readFromStream(InputStream inputStream) {
         }
     }
 
+    /**
+     * Combines a single argument with a vararg to a single array
+     *
+     * @param firstByte first arg
+     * @param moreBytes varargs
+     * @return array containing all args
+     */
     static byte[] concatVararg(byte firstByte, byte[] moreBytes) {
         if (moreBytes == null) {
             return new byte[]{firstByte};
@@ -262,9 +275,5 @@ public double entropy() {
             }
             return entropy;
         }
-
-        public double perplexity() {
-            return Math.pow(2, entropy());
-        }
     }
 }

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

@@ -0,0 +1,35 @@
+package at.favre.lib.bytes;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Test cases from rfc4648
+ */
+public class Base64Test {
+
+    @Test
+    public void decode() throws Exception {
+        assertArrayEquals("".getBytes(), Base64.decode(""));
+        assertArrayEquals("f".getBytes(), Base64.decode("Zg=="));
+        assertArrayEquals("fo".getBytes(), Base64.decode("Zm8="));
+        assertArrayEquals("foo".getBytes(), Base64.decode("Zm9v"));
+        assertArrayEquals("foob".getBytes(), Base64.decode("Zm9vYg=="));
+        assertArrayEquals("fooba".getBytes(), Base64.decode("Zm9vYmE="));
+        assertArrayEquals("foobar".getBytes(), Base64.decode("Zm9vYmFy"));
+    }
+
+    @Test
+    public void encode() throws Exception {
+        assertEquals("", Base64.encode("".getBytes()));
+        assertEquals("Zg==", Base64.encode("f".getBytes()));
+        assertEquals("Zm8=", Base64.encode("fo".getBytes()));
+        assertEquals("Zm9v", Base64.encode("foo".getBytes()));
+        assertEquals("Zm9vYg==", Base64.encode("foob".getBytes()));
+        assertEquals("Zm9vYmE=", Base64.encode("fooba".getBytes()));
+        assertEquals("Zm9vYmFy", Base64.encode("foobar".getBytes()));
+    }
+
+}

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

@@ -44,6 +44,9 @@ public void wrapTest() throws Exception {
 
         assertSame(example_bytes_seven, b.array());
         assertArrayNotEquals(copy, example_bytes_seven);
+
+        Bytes b2 = Bytes.wrap(b);
+        assertSame(b.array(), b2.array());
     }
 
     @Test

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

@@ -110,6 +110,7 @@ public void indexOfByte() throws Exception {
     @Test
     public void indexOfArray() throws Exception {
         assertEquals(-1, Bytes.allocate(0).indexOf(new byte[]{(byte) 0xFD}));
+        assertEquals(0, Bytes.allocate(1).indexOf(new byte[0]));
         assertEquals(2, Bytes.from(example_bytes_seven).indexOf(new byte[]{(byte) 0xFD, (byte) 0xFF}));
         assertEquals(-1, Bytes.from(example_bytes_seven).indexOf(new byte[]{(byte) 0xFD, (byte) 0x00}));
     }

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

@@ -0,0 +1,17 @@
+package at.favre.lib.bytes;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class UtilTest {
+    @Test(expected = IllegalStateException.class)
+    public void readFromStream() throws Exception {
+        Util.readFromStream(null);
+    }
+
+    @Test
+    public void concatVararg() throws Exception {
+        assertArrayEquals(new byte[]{1}, Util.concatVararg((byte) 1, null));
+    }
+}