aboutsummaryrefslogtreecommitdiff
path: root/jimfs/src/test/java/com/google/common/jimfs/JimfsInputStreamTest.java
diff options
context:
space:
mode:
Diffstat (limited to 'jimfs/src/test/java/com/google/common/jimfs/JimfsInputStreamTest.java')
-rw-r--r--jimfs/src/test/java/com/google/common/jimfs/JimfsInputStreamTest.java240
1 files changed, 240 insertions, 0 deletions
diff --git a/jimfs/src/test/java/com/google/common/jimfs/JimfsInputStreamTest.java b/jimfs/src/test/java/com/google/common/jimfs/JimfsInputStreamTest.java
new file mode 100644
index 0000000..94cc5f4
--- /dev/null
+++ b/jimfs/src/test/java/com/google/common/jimfs/JimfsInputStreamTest.java
@@ -0,0 +1,240 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Licensed 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 com.google.common.jimfs;
+
+import static com.google.common.jimfs.TestUtils.bytes;
+import static com.google.common.jimfs.TestUtils.regularFile;
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.fail;
+
+import com.google.common.util.concurrent.Runnables;
+import java.io.IOException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link JimfsInputStream}.
+ *
+ * @author Colin Decker
+ */
+@RunWith(JUnit4.class)
+@SuppressWarnings("ResultOfMethodCallIgnored")
+public class JimfsInputStreamTest {
+
+ @Test
+ public void testRead_singleByte() throws IOException {
+ JimfsInputStream in = newInputStream(2);
+ assertThat(in.read()).isEqualTo(2);
+ assertEmpty(in);
+ }
+
+ @Test
+ public void testRead_wholeArray() throws IOException {
+ JimfsInputStream in = newInputStream(1, 2, 3, 4, 5, 6, 7, 8);
+ byte[] bytes = new byte[8];
+ assertThat(in.read(bytes)).isEqualTo(8);
+ assertArrayEquals(bytes(1, 2, 3, 4, 5, 6, 7, 8), bytes);
+ assertEmpty(in);
+ }
+
+ @Test
+ public void testRead_wholeArray_arrayLarger() throws IOException {
+ JimfsInputStream in = newInputStream(1, 2, 3, 4, 5, 6, 7, 8);
+ byte[] bytes = new byte[12];
+ assertThat(in.read(bytes)).isEqualTo(8);
+ assertArrayEquals(bytes(1, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0, 0), bytes);
+ assertEmpty(in);
+ }
+
+ @Test
+ public void testRead_wholeArray_arraySmaller() throws IOException {
+ JimfsInputStream in = newInputStream(1, 2, 3, 4, 5, 6, 7, 8);
+ byte[] bytes = new byte[6];
+ assertThat(in.read(bytes)).isEqualTo(6);
+ assertArrayEquals(bytes(1, 2, 3, 4, 5, 6), bytes);
+ bytes = new byte[6];
+ assertThat(in.read(bytes)).isEqualTo(2);
+ assertArrayEquals(bytes(7, 8, 0, 0, 0, 0), bytes);
+ assertEmpty(in);
+ }
+
+ @Test
+ public void testRead_partialArray() throws IOException {
+ JimfsInputStream in = newInputStream(1, 2, 3, 4, 5, 6, 7, 8);
+ byte[] bytes = new byte[12];
+ assertThat(in.read(bytes, 0, 8)).isEqualTo(8);
+ assertArrayEquals(bytes(1, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0, 0), bytes);
+ assertEmpty(in);
+ }
+
+ @Test
+ public void testRead_partialArray_sliceLarger() throws IOException {
+ JimfsInputStream in = newInputStream(1, 2, 3, 4, 5, 6, 7, 8);
+ byte[] bytes = new byte[12];
+ assertThat(in.read(bytes, 0, 10)).isEqualTo(8);
+ assertArrayEquals(bytes(1, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0, 0), bytes);
+ assertEmpty(in);
+ }
+
+ @Test
+ public void testRead_partialArray_sliceSmaller() throws IOException {
+ JimfsInputStream in = newInputStream(1, 2, 3, 4, 5, 6, 7, 8);
+ byte[] bytes = new byte[12];
+ assertThat(in.read(bytes, 0, 6)).isEqualTo(6);
+ assertArrayEquals(bytes(1, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0, 0), bytes);
+ assertThat(in.read(bytes, 6, 6)).isEqualTo(2);
+ assertArrayEquals(bytes(1, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0, 0), bytes);
+ assertEmpty(in);
+ }
+
+ @Test
+ public void testRead_partialArray_invalidInput() throws IOException {
+ JimfsInputStream in = newInputStream(1, 2, 3, 4, 5);
+
+ try {
+ in.read(new byte[3], -1, 1);
+ fail();
+ } catch (IndexOutOfBoundsException expected) {
+ }
+
+ try {
+ in.read(new byte[3], 0, 4);
+ fail();
+ } catch (IndexOutOfBoundsException expected) {
+ }
+
+ try {
+ in.read(new byte[3], 1, 3);
+ fail();
+ } catch (IndexOutOfBoundsException expected) {
+ }
+ }
+
+ @Test
+ public void testAvailable() throws IOException {
+ JimfsInputStream in = newInputStream(1, 2, 3, 4, 5, 6, 7, 8);
+ assertThat(in.available()).isEqualTo(8);
+ assertThat(in.read()).isEqualTo(1);
+ assertThat(in.available()).isEqualTo(7);
+ assertThat(in.read(new byte[3])).isEqualTo(3);
+ assertThat(in.available()).isEqualTo(4);
+ assertThat(in.read(new byte[10], 1, 2)).isEqualTo(2);
+ assertThat(in.available()).isEqualTo(2);
+ assertThat(in.read(new byte[10])).isEqualTo(2);
+ assertThat(in.available()).isEqualTo(0);
+ }
+
+ @Test
+ public void testSkip() throws IOException {
+ JimfsInputStream in = newInputStream(1, 2, 3, 4, 5, 6, 7, 8);
+ assertThat(in.skip(0)).isEqualTo(0);
+ assertThat(in.skip(-10)).isEqualTo(0);
+ assertThat(in.skip(2)).isEqualTo(2);
+ assertThat(in.read()).isEqualTo(3);
+ assertThat(in.skip(3)).isEqualTo(3);
+ assertThat(in.read()).isEqualTo(7);
+ assertThat(in.skip(10)).isEqualTo(1);
+ assertEmpty(in);
+ assertThat(in.skip(10)).isEqualTo(0);
+ assertEmpty(in);
+ }
+
+ @SuppressWarnings("GuardedByChecker")
+ @Test
+ public void testFullyReadInputStream_doesNotChangeStateWhenStoreChanges() throws IOException {
+ JimfsInputStream in = newInputStream(1, 2, 3, 4, 5);
+ assertThat(in.read(new byte[5])).isEqualTo(5);
+ assertEmpty(in);
+
+ in.file.write(5, new byte[10], 0, 10); // append more bytes to file
+ assertEmpty(in);
+ }
+
+ @Test
+ public void testMark_unsupported() throws IOException {
+ JimfsInputStream in = newInputStream(1, 2, 3);
+ assertThat(in.markSupported()).isFalse();
+
+ // mark does nothing
+ in.mark(1);
+
+ try {
+ // reset throws IOException when unsupported
+ in.reset();
+ fail();
+ } catch (IOException expected) {
+ }
+ }
+
+ @Test
+ public void testClosedInputStream_throwsException() throws IOException {
+ JimfsInputStream in = newInputStream(1, 2, 3);
+ in.close();
+
+ try {
+ in.read();
+ fail();
+ } catch (IOException expected) {
+ }
+
+ try {
+ in.read(new byte[3]);
+ fail();
+ } catch (IOException expected) {
+ }
+
+ try {
+ in.read(new byte[10], 0, 2);
+ fail();
+ } catch (IOException expected) {
+ }
+
+ try {
+ in.skip(10);
+ fail();
+ } catch (IOException expected) {
+ }
+
+ try {
+ in.available();
+ fail();
+ } catch (IOException expected) {
+ }
+
+ in.close(); // does nothing
+ }
+
+ private static JimfsInputStream newInputStream(int... bytes) throws IOException {
+ byte[] b = new byte[bytes.length];
+ for (int i = 0; i < bytes.length; i++) {
+ b[i] = (byte) bytes[i];
+ }
+
+ RegularFile file = regularFile(0);
+ file.write(0, b, 0, b.length);
+ return new JimfsInputStream(file, new FileSystemState(Runnables.doNothing()));
+ }
+
+ private static void assertEmpty(JimfsInputStream in) throws IOException {
+ assertThat(in.read()).isEqualTo(-1);
+ assertThat(in.read(new byte[3])).isEqualTo(-1);
+ assertThat(in.read(new byte[10], 1, 5)).isEqualTo(-1);
+ assertThat(in.available()).isEqualTo(0);
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-24 02:12:50 +0000