Add more tests

Author: patrickfav

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

@@ -120,21 +120,10 @@ public static byte[] decode(String in) {
             '5', '6', '7', '8', '9', '+', '/'
     };
 
-    private static final byte[] URL_MAP = new byte[]{
-            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
-            'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
-            'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4',
-            '5', '6', '7', '8', '9', '-', '_'
-    };
-
     public static String encode(byte[] in) {
         return encode(in, MAP);
     }
 
-    public static String encodeUrl(byte[] in) {
-        return encode(in, URL_MAP);
-    }
-
     private static String encode(byte[] in, byte[] map) {
         int length = (in.length + 2) / 3 * 4;
         byte[] out = new byte[length];

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

@@ -21,8 +21,8 @@
 
 package at.favre.lib.bytes;
 
+import java.io.ByteArrayInputStream;
 import java.io.InputStream;
-import java.io.OutputStream;
 import java.math.BigInteger;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
@@ -589,16 +589,16 @@ public Bytes rightShift(int shiftCount) {
     }
 
     /**
-     * Creates a new instance with a copy of the internal byte array.
+     * Creates a new instance with a copy of the internal byte array and all other attributes.
      *
      * @return copied instance
      */
     public Bytes copy() {
-        return wrap(Arrays.copyOf(internalArray(), length()));
+        return new Bytes(Arrays.copyOf(internalArray(), length()), byteOrder, mutable, readonly);
     }
 
     /**
-     * Creates a new instance with a copy of the internal byte array.
+     * Creates a new instance with a copy of the internal byte array and all other attributes.
      *
      * @param offset starting position in the source array
      * @param length of the new instance
@@ -607,7 +607,7 @@ public Bytes copy() {
     public Bytes copy(int offset, int length) {
         byte[] copy = new byte[length];
         System.arraycopy(internalArray(), offset, copy, 0, copy.length);
-        return wrap(copy);
+        return new Bytes(copy, byteOrder, mutable, readonly);
     }
 
     /**
@@ -758,6 +758,15 @@ public ByteOrder byteOrder() {
         return byteOrder;
     }
 
+    /**
+     * Check if this instance is read only
+     *
+     * @return true if read only
+     */
+    public boolean isReadOnly() {
+        return readonly;
+    }
+
     /**
      * Returns the index of the first appearance of the value {@code target} in
      * {@code array}.
@@ -939,12 +948,12 @@ public MutableBytes mutable() {
     }
 
     /**
-     * Creates an output stream with the same backing data as the intern array of this instance
+     * Creates an input stream with the same backing data as the intern array of this instance
      *
-     * @return new output stream
+     * @return new input stream
      */
-    public OutputStream outputStream() {
-        return Util.createOutputStream(array());
+    public InputStream inputStream() {
+        return new ByteArrayInputStream(internalArray());
     }
 
     /**

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

@@ -23,7 +23,6 @@
 
 import java.io.ByteArrayOutputStream;
 import java.io.InputStream;
-import java.io.OutputStream;
 import java.util.*;
 
 /**
@@ -183,7 +182,6 @@ static Byte[] toObjectArray(byte[] array) {
      *
      * @param array
      * @param random
-     * @return shuffled array
      */
     static void shuffle(byte[] array, Random random) {
         for (int i = array.length - 1; i > 0; i--) {
@@ -213,16 +211,6 @@ static byte[] readFromStream(InputStream inputStream) {
         }
     }
 
-    static OutputStream createOutputStream(byte[] array) {
-        try {
-            OutputStream outputStream = new ByteArrayOutputStream(array.length);
-            outputStream.write(array);
-            return outputStream;
-        } catch (Exception e) {
-            throw new IllegalStateException("could not write to output stream", e);
-        }
-    }
-
     static byte[] concatVararg(byte firstByte, byte[] moreBytes) {
         if (moreBytes == null) {
             return new byte[]{firstByte};

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

@@ -131,6 +131,12 @@ public void byteAt() throws Exception {
         for (int i = 0; i < example_bytes_twentyfour.length; i++) {
             assertEquals(example_bytes_twentyfour[i], Bytes.wrap(example_bytes_twentyfour).byteAt(i));
         }
+
+        try {
+            assertEquals(0, Bytes.allocate(1).byteAt(1));
+            fail();
+        } catch (IndexOutOfBoundsException e) {
+        }
     }
 
     @Test
@@ -152,4 +158,11 @@ public void entropy() throws Exception {
         assertTrue(Bytes.from(example_bytes_seven).entropy() > 2.5);
         assertTrue(Bytes.from(example_bytes_two).entropy() > 0.5);
     }
+
+    @Test
+    public void readOnly() throws Exception {
+        assertFalse(Bytes.from(example_bytes_twentyfour).isReadOnly());
+        assertTrue(Bytes.from(example_bytes_twentyfour).readOnly().isReadOnly());
+        assertTrue(Bytes.from(example_bytes_twentyfour).readOnly().copy().isReadOnly());
+    }
 }

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

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2017 Patrick Favre-Bulle
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 at.favre.lib.bytes;
+
+import org.junit.Test;
+
+import java.nio.ByteBuffer;
+
+import static org.junit.Assert.*;
+
+public class BytesSharedDataConverterTest extends ABytesTest {
+
+    @Test
+    public void array() throws Exception {
+        assertArrayEquals(new byte[0], Bytes.from(new byte[0]).array());
+        assertArrayEquals(example_bytes_one, Bytes.from(example_bytes_one).array());
+        assertArrayEquals(example_bytes_two, Bytes.from(example_bytes_two).array());
+        assertArrayEquals(example_bytes_four, Bytes.from(example_bytes_four).array());
+        assertArrayEquals(example_bytes_seven, Bytes.from(example_bytes_seven).array());
+        assertArrayEquals(example_bytes_eight, Bytes.from(example_bytes_eight).array());
+        assertArrayEquals(example_bytes_sixteen, Bytes.from(example_bytes_sixteen).array());
+    }
+
+    @Test
+    public void bigInteger() throws Exception {
+        assertArrayEquals(example_bytes_one, Bytes.from(example_bytes_one).bigInteger().toByteArray());
+        assertArrayEquals(example_bytes_two, Bytes.from(example_bytes_two).bigInteger().toByteArray());
+        assertArrayEquals(example_bytes_four, Bytes.from(example_bytes_four).bigInteger().toByteArray());
+        assertArrayEquals(example_bytes_seven, Bytes.from(example_bytes_seven).bigInteger().toByteArray());
+        assertArrayEquals(example_bytes_eight, Bytes.from(example_bytes_eight).bigInteger().toByteArray());
+        assertArrayEquals(example_bytes_sixteen, Bytes.from(example_bytes_sixteen).bigInteger().toByteArray());
+    }
+
+    @Test
+    public void buffer() throws Exception {
+        assertEquals(ByteBuffer.wrap(new byte[0]), Bytes.from(new byte[0]).buffer());
+        assertEquals(ByteBuffer.wrap(example_bytes_one), Bytes.from(example_bytes_one).buffer());
+        assertEquals(ByteBuffer.wrap(example_bytes_two), Bytes.from(example_bytes_two).buffer());
+        assertEquals(ByteBuffer.wrap(example_bytes_four), Bytes.from(example_bytes_four).buffer());
+        assertEquals(ByteBuffer.wrap(example_bytes_seven), Bytes.from(example_bytes_seven).buffer());
+        assertEquals(ByteBuffer.wrap(example_bytes_eight), Bytes.from(example_bytes_eight).buffer());
+        assertEquals(ByteBuffer.wrap(example_bytes_sixteen), Bytes.from(example_bytes_sixteen).buffer());
+    }
+
+    @Test
+    public void duplicate() throws Exception {
+        Bytes b = Bytes.from(example_bytes_sixteen);
+        Bytes b2 = b.duplicate();
+        assertNotSame(b, b2);
+        assertSame(b.array(), b2.array());
+    }
+
+    @Test
+    public void inputStream() throws Exception {
+        assertArrayEquals(example_bytes_one, Util.readFromStream(Bytes.from(example_bytes_one).inputStream()));
+        assertArrayEquals(example_bytes_two, Util.readFromStream(Bytes.from(example_bytes_two).inputStream()));
+        assertArrayEquals(example_bytes_four, Util.readFromStream(Bytes.from(example_bytes_four).inputStream()));
+        assertArrayEquals(example_bytes_sixteen, Util.readFromStream(Bytes.from(example_bytes_sixteen).inputStream()));
+    }
+}