8273507: Convert test/jdk/java/nio/channels/Channels/TransferTo.java to TestNG test

Reviewed-by: shade, bpb

Author: mkarg

test/jdk/java/nio/channels/Channels/TransferTo.java

@@ -21,8 +21,6 @@
  * questions.
  */
 
-import static java.lang.String.format;
-
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
@@ -39,13 +37,22 @@
 import java.util.function.Consumer;
 import java.util.function.Supplier;
 
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
 import jdk.test.lib.RandomFactory;
 
+import static java.lang.String.format;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertThrows;
+import static org.testng.Assert.assertTrue;
+
 /*
  * @test
  * @library /test/lib
  * @build jdk.test.lib.RandomFactory
- * @run main TransferTo
+ * @run testng TransferTo
  * @bug 8265891
  * @summary tests whether sun.nio.ChannelInputStream.transferTo conforms to the
  *          InputStream.transferTo contract defined in the javadoc
@@ -59,59 +66,81 @@ public class TransferTo {
 
     private static final Random RND = RandomFactory.getRandom();
 
-    public static void main(String[] args) throws Exception {
-        test(fileChannelInput(), fileChannelOutput());
-        test(readableByteChannelInput(), defaultOutput());
-    }
-
-    private static void test(InputStreamProvider inputStreamProvider, OutputStreamProvider outputStreamProvider)
-            throws Exception {
-        testNullPointerException(inputStreamProvider);
-        testStreamContents(inputStreamProvider, outputStreamProvider);
+    /*
+     * 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 InputStream.transferTo(OutputStream) default case
+            { readableByteChannelInput(), defaultOutput() }
+        };
     }
 
-    private static void testNullPointerException(InputStreamProvider inputStreamProvider) throws Exception {
-        try (InputStream in = inputStreamProvider.input()) {
-            assertThrowsNPE(() -> in.transferTo(null), "out");
-        }
+    /*
+     * Testing API compliance: Input stream must throw NullPointerException when parameter "out" is null.
+     */
+    @Test(dataProvider = "streamCombinations")
+    public void testNullPointerException(InputStreamProvider inputStreamProvider,
+            OutputStreamProvider outputStreamProvider) throws Exception {
+        // tests empty input stream
+        assertThrows(NullPointerException.class, () -> inputStreamProvider.input().transferTo(null));
 
-        try (InputStream in = inputStreamProvider.input((byte) 1)) {
-            assertThrowsNPE(() -> in.transferTo(null), "out");
-        }
+        // tests single-byte input stream
+        assertThrows(NullPointerException.class, () -> inputStreamProvider.input((byte) 1).transferTo(null));
 
-        try (InputStream in = inputStreamProvider.input((byte) 1, (byte) 2)) {
-            assertThrowsNPE(() -> in.transferTo(null), "out");
-        }
+        // tests dual-byte input stream
+        assertThrows(NullPointerException.class, () -> inputStreamProvider.input((byte) 1, (byte) 2).transferTo(null));
     }
 
-    private static void testStreamContents(InputStreamProvider inputStreamProvider,
+    /*
+     * Testing API compliance: Complete content of input stream must be transferred to output stream.
+     */
+    @Test(dataProvider = "streamCombinations")
+    public void testStreamContents(InputStreamProvider inputStreamProvider,
             OutputStreamProvider outputStreamProvider) throws Exception {
+        // tests empty input stream
         checkTransferredContents(inputStreamProvider, outputStreamProvider, new byte[0]);
+
+        // tests input stream with a length between 1k and 4k
         checkTransferredContents(inputStreamProvider, outputStreamProvider, createRandomBytes(1024, 4096));
 
-        // to span through several batches
+        // tests input stream with several data chunks, as 16k is more than a single chunk can hold
         checkTransferredContents(inputStreamProvider, outputStreamProvider, createRandomBytes(16384, 16384));
 
-        // randomly chosen starting positions within source and target
+        // 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);
             int posOut = RND.nextInt(MIN_SIZE);
             checkTransferredContents(inputStreamProvider, outputStreamProvider, inBytes, posIn, posOut);
         }
 
-        // beyond source EOF
+        // tests reading beyond source EOF (must not transfer any bytes)
         checkTransferredContents(inputStreamProvider, outputStreamProvider, createRandomBytes(4096, 0), 4096, 0);
 
-        // beyond target EOF
+        // tests writing beyond target EOF (must extend output stream)
         checkTransferredContents(inputStreamProvider, outputStreamProvider, createRandomBytes(4096, 0), 0, 4096);
     }
 
