|
@@ -0,0 +1,527 @@
|
|
|
+/*
|
|
|
+ * 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 org.apache.hadoop.fs.azure;
|
|
|
+
|
|
|
+import java.io.EOFException;
|
|
|
+import java.io.FileNotFoundException;
|
|
|
+import java.io.IOException;
|
|
|
+import java.util.EnumSet;
|
|
|
+import java.util.concurrent.Callable;
|
|
|
+
|
|
|
+import org.junit.FixMethodOrder;
|
|
|
+import org.junit.Rule;
|
|
|
+import org.junit.Test;
|
|
|
+import org.junit.rules.Timeout;
|
|
|
+import org.junit.runners.MethodSorters;
|
|
|
+import org.slf4j.Logger;
|
|
|
+import org.slf4j.LoggerFactory;
|
|
|
+
|
|
|
+import org.apache.hadoop.conf.Configuration;
|
|
|
+import org.apache.hadoop.fs.FSDataInputStream;
|
|
|
+import org.apache.hadoop.fs.FSDataOutputStream;
|
|
|
+import org.apache.hadoop.fs.FSExceptionMessages;
|
|
|
+import org.apache.hadoop.fs.FileStatus;
|
|
|
+import org.apache.hadoop.fs.Path;
|
|
|
+import org.apache.hadoop.fs.contract.ContractTestUtils;
|
|
|
+
|
|
|
+import static org.apache.hadoop.test.LambdaTestUtils.intercept;
|
|
|
+
|
|
|
+/**
|
|
|
+ * Test semantics of the page blob input stream
|
|
|
+ */
|
|
|
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
|
|
|
+
|
|
|
+public class ITestPageBlobInputStream extends AbstractWasbTestBase {
|
|
|
+ private static final Logger LOG = LoggerFactory.getLogger(
|
|
|
+ ITestPageBlobInputStream.class);
|
|
|
+ private static final int KILOBYTE = 1024;
|
|
|
+ private static final int MEGABYTE = KILOBYTE * KILOBYTE;
|
|
|
+ private static final int TEST_FILE_SIZE = 6 * MEGABYTE;
|
|
|
+ private static final Path TEST_FILE_PATH = new Path(
|
|
|
+ "TestPageBlobInputStream.txt");
|
|
|
+
|
|
|
+ private long testFileLength;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Long test timeout.
|
|
|
+ */
|
|
|
+ @Rule
|
|
|
+ public Timeout testTimeout = new Timeout(10 * 60 * 1000);
|
|
|
+ private FileStatus testFileStatus;
|
|
|
+ private Path hugefile;
|
|
|
+
|
|
|
+ @Override
|
|
|
+ public void setUp() throws Exception {
|
|
|
+ super.setUp();
|
|
|
+ createTestAccount();
|
|
|
+
|
|
|
+ hugefile = fs.makeQualified(TEST_FILE_PATH);
|
|
|
+ try {
|
|
|
+ testFileStatus = fs.getFileStatus(TEST_FILE_PATH);
|
|
|
+ testFileLength = testFileStatus.getLen();
|
|
|
+ } catch (FileNotFoundException e) {
|
|
|
+ // file doesn't exist
|
|
|
+ testFileLength = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ @Override
|
|
|
+ protected AzureBlobStorageTestAccount createTestAccount() throws Exception {
|
|
|
+ Configuration conf = new Configuration();
|
|
|
+
|
|
|
+ // Configure the page blob directories key so every file created is a page blob.
|
|
|
+ conf.set(AzureNativeFileSystemStore.KEY_PAGE_BLOB_DIRECTORIES, "/");
|
|
|
+
|
|
|
+ return AzureBlobStorageTestAccount.create(
|
|
|
+ "testpageblobinputstream",
|
|
|
+ EnumSet.of(AzureBlobStorageTestAccount.CreateOptions.CreateContainer),
|
|
|
+ conf,
|
|
|
+ true);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Create a test file by repeating the characters in the alphabet.
|
|
|
+ * @throws IOException
|
|
|
+ */
|
|
|
+ private void createTestFileAndSetLength() throws IOException {
|
|
|
+ // To reduce test run time, the test file can be reused.
|
|
|
+ if (fs.exists(TEST_FILE_PATH)) {
|
|
|
+ testFileStatus = fs.getFileStatus(TEST_FILE_PATH);
|
|
|
+ testFileLength = testFileStatus.getLen();
|
|
|
+ LOG.info("Reusing test file: {}", testFileStatus);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ byte[] buffer = new byte[256];
|
|
|
+ for (int i = 0; i < buffer.length; i++) {
|
|
|
+ buffer[i] = (byte) i;
|
|
|
+ }
|
|
|
+
|
|
|
+ LOG.info("Creating test file {} of size: {}", TEST_FILE_PATH,
|
|
|
+ TEST_FILE_SIZE);
|
|
|
+
|
|
|
+ try(FSDataOutputStream outputStream = fs.create(TEST_FILE_PATH)) {
|
|
|
+ int bytesWritten = 0;
|
|
|
+ while (bytesWritten < TEST_FILE_SIZE) {
|
|
|
+ outputStream.write(buffer);
|
|
|
+ bytesWritten += buffer.length;
|
|
|
+ }
|
|
|
+ LOG.info("Closing stream {}", outputStream);
|
|
|
+ outputStream.close();
|
|
|
+ }
|
|
|
+ testFileLength = fs.getFileStatus(TEST_FILE_PATH).getLen();
|
|
|
+ }
|
|
|
+
|
|
|
+ void assumeHugeFileExists() throws IOException {
|
|
|
+ ContractTestUtils.assertPathExists(fs, "huge file not created", hugefile);
|
|
|
+ FileStatus status = fs.getFileStatus(hugefile);
|
|
|
+ ContractTestUtils.assertIsFile(hugefile, status);
|
|
|
+ assertTrue("File " + hugefile + " is empty", status.getLen() > 0);
|
|
|
+ }
|
|
|
+
|
|
|
+ @Test
|
|
|
+ public void test_0100_CreateHugeFile() throws IOException {
|
|
|
+ createTestFileAndSetLength();
|
|
|
+ }
|
|
|
+
|
|
|
+ @Test
|
|
|
+ public void test_0200_BasicReadTest() throws Exception {
|
|
|
+ assumeHugeFileExists();
|
|
|
+
|
|
|
+ try (
|
|
|
+ FSDataInputStream inputStream = fs.open(TEST_FILE_PATH);
|
|
|
+ ) {
|
|
|
+ byte[] buffer = new byte[3 * MEGABYTE];
|
|
|
+
|
|
|
+ // v1 forward seek and read a kilobyte into first kilobyte of buffer
|
|
|
+ long position = 5 * MEGABYTE;
|
|
|
+ inputStream.seek(position);
|
|
|
+ int numBytesRead = inputStream.read(buffer, 0, KILOBYTE);
|
|
|
+ assertEquals(KILOBYTE, numBytesRead);
|
|
|
+
|
|
|
+ byte[] expected = new byte[3 * MEGABYTE];
|
|
|
+
|
|
|
+ for (int i = 0; i < KILOBYTE; i++) {
|
|
|
+ expected[i] = (byte) ((i + position) % 256);
|
|
|
+ }
|
|
|
+
|
|
|
+ assertArrayEquals(expected, buffer);
|
|
|
+
|
|
|
+ int len = MEGABYTE;
|
|
|
+ int offset = buffer.length - len;
|
|
|
+
|
|
|
+ // v1 reverse seek and read a megabyte into last megabyte of buffer
|
|
|
+ position = 3 * MEGABYTE;
|
|
|
+ inputStream.seek(position);
|
|
|
+ numBytesRead = inputStream.read(buffer, offset, len);
|
|
|
+ assertEquals(len, numBytesRead);
|
|
|
+
|
|
|
+ for (int i = offset; i < offset + len; i++) {
|
|
|
+ expected[i] = (byte) ((i + position) % 256);
|
|
|
+ }
|
|
|
+
|
|
|
+ assertArrayEquals(expected, buffer);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ @Test
|
|
|
+ public void test_0201_RandomReadTest() throws Exception {
|
|
|
+ assumeHugeFileExists();
|
|
|
+
|
|
|
+ try (
|
|
|
+ FSDataInputStream inputStream = fs.open(TEST_FILE_PATH);
|
|
|
+ ) {
|
|
|
+ final int bufferSize = 4 * KILOBYTE;
|
|
|
+ byte[] buffer = new byte[bufferSize];
|
|
|
+ long position = 0;
|
|
|
+
|
|
|
+ verifyConsistentReads(inputStream, buffer, position);
|
|
|
+
|
|
|
+ inputStream.seek(0);
|
|
|
+
|
|
|
+ verifyConsistentReads(inputStream, buffer, position);
|
|
|
+
|
|
|
+ int seekPosition = 2 * KILOBYTE;
|
|
|
+ inputStream.seek(seekPosition);
|
|
|
+ position = seekPosition;
|
|
|
+ verifyConsistentReads(inputStream, buffer, position);
|
|
|
+
|
|
|
+ inputStream.seek(0);
|
|
|
+ position = 0;
|
|
|
+ verifyConsistentReads(inputStream, buffer, position);
|
|
|
+
|
|
|
+ seekPosition = 5 * KILOBYTE;
|
|
|
+ inputStream.seek(seekPosition);
|
|
|
+ position = seekPosition;
|
|
|
+ verifyConsistentReads(inputStream, buffer, position);
|
|
|
+
|
|
|
+ seekPosition = 10 * KILOBYTE;
|
|
|
+ inputStream.seek(seekPosition);
|
|
|
+ position = seekPosition;
|
|
|
+ verifyConsistentReads(inputStream, buffer, position);
|
|
|
+
|
|
|
+ seekPosition = 4100 * KILOBYTE;
|
|
|
+ inputStream.seek(seekPosition);
|
|
|
+ position = seekPosition;
|
|
|
+ verifyConsistentReads(inputStream, buffer, position);
|
|
|
+
|
|
|
+ for (int i = 4 * 1024 * 1023; i < 5000; i++) {
|
|
|
+ seekPosition = i;
|
|
|
+ inputStream.seek(seekPosition);
|
|
|
+ position = seekPosition;
|
|
|
+ verifyConsistentReads(inputStream, buffer, position);
|
|
|
+ }
|
|
|
+
|
|
|
+ inputStream.seek(0);
|
|
|
+ position = 0;
|
|
|
+ buffer = new byte[1];
|
|
|
+
|
|
|
+ for (int i = 0; i < 5000; i++) {
|
|
|
+ assertEquals(1, inputStream.skip(1));
|
|
|
+ position++;
|
|
|
+ verifyConsistentReads(inputStream, buffer, position);
|
|
|
+ position++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private void verifyConsistentReads(FSDataInputStream inputStream,
|
|
|
+ byte[] buffer,
|
|
|
+ long position) throws IOException {
|
|
|
+ int size = buffer.length;
|
|
|
+ final int numBytesRead = inputStream.read(buffer, 0, size);
|
|
|
+ assertEquals("Bytes read from stream", size, numBytesRead);
|
|
|
+
|
|
|
+ byte[] expected = new byte[size];
|
|
|
+ for (int i = 0; i < expected.length; i++) {
|
|
|
+ expected[i] = (byte) ((position + i) % 256);
|
|
|
+ }
|
|
|
+
|
|
|
+ assertArrayEquals("Mismatch", expected, buffer);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Validates the implementation of InputStream.markSupported.
|
|
|
+ * @throws IOException
|
|
|
+ */
|
|
|
+ @Test
|
|
|
+ public void test_0301_MarkSupported() throws IOException {
|
|
|
+ assumeHugeFileExists();
|
|
|
+ try (FSDataInputStream inputStream = fs.open(TEST_FILE_PATH)) {
|
|
|
+ assertTrue("mark is not supported", inputStream.markSupported());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Validates the implementation of InputStream.mark and reset
|
|
|
+ * for version 1 of the block blob input stream.
|
|
|
+ * @throws Exception
|
|
|
+ */
|
|
|
+ @Test
|
|
|
+ public void test_0303_MarkAndResetV1() throws Exception {
|
|
|
+ assumeHugeFileExists();
|
|
|
+ try (FSDataInputStream inputStream = fs.open(TEST_FILE_PATH)) {
|
|
|
+ inputStream.mark(KILOBYTE - 1);
|
|
|
+
|
|
|
+ byte[] buffer = new byte[KILOBYTE];
|
|
|
+ int bytesRead = inputStream.read(buffer);
|
|
|
+ assertEquals(buffer.length, bytesRead);
|
|
|
+
|
|
|
+ inputStream.reset();
|
|
|
+ assertEquals("rest -> pos 0", 0, inputStream.getPos());
|
|
|
+
|
|
|
+ inputStream.mark(8 * KILOBYTE - 1);
|
|
|
+
|
|
|
+ buffer = new byte[8 * KILOBYTE];
|
|
|
+ bytesRead = inputStream.read(buffer);
|
|
|
+ assertEquals(buffer.length, bytesRead);
|
|
|
+
|
|
|
+ intercept(IOException.class,
|
|
|
+ "Resetting to invalid mark",
|
|
|
+ new Callable<FSDataInputStream>() {
|
|
|
+ @Override
|
|
|
+ public FSDataInputStream call() throws Exception {
|
|
|
+ inputStream.reset();
|
|
|
+ return inputStream;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ );
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Validates the implementation of Seekable.seekToNewSource, which should
|
|
|
+ * return false for version 1 of the block blob input stream.
|
|
|
+ * @throws IOException
|
|
|
+ */
|
|
|
+ @Test
|
|
|
+ public void test_0305_SeekToNewSourceV1() throws IOException {
|
|
|
+ assumeHugeFileExists();
|
|
|
+ try (FSDataInputStream inputStream = fs.open(TEST_FILE_PATH)) {
|
|
|
+ assertFalse(inputStream.seekToNewSource(0));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Validates the implementation of InputStream.skip and ensures there is no
|
|
|
+ * network I/O for version 1 of the block blob input stream.
|
|
|
+ * @throws Exception
|
|
|
+ */
|
|
|
+ @Test
|
|
|
+ public void test_0307_SkipBounds() throws Exception {
|
|
|
+ assumeHugeFileExists();
|
|
|
+ try (FSDataInputStream inputStream = fs.open(TEST_FILE_PATH)) {
|
|
|
+ long skipped = inputStream.skip(-1);
|
|
|
+ assertEquals(0, skipped);
|
|
|
+
|
|
|
+ skipped = inputStream.skip(0);
|
|
|
+ assertEquals(0, skipped);
|
|
|
+
|
|
|
+ assertTrue(testFileLength > 0);
|
|
|
+
|
|
|
+ skipped = inputStream.skip(testFileLength);
|
|
|
+ assertEquals(testFileLength, skipped);
|
|
|
+
|
|
|
+ intercept(EOFException.class,
|
|
|
+ new Callable<Long>() {
|
|
|
+ @Override
|
|
|
+ public Long call() throws Exception {
|
|
|
+ return inputStream.skip(1);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ );
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Validates the implementation of Seekable.seek and ensures there is no
|
|
|
+ * network I/O for forward seek.
|
|
|
+ * @throws Exception
|
|
|
+ */
|
|
|
+ @Test
|
|
|
+ public void test_0309_SeekBounds() throws Exception {
|
|
|
+ assumeHugeFileExists();
|
|
|
+ try (
|
|
|
+ FSDataInputStream inputStream = fs.open(TEST_FILE_PATH);
|
|
|
+ ) {
|
|
|
+ inputStream.seek(0);
|
|
|
+ assertEquals(0, inputStream.getPos());
|
|
|
+
|
|
|
+ intercept(EOFException.class,
|
|
|
+ FSExceptionMessages.NEGATIVE_SEEK,
|
|
|
+ new Callable<FSDataInputStream>() {
|
|
|
+ @Override
|
|
|
+ public FSDataInputStream call() throws Exception {
|
|
|
+ inputStream.seek(-1);
|
|
|
+ return inputStream;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ );
|
|
|
+
|
|
|
+ assertTrue("Test file length only " + testFileLength, testFileLength > 0);
|
|
|
+ inputStream.seek(testFileLength);
|
|
|
+ assertEquals(testFileLength, inputStream.getPos());
|
|
|
+
|
|
|
+ intercept(EOFException.class,
|
|
|
+ FSExceptionMessages.CANNOT_SEEK_PAST_EOF,
|
|
|
+ new Callable<FSDataInputStream>() {
|
|
|
+ @Override
|
|
|
+ public FSDataInputStream call() throws Exception {
|
|
|
+ inputStream.seek(testFileLength + 1);
|
|
|
+ return inputStream;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ );
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Validates the implementation of Seekable.seek, Seekable.getPos,
|
|
|
+ * and InputStream.available.
|
|
|
+ * @throws Exception
|
|
|
+ */
|
|
|
+ @Test
|
|
|
+ public void test_0311_SeekAndAvailableAndPosition() throws Exception {
|
|
|
+ assumeHugeFileExists();
|
|
|
+ try (FSDataInputStream inputStream = fs.open(TEST_FILE_PATH)) {
|
|
|
+ byte[] expected1 = {0, 1, 2};
|
|
|
+ byte[] expected2 = {3, 4, 5};
|
|
|
+ byte[] expected3 = {1, 2, 3};
|
|
|
+ byte[] expected4 = {6, 7, 8};
|
|
|
+ byte[] buffer = new byte[3];
|
|
|
+
|
|
|
+ int bytesRead = inputStream.read(buffer);
|
|
|
+ assertEquals(buffer.length, bytesRead);
|
|
|
+ assertArrayEquals(expected1, buffer);
|
|
|
+ assertEquals(buffer.length, inputStream.getPos());
|
|
|
+ assertEquals(testFileLength - inputStream.getPos(),
|
|
|
+ inputStream.available());
|
|
|
+
|
|
|
+ bytesRead = inputStream.read(buffer);
|
|
|
+ assertEquals(buffer.length, bytesRead);
|
|
|
+ assertArrayEquals(expected2, buffer);
|
|
|
+ assertEquals(2 * buffer.length, inputStream.getPos());
|
|
|
+ assertEquals(testFileLength - inputStream.getPos(),
|
|
|
+ inputStream.available());
|
|
|
+
|
|
|
+ // reverse seek
|
|
|
+ int seekPos = 0;
|
|
|
+ inputStream.seek(seekPos);
|
|
|
+
|
|
|
+ bytesRead = inputStream.read(buffer);
|
|
|
+ assertEquals(buffer.length, bytesRead);
|
|
|
+ assertArrayEquals(expected1, buffer);
|
|
|
+ assertEquals(buffer.length + seekPos, inputStream.getPos());
|
|
|
+ assertEquals(testFileLength - inputStream.getPos(),
|
|
|
+ inputStream.available());
|
|
|
+
|
|
|
+ // reverse seek
|
|
|
+ seekPos = 1;
|
|
|
+ inputStream.seek(seekPos);
|
|
|
+
|
|
|
+ bytesRead = inputStream.read(buffer);
|
|
|
+ assertEquals(buffer.length, bytesRead);
|
|
|
+ assertArrayEquals(expected3, buffer);
|
|
|
+ assertEquals(buffer.length + seekPos, inputStream.getPos());
|
|
|
+ assertEquals(testFileLength - inputStream.getPos(),
|
|
|
+ inputStream.available());
|
|
|
+
|
|
|
+ // forward seek
|
|
|
+ seekPos = 6;
|
|
|
+ inputStream.seek(seekPos);
|
|
|
+
|
|
|
+ bytesRead = inputStream.read(buffer);
|
|
|
+ assertEquals(buffer.length, bytesRead);
|
|
|
+ assertArrayEquals(expected4, buffer);
|
|
|
+ assertEquals(buffer.length + seekPos, inputStream.getPos());
|
|
|
+ assertEquals(testFileLength - inputStream.getPos(),
|
|
|
+ inputStream.available());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Validates the implementation of InputStream.skip, Seekable.getPos,
|
|
|
+ * and InputStream.available.
|
|
|
+ * @throws IOException
|
|
|
+ */
|
|
|
+ @Test
|
|
|
+ public void test_0313_SkipAndAvailableAndPosition() throws IOException {
|
|
|
+ assumeHugeFileExists();
|
|
|
+ try (
|
|
|
+ FSDataInputStream inputStream = fs.open(TEST_FILE_PATH);
|
|
|
+ ) {
|
|
|
+ byte[] expected1 = {0, 1, 2};
|
|
|
+ byte[] expected2 = {3, 4, 5};
|
|
|
+ byte[] expected3 = {1, 2, 3};
|
|
|
+ byte[] expected4 = {6, 7, 8};
|
|
|
+ assertEquals(testFileLength, inputStream.available());
|
|
|
+ assertEquals(0, inputStream.getPos());
|
|
|
+
|
|
|
+ int n = 3;
|
|
|
+ long skipped = inputStream.skip(n);
|
|
|
+
|
|
|
+ assertEquals(skipped, inputStream.getPos());
|
|
|
+ assertEquals(testFileLength - inputStream.getPos(),
|
|
|
+ inputStream.available());
|
|
|
+ assertEquals(skipped, n);
|
|
|
+
|
|
|
+ byte[] buffer = new byte[3];
|
|
|
+ int bytesRead = inputStream.read(buffer);
|
|
|
+ assertEquals(buffer.length, bytesRead);
|
|
|
+ assertArrayEquals(expected2, buffer);
|
|
|
+ assertEquals(buffer.length + skipped, inputStream.getPos());
|
|
|
+ assertEquals(testFileLength - inputStream.getPos(),
|
|
|
+ inputStream.available());
|
|
|
+
|
|
|
+ // does skip still work after seek?
|
|
|
+ int seekPos = 1;
|
|
|
+ inputStream.seek(seekPos);
|
|
|
+
|
|
|
+ bytesRead = inputStream.read(buffer);
|
|
|
+ assertEquals(buffer.length, bytesRead);
|
|
|
+ assertArrayEquals(expected3, buffer);
|
|
|
+ assertEquals(buffer.length + seekPos, inputStream.getPos());
|
|
|
+ assertEquals(testFileLength - inputStream.getPos(),
|
|
|
+ inputStream.available());
|
|
|
+
|
|
|
+ long currentPosition = inputStream.getPos();
|
|
|
+ n = 2;
|
|
|
+ skipped = inputStream.skip(n);
|
|
|
+
|
|
|
+ assertEquals(currentPosition + skipped, inputStream.getPos());
|
|
|
+ assertEquals(testFileLength - inputStream.getPos(),
|
|
|
+ inputStream.available());
|
|
|
+ assertEquals(skipped, n);
|
|
|
+
|
|
|
+ bytesRead = inputStream.read(buffer);
|
|
|
+ assertEquals(buffer.length, bytesRead);
|
|
|
+ assertArrayEquals(expected4, buffer);
|
|
|
+ assertEquals(buffer.length + skipped + currentPosition,
|
|
|
+ inputStream.getPos());
|
|
|
+ assertEquals(testFileLength - inputStream.getPos(),
|
|
|
+ inputStream.available());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ @Test
|
|
|
+ public void test_999_DeleteHugeFiles() throws IOException {
|
|
|
+ fs.delete(TEST_FILE_PATH, false);
|
|
|
+ }
|
|
|
+
|
|
|
+}
|