Better tests

Serialize reads and writes in ByteArraySeekableByteChannel

Author: garydgregory

src/main/java/org/apache/commons/io/IOUtils.java

@@ -226,8 +226,10 @@ public class IOUtils {
      * <p>
      * The constant is copied from OpenJDK's {@link jdk.internal.util.ArraysSupport#SOFT_MAX_ARRAY_LENGTH}.
      * </p>
+     *
+     * @since 2.21.0
      */
-    private static final int SOFT_MAX_ARRAY_LENGTH = Integer.MAX_VALUE - 8;
+    public static final int SOFT_MAX_ARRAY_LENGTH = Integer.MAX_VALUE - 8;
 
     /**
      * Returns the given InputStream if it is already a {@link BufferedInputStream}, otherwise creates a

src/main/java/org/apache/commons/io/channels/ByteArraySeekableByteChannel.java

@@ -25,38 +25,34 @@
 import java.nio.channels.SeekableByteChannel;
 import java.util.Arrays;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.locks.ReentrantLock;
 
 import org.apache.commons.io.IOUtils;
 
 /**
  * A {@link SeekableByteChannel} implementation backed by a byte array.
  * <p>
- * When this channel is used for writing, an internal buffer grows to accommodate incoming data. The natural size limit is the value of
- * {@link Integer#MAX_VALUE} and it's not possible to {@link #position(long) set the position} or {@link #truncate(long) truncate} to a value bigger than that.
- * The raw internal buffer is accessed via {@link ByteArraySeekableByteChannel#array()}.
- * </p>
- * <p>
- * This class never throws {@link ClosedChannelException} because a byte array is not a resource you open or close.
- * </p>
- * <p>
- * This class isn't thread-safe.
+ * When used for writing, the internal buffer grows to accommodate incoming data. The natural size limit is the value of {@link IOUtils#SOFT_MAX_ARRAY_LENGTH}
+ * and it's not possible to {@link #position(long) set the position} or {@link #truncate(long) truncate} to a value bigger than that. The raw internal buffer is
+ * accessed via {@link ByteArraySeekableByteChannel#array()}.
  * </p>
  *
  * @since 2.19.0
  */
 public class ByteArraySeekableByteChannel implements SeekableByteChannel {
 
-    private static final int NAIVE_RESIZE_LIMIT = Integer.MAX_VALUE >> 1;
+    private static final int RESIZE_LIMIT = Integer.MAX_VALUE >> 1;
     private byte[] data;
     private final AtomicBoolean closed = new AtomicBoolean();
     private int position;
     private int size;
+    private final ReentrantLock lock = new ReentrantLock();
 
     /**
      * Constructs a new instance using a default empty buffer.
      */
     public ByteArraySeekableByteChannel() {
-        this(IOUtils.DEFAULT_BUFFER_SIZE);
+        this(0);
     }
 
     /**
@@ -90,17 +86,24 @@ public byte[] array() {
         return data;
     }
 
-    @Override
-    public void close() {
-        closed.set(true);
-    }
-
-    private void ensureOpen() throws ClosedChannelException {
+    private void checkOpen() throws ClosedChannelException {
         if (!isOpen()) {
             throw new ClosedChannelException();
         }
     }
 
+    private int checkRange(final long newSize, final String method) {
+        if (newSize < 0L || newSize > IOUtils.SOFT_MAX_ARRAY_LENGTH) {
+            throw new IllegalArgumentException(String.format("%s must be in range [0..%,d]: %,d", method, IOUtils.SOFT_MAX_ARRAY_LENGTH, newSize));
+        }
+        return (int) newSize;
+    }
+
+    @Override
+    public void close() {
+        closed.set(true);
+    }
+
     /**
      * Like {@link #size()} but never throws {@link ClosedChannelException}.
      *
@@ -117,42 +120,55 @@ public boolean isOpen() {
 
     @Override
     public long position() throws ClosedChannelException {
-        ensureOpen();
-        return position;
+        checkOpen();
+        lock.lock();
+        try {
+            return position;
+        } finally {
+            lock.unlock();
+        }
     }
 
     @Override
     public SeekableByteChannel position(final long newPosition) throws IOException {
-        ensureOpen();
-        if (newPosition < 0L || newPosition > Integer.MAX_VALUE) {
-            throw new IOException("Position must be in range [0.." + Integer.MAX_VALUE + "]");
+        checkOpen();
+        final int intPos = checkRange(newPosition, "position()");
+        lock.lock();
+        try {
+            position = intPos;
+        } finally {
+            lock.unlock();
         }
-        position = (int) newPosition;
         return this;
     }
 
     @Override
     public int read(final ByteBuffer buf) throws IOException {
-        ensureOpen();
-        int wanted = buf.remaining();
-        final int possible = size - position;
-        if (possible <= 0) {
-            return -1;
-        }
-        if (wanted > possible) {
-            wanted = possible;
+        checkOpen();
+        lock.lock();
+        try {
+            int wanted = buf.remaining();
+            final int possible = size - position;
+            if (possible <= 0) {
+                return IOUtils.EOF;
+            }
+            if (wanted > possible) {
+                wanted = possible;
+            }
+            buf.put(data, position, wanted);
+            position += wanted;
+            return wanted;
+        } finally {
+            lock.unlock();
         }
-        buf.put(data, position, wanted);
-        position += wanted;
-        return wanted;
     }
 
     private void resize(final int newLength) {
         int len = data.length;
         if (len <= 0) {
             len = 1;
         }
-        if (newLength < NAIVE_RESIZE_LIMIT) {
+        if (newLength < RESIZE_LIMIT) {
             while (len < newLength) {
                 len <<= 1;
             }
@@ -164,44 +180,57 @@ private void resize(final int newLength) {
 
     @Override
     public long size() throws ClosedChannelException {
-        ensureOpen();
-        return size;
+        checkOpen();
+        lock.lock();
+        try {
+            return size;
+        } finally {
+            lock.unlock();
+        }
     }
 
     @Override
     public SeekableByteChannel truncate(final long newSize) throws ClosedChannelException {
-        ensureOpen();
-        if (newSize < 0L || newSize > Integer.MAX_VALUE) {
-            throw new IllegalArgumentException("Size must be range [0.." + Integer.MAX_VALUE + "]");
-        }
-        if (size > newSize) {
-            size = (int) newSize;
-        }
-        if (position > newSize) {
-            position = (int) newSize;
+        checkOpen();
+        final int intSize = checkRange(newSize, "truncate()");
+        lock.lock();
+        try {
+            if (size > intSize) {
+                size = intSize;
+            }
+            if (position > intSize) {
+                position = intSize;
+            }
+        } finally {
+            lock.unlock();
         }
         return this;
     }
 
     @Override
     public int write(final ByteBuffer b) throws IOException {
-        ensureOpen();
-        int wanted = b.remaining();
-        final int possibleWithoutResize = size - position;
-        if (wanted > possibleWithoutResize) {
-            final int newSize = position + wanted;
-            if (newSize < 0) { // overflow
-                resize(Integer.MAX_VALUE);
-                wanted = Integer.MAX_VALUE - position;
-            } else {
-                resize(newSize);
+        checkOpen();
+        lock.lock();
+        try {
+            int wanted = b.remaining();
+            final int possibleWithoutResize = size - position;
+            if (wanted > possibleWithoutResize) {
+                final int newSize = position + wanted;
+                if (newSize < 0) { // overflow
+                    resize(IOUtils.SOFT_MAX_ARRAY_LENGTH);
+                    wanted = IOUtils.SOFT_MAX_ARRAY_LENGTH - position;
+                } else {
+                    resize(newSize);
+                }
             }
+            b.get(data, position, wanted);
+            position += wanted;
+            if (size < position) {
+                size = position;
+            }
+            return wanted;
+        } finally {
+            lock.unlock();
         }
-        b.get(data, position, wanted);
-        position += wanted;
-        if (size < position) {
-            size = position;
-        }
-        return wanted;
     }
 }