+    /*
+     * 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).
+     */
     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.
+     */
     private static void checkTransferredContents(InputStreamProvider inputStreamProvider,
             OutputStreamProvider outputStreamProvider, byte[] inBytes, int posIn, int posOut) throws Exception {
         AtomicReference<Supplier<byte[]>> recorder = new AtomicReference<>();
@@ -124,17 +153,17 @@ private static void checkTransferredContents(InputStreamProvider inputStreamProv
             long reported = in.transferTo(out);
             int count = inBytes.length - posIn;
 
-            if (reported != count)
-                throw new AssertionError(
-                        format("reported %d bytes but should report %d", reported, count));
+            assertEquals(reported, count, format("reported %d bytes but should report %d", reported, count));
 
             byte[] outBytes = recorder.get().get();
-            if (!Arrays.equals(inBytes, posIn, posIn + count, outBytes, posOut, posOut + count))
-                throw new AssertionError(
-                        format("inBytes.length=%d, outBytes.length=%d", count, outBytes.length));
+            assertTrue(Arrays.equals(inBytes, posIn, posIn + count, outBytes, posOut, posOut + count),
+                format("inBytes.length=%d, outBytes.length=%d", count, outBytes.length));
         }
     }
 
+    /*
+     * 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))];
         RND.nextBytes(bytes);
@@ -149,6 +178,9 @@ private interface OutputStreamProvider {
         OutputStream output(Consumer<Supplier<byte[]>> spy) throws Exception;
     }
 
+    /*
+     * Creates a provider for an output stream which does not wrap a channel
+     */
     private static OutputStreamProvider defaultOutput() {
         return new OutputStreamProvider() {
             @Override
@@ -160,6 +192,9 @@ public OutputStream output(Consumer<Supplier<byte[]>> spy) {
         };
     }
 
+    /*
+     * Creates a provider for an input stream which wraps a file channel
+     */
     private static InputStreamProvider fileChannelInput() {
         return new InputStreamProvider() {
             @Override
@@ -172,6 +207,9 @@ 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
+     */
     private static InputStreamProvider readableByteChannelInput() {
         return new InputStreamProvider() {
             @Override
@@ -181,6 +219,9 @@ public InputStream input(byte... bytes) throws Exception {
         };
     }
 
+    /*
+     * Creates a provider for an output stream which wraps a file channel
+     */
     private static OutputStreamProvider fileChannelOutput() {
         return new OutputStreamProvider() {
             public OutputStream output(Consumer<Supplier<byte[]>> spy) throws Exception {
@@ -198,31 +239,4 @@ public OutputStream output(Consumer<Supplier<byte[]>> spy) throws Exception {
         };
     }
 
-    public interface Thrower {
-        public void run() throws Throwable;
-    }
-
-    public static void assertThrowsNPE(Thrower thrower, String message) {
-        assertThrows(thrower, NullPointerException.class, message);
-    }
-
-    public static <T extends Throwable> void assertThrows(Thrower thrower, Class<T> throwable, String message) {
-        Throwable thrown;
-        try {
-            thrower.run();
-            thrown = null;
-        } catch (Throwable caught) {
-            thrown = caught;
-        }
-
-        if (!throwable.isInstance(thrown)) {
-            String caught = thrown == null ? "nothing" : thrown.getClass().getCanonicalName();
-            throw new AssertionError(format("Expected to catch %s, but caught %s", throwable, caught), thrown);
-        }
-
-        if (thrown != null && !message.equals(thrown.getMessage())) {
-            throw new AssertionError(
-                    format("Expected exception message to be '%s', but it's '%s'", message, thrown.getMessage()));
-        }
-    }
 }