fix: don't signal onComplete when a chunk is fully consumed by the range skip

AdjustedRangeSubscriber called onComplete (and fell through to an NPE) when
numBytesToSkip exceeded a chunk, so a small first chunk ended ranged GETs
with an empty stream. Consume the chunk toward the skip and wait for the
next one instead. Fixes #517.

Author: sharmabikram

src/main/java/software/amazon/encryption/s3/legacy/internal/AdjustedRangeSubscriber.java

@@ -61,11 +61,11 @@ public void onNext(ByteBuffer byteBuffer) {
 
         if (numBytesToSkip != 0) {
             byte[] buf = byteBuffer.array();
-            if (numBytesToSkip > buf.length) {
-                // If we need to skip past the available data,
-                // we are returning nothing, so signal completion
+            if (numBytesToSkip >= buf.length) {
+                // Chunk is fully consumed by the skip; wait for the next chunk
+                // rather than signaling completion.
                 numBytesToSkip -= buf.length;
-                wrappedSubscriber.onComplete();
+                return;
             } else {
                 outputBuffer = Arrays.copyOfRange(buf, numBytesToSkip, buf.length);
                 numBytesToSkip = 0;

src/test/java/software/amazon/encryption/s3/legacy/internal/AdjustedRangeSubscriberTest.java

@@ -0,0 +1,106 @@
+// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.encryption.s3.legacy.internal;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+import java.io.ByteArrayOutputStream;
+import java.nio.ByteBuffer;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.junit.jupiter.api.Test;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+public class AdjustedRangeSubscriberTest {
+
+    /**
+     * Records everything delivered downstream so tests can assert on bytes and
+     * terminal signals.
+     */
+    private static class RecordingSubscriber implements Subscriber<ByteBuffer> {
+        final ByteArrayOutputStream data = new ByteArrayOutputStream();
+        final AtomicInteger completeCount = new AtomicInteger();
+        Throwable error;
+
+        @Override
+        public void onSubscribe(Subscription s) {
+        }
+
+        @Override
+        public void onNext(ByteBuffer byteBuffer) {
+            byte[] b = new byte[byteBuffer.remaining()];
+            byteBuffer.get(b);
+            data.write(b, 0, b.length);
+        }
+
+        @Override
+        public void onError(Throwable t) {
+            error = t;
+        }
+
+        @Override
+        public void onComplete() {
+            completeCount.incrementAndGet();
+        }
+    }
+
+    private static ByteBuffer bytes(int start, int length) {
+        byte[] b = new byte[length];
+        for (int i = 0; i < length; i++) {
+            b[i] = (byte) (start + i);
+        }
+        return ByteBuffer.wrap(b);
+    }
+
+    @Test
+    public void testFirstChunkSmallerThanSkipDoesNotCompleteOrThrow() throws Exception {
+        // rangeBeginning=20 => numBytesToSkip=20, virtualAvailable=100
+        RecordingSubscriber downstream = new RecordingSubscriber();
+        AdjustedRangeSubscriber subscriber = new AdjustedRangeSubscriber(downstream, 20L, 119L);
+
+        // First chunk (10 bytes) is smaller than the 20-byte skip.
+        subscriber.onNext(bytes(0, 10));
+        assertEquals(0, downstream.completeCount.get());
+        assertNull(downstream.error);
+        assertEquals(0, downstream.data.size());
+
+        // Second chunk (10 bytes) exactly finishes the skip; still no data delivered.
+        subscriber.onNext(bytes(10, 10));
+        assertEquals(0, downstream.completeCount.get());
+        assertEquals(0, downstream.data.size());
+
+        // Third chunk carries the actual payload, which must now be delivered.
+        subscriber.onNext(bytes(100, 100));
+        assertArrayEquals(bytes(100, 100).array(), downstream.data.toByteArray());
+    }
+
+    @Test
+    public void testEmptyFirstChunkIsSkippedNotTreatedAsCompletion() throws Exception {
+        RecordingSubscriber downstream = new RecordingSubscriber();
+        AdjustedRangeSubscriber subscriber = new AdjustedRangeSubscriber(downstream, 20L, 119L);
+
+        // CipherSubscriber can emit an empty buffer; it must not complete the stream.
+        subscriber.onNext(ByteBuffer.allocate(0));
+        assertEquals(0, downstream.completeCount.get());
+        assertNull(downstream.error);
+
+        subscriber.onNext(bytes(0, 20)); // finish the skip
+        subscriber.onNext(bytes(50, 100));
+        assertArrayEquals(bytes(50, 100).array(), downstream.data.toByteArray());
+    }
+
+    @Test
+    public void testChunkLargerThanSkipDeliversRemainder() throws Exception {
+        RecordingSubscriber downstream = new RecordingSubscriber();
+        AdjustedRangeSubscriber subscriber = new AdjustedRangeSubscriber(downstream, 20L, 119L);
+
+        // A single 120-byte chunk: 20 skipped, 100 delivered.
+        subscriber.onNext(bytes(0, 120));
+        assertArrayEquals(bytes(20, 100).array(), downstream.data.toByteArray());
+        assertFalse(downstream.completeCount.get() == 0);
+    }
+}