Skip to content
Permalink
Browse files
8278166: java/nio/channels/Channels/TransferTo.java timed out 
Reviewed-by: lancea, alanb
  • Loading branch information
Brian Burkhalter committed Dec 7, 2021
1 parent 543d1a8 commit 7ea4b19f544cabb70590793ef59d5a8be05deeb1
Showing 1 changed file with 95 additions and 53 deletions.
148 test/jdk/java/nio/channels/Channels/TransferTo.java
View file
@@ -23,9 +23,10 @@

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.Channels;
import java.nio.channels.FileChannel;
import java.nio.channels.IllegalBlockingModeException;
@@ -51,6 +52,7 @@
import jdk.test.lib.RandomFactory;

import static java.lang.String.format;
import static java.nio.file.StandardOpenOption.*;

import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertThrows;
@@ -62,8 +64,8 @@
* @build jdk.test.lib.RandomFactory
* @run testng/othervm/timeout=180 TransferTo
* @bug 8265891
* @summary tests whether sun.nio.ChannelInputStream.transferTo conforms to the
* InputStream.transferTo contract defined in the javadoc
* @summary Tests whether sun.nio.ChannelInputStream.transferTo conforms to the
* InputStream.transferTo specification
* @key randomness
*/
public class TransferTo {
@@ -72,27 +74,30 @@ public class TransferTo {

private static final int ITERATIONS = 10;

private static final int NUM_WRITES = 3 * 1024;
private static final int BYTES_PER_WRITE = 1024 * 1024;
private static final long BYTES_WRITTEN = (long) NUM_WRITES * BYTES_PER_WRITE;
private static final int NUM_WRITES = 3*1024;
private static final int BYTES_PER_WRITE = 1024*1024;
private static final long BYTES_WRITTEN = (long) NUM_WRITES*BYTES_PER_WRITE;

private static final Random RND = RandomFactory.getRandom();

private static final Path CWD = Path.of(".");

/*
* Provides test scenarios, i. e. combinations of input and output streams to be tested.
* Provides test scenarios, i.e., combinations of input and output streams
* to be tested.
*/
@DataProvider
public static Object[][] streamCombinations() throws Exception {
return new Object[][] {
// tests FileChannel.transferTo(FileChannel) optimized case
{ fileChannelInput(), fileChannelOutput() },

// tests FileChannel.transferTo(SelectableChannelOutput) optimized case
// tests FileChannel.transferTo(SelectableChannelOutput)
// optimized case
{ fileChannelInput(), selectableChannelOutput() },

// tests FileChannel.transferTo(WritableChannelOutput) optimized case
// tests FileChannel.transferTo(WritableChannelOutput)
// optimized case
{ fileChannelInput(), writableByteChannelOutput() },

// tests InputStream.transferTo(OutputStream) default case
@@ -101,7 +106,8 @@ public static Object[][] streamCombinations() throws Exception {
}

/*
* Testing API compliance: Input stream must throw NullPointerException when parameter "out" is null.
* Testing API compliance: input stream must throw NullPointerException
* when parameter "out" is null.
*/
@Test(dataProvider = "streamCombinations")
public void testNullPointerException(InputStreamProvider inputStreamProvider,
@@ -117,7 +123,8 @@ public void testNullPointerException(InputStreamProvider inputStreamProvider,
}

/*
* Testing API compliance: Complete content of input stream must be transferred to output stream.
* Testing API compliance: complete content of input stream must be
* transferred to output stream.
*/
@Test(dataProvider = "streamCombinations")
public void testStreamContents(InputStreamProvider inputStreamProvider,
@@ -128,10 +135,12 @@ public void testStreamContents(InputStreamProvider inputStreamProvider,
// tests input stream with a length between 1k and 4k
checkTransferredContents(inputStreamProvider, outputStreamProvider, createRandomBytes(1024, 4096));

// tests input stream with several data chunks, as 16k is more than a single chunk can hold
// tests input stream with several data chunks, as 16k is more than a
// single chunk can hold
checkTransferredContents(inputStreamProvider, outputStreamProvider, createRandomBytes(16384, 16384));

// tests randomly chosen starting positions within source and target stream
// tests randomly chosen starting positions within source and
// target stream
for (int i = 0; i < ITERATIONS; i++) {
byte[] inBytes = createRandomBytes(MIN_SIZE, MAX_SIZE_INCR);
int posIn = RND.nextInt(inBytes.length);
@@ -147,34 +156,60 @@ public void testStreamContents(InputStreamProvider inputStreamProvider,
}

/*
* Special test for file-to-file transfer of more than two GB.
* This test covers multiple iterations of FileChannel.transerTo(FileChannel),
* which ChannelInputStream.transferTo() only applies in this particular case,
* and cannot get tested using a single byte[] due to size limitation of arrays.
* Special test for file-to-file transfer of more than 2 GB. This test
* covers multiple iterations of FileChannel.transerTo(FileChannel),
* which ChannelInputStream.transferTo() only applies in this particular
* case, and cannot get tested using a single byte[] due to size limitation
* of arrays.
*/
@Test
public void testMoreThanTwoGB() throws IOException {
Path sourceFile = Files.createTempFile(CWD, "test2GBSource", null);
// prepare two temporary files to be compared at the end of the test
// set the source file name
String sourceName = String.format("test3GBSource%s.tmp",
String.valueOf(RND.nextInt(Integer.MAX_VALUE)));
Path sourceFile = CWD.resolve(sourceName);

try {
// preparing two temporary files which will be compared at the end of the test
Path targetFile = Files.createTempFile(CWD, "test2GBtarget", null);
// set the target file name
String targetName = String.format("test3GBTarget%s.tmp",
String.valueOf(RND.nextInt(Integer.MAX_VALUE)));
Path targetFile = CWD.resolve(targetName);

try {
// writing 3 GB of random bytes into source file
for (int i = 0; i < NUM_WRITES; i++)
Files.write(sourceFile, createRandomBytes(BYTES_PER_WRITE, 0), StandardOpenOption.APPEND);
// calculate initial position to be just short of 2GB
final long initPos = 2047*BYTES_PER_WRITE;

// create the source file with a hint to be sparse
try (FileChannel fc = FileChannel.open(sourceFile, CREATE_NEW, SPARSE, WRITE, APPEND);) {
// set initial position to avoid writing nearly 2GB
fc.position(initPos);

// fill the remainder of the file with random bytes
int nw = (int)(NUM_WRITES - initPos/BYTES_PER_WRITE);
for (int i = 0; i < nw; i++) {
byte[] rndBytes = createRandomBytes(BYTES_PER_WRITE, 0);
ByteBuffer src = ByteBuffer.wrap(rndBytes);
fc.write(src);
}
}

// performing actual transfer, effectively by multiple invocations of Filechannel.transferTo(FileChannel)
long count;
try (InputStream inputStream = Channels.newInputStream(FileChannel.open(sourceFile));
OutputStream outputStream = Channels
.newOutputStream(FileChannel.open(targetFile, StandardOpenOption.WRITE))) {
count = inputStream.transferTo(outputStream);
// create the target file with a hint to be sparse
try (FileChannel fc = FileChannel.open(targetFile, CREATE_NEW, WRITE, SPARSE);) {
}

// comparing reported transferred bytes, must be 3 GB
assertEquals(count, BYTES_WRITTEN);
// perform actual transfer, effectively by multiple invocations
// of Filechannel.transferTo(FileChannel)
try (InputStream inputStream = Channels.newInputStream(FileChannel.open(sourceFile));
OutputStream outputStream = Channels.newOutputStream(FileChannel.open(targetFile, WRITE))) {
long count = inputStream.transferTo(outputStream);

// compare reported transferred bytes, must be 3 GB
// less the value of the initial position
assertEquals(count, BYTES_WRITTEN - initPos);
}

// comparing content of both files, failing in case of any difference
// compare content of both files, failing if different
assertEquals(Files.mismatch(sourceFile, targetFile), -1);

} finally {
@@ -186,28 +221,33 @@ public void testMoreThanTwoGB() throws IOException {
}

/*
* Special test whether selectable channel based transfer throws blocking mode exception.
* Special test of whether selectable channel based transfer throws blocking
* mode exception.
*/
@Test
public void testIllegalBlockingMode() throws IOException {
Pipe pipe = Pipe.open();
try {
// testing arbitrary input (here: empty file) to non-blocking selectable output
// testing arbitrary input (here: empty file) to non-blocking
// selectable output
try (FileChannel fc = FileChannel.open(Files.createTempFile(CWD, "testIllegalBlockingMode", null));
InputStream is = Channels.newInputStream(fc);
SelectableChannel sc = pipe.sink().configureBlocking(false);
OutputStream os = Channels.newOutputStream((WritableByteChannel) sc)) {
InputStream is = Channels.newInputStream(fc);
SelectableChannel sc = pipe.sink().configureBlocking(false);
OutputStream os = Channels.newOutputStream((WritableByteChannel) sc)) {

// IllegalBlockingMode must be thrown when trying to perform a transfer
// IllegalBlockingMode must be thrown when trying to perform
// a transfer
assertThrows(IllegalBlockingModeException.class, () -> is.transferTo(os));
}

// testing non-blocking selectable input to arbitrary output (here: byte array)
// testing non-blocking selectable input to arbitrary output
// (here: byte array)
try (SelectableChannel sc = pipe.source().configureBlocking(false);
InputStream is = Channels.newInputStream((ReadableByteChannel) sc);
OutputStream os = new ByteArrayOutputStream()) {
InputStream is = Channels.newInputStream((ReadableByteChannel) sc);
OutputStream os = new ByteArrayOutputStream()) {

// IllegalBlockingMode must be thrown when trying to perform a transfer
// IllegalBlockingMode must be thrown when trying to perform
// a transfer
assertThrows(IllegalBlockingModeException.class, () -> is.transferTo(os));
}
} finally {
@@ -217,26 +257,26 @@ public void testIllegalBlockingMode() throws IOException {
}

/*
* Asserts that the transferred content is correct, i. e. compares the actually transferred bytes
* to the expected assumption. The position of the input and output stream before the transfer is
* the start of stream (BOF).
* Asserts that the transferred content is correct, i.e., compares the bytes
* actually transferred to those expected. The position of the input and
* output streams before the transfer are zero (BOF).
*/
private static void checkTransferredContents(InputStreamProvider inputStreamProvider,
OutputStreamProvider outputStreamProvider, byte[] inBytes) throws Exception {
checkTransferredContents(inputStreamProvider, outputStreamProvider, inBytes, 0, 0);
}

/*
* Asserts that the transferred content is correct, i. e. compares the actually transferred bytes
* to the expected assumption. The position of the input and output stream before the transfer is
* provided by the caller.
* Asserts that the transferred content is correct, i. e. compares the bytes
* actually transferred to those expected. The positions of the input and
* output streams before the transfer are provided by the caller.
*/
private static void checkTransferredContents(InputStreamProvider inputStreamProvider,
OutputStreamProvider outputStreamProvider, byte[] inBytes, int posIn, int posOut) throws Exception {
AtomicReference<Supplier<byte[]>> recorder = new AtomicReference<>();
try (InputStream in = inputStreamProvider.input(inBytes);
OutputStream out = outputStreamProvider.output(recorder::set)) {
// skip bytes till starting position
OutputStream out = outputStreamProvider.output(recorder::set)) {
// skip bytes until starting position
in.skipNBytes(posIn);
out.write(new byte[posOut]);

@@ -252,7 +292,8 @@ private static void checkTransferredContents(InputStreamProvider inputStreamProv
}

/*
* Creates an array of random size (between min and min + maxRandomAdditive) filled with random bytes
* Creates an array of random size (between min and min + maxRandomAdditive)
* filled with random bytes
*/
private static byte[] createRandomBytes(int min, int maxRandomAdditive) {
byte[] bytes = new byte[min + (maxRandomAdditive == 0 ? 0 : RND.nextInt(maxRandomAdditive))];
@@ -298,7 +339,8 @@ public InputStream input(byte... bytes) throws Exception {
}

/*
* Creates a provider for an input stream which wraps a readable byte channel but is not a file channel
* Creates a provider for an input stream which wraps a readable byte
* channel but is not a file channel
*/
private static InputStreamProvider readableByteChannelInput() {
return new InputStreamProvider() {
@@ -316,7 +358,7 @@ private static OutputStreamProvider fileChannelOutput() {
return new OutputStreamProvider() {
public OutputStream output(Consumer<Supplier<byte[]>> spy) throws Exception {
Path path = Files.createTempFile(CWD, "fileChannelOutput", null);
FileChannel fileChannel = FileChannel.open(path, StandardOpenOption.WRITE);
FileChannel fileChannel = FileChannel.open(path, WRITE);
spy.accept(() -> {
try {
return Files.readAllBytes(path);

1 comment on commit 7ea4b19

@openjdk-notifier
Copy link

@openjdk-notifier openjdk-notifier bot commented on 7ea4b19 Dec 7, 2021

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Review

Issues

Please sign in to comment.