Automatic merge of jdk:master into master

Author: duke

test/jdk/java/net/DatagramSocket/SendReceiveMaxSize.java

@@ -23,7 +23,8 @@
 
 /*
  * @test
- * @bug 8242885 8250886
+ * @bug 8242885 8250886 8240901
+ * @key randomness
  * @summary This test verifies that on macOS, the send buffer size is configured
  *          by default so that none of our implementations of the UDP protocol
  *          will fail with a "packet too large" exception when trying to send a
@@ -32,7 +33,6 @@
  *          limit.
  * @library /test/lib
  * @build jdk.test.lib.net.IPSupport
- * @requires os.family == "mac"
  * @run testng/othervm SendReceiveMaxSize
  * @run testng/othervm -Djava.net.preferIPv4Stack=true SendReceiveMaxSize
  * @run testng/othervm -Djava.net.preferIPv6Addresses=true SendReceiveMaxSize
@@ -41,6 +41,8 @@
  * @run testng/othervm -Djdk.net.usePlainDatagramSocketImpl -Djava.net.preferIPv6Addresses=true SendReceiveMaxSize
  */
 
+import jdk.test.lib.RandomFactory;
+import jdk.test.lib.Platform;
 import jdk.test.lib.net.IPSupport;
 import org.testng.annotations.BeforeTest;
 import org.testng.annotations.DataProvider;
@@ -54,7 +56,9 @@
 import java.net.InetSocketAddress;
 import java.net.MulticastSocket;
 import java.nio.channels.DatagramChannel;
+import java.util.Random;
 
+import static org.testng.Assert.assertEquals;
 import static org.testng.Assert.expectThrows;
 
 public class SendReceiveMaxSize {
@@ -63,6 +67,7 @@ public class SendReceiveMaxSize {
     private final static int IPV4_SNDBUF = 65507;
     private final static int IPV6_SNDBUF = 65527;
     private final static Class<IOException> IOE = IOException.class;
+    private final static Random random = RandomFactory.getRandom();
 
     public interface DatagramSocketSupplier {
         DatagramSocket open() throws IOException;
@@ -102,14 +107,25 @@ public void testSendReceiveMaxSize(String name, int capacity,
             var port = receiver.getLocalPort();
             var addr = new InetSocketAddress(HOST_ADDR, port);
             try (var sender = supplier.open()) {
-                var sendPkt = new DatagramPacket(new byte[capacity], capacity, addr);
+                if (!Platform.isOSX()) {
+                    if (sender.getSendBufferSize() < capacity)
+                        sender.setSendBufferSize(capacity);
+                }
+                byte[] testData = new byte[capacity];
+                random.nextBytes(testData);
+                var sendPkt = new DatagramPacket(testData, capacity, addr);
+
                 if (exception != null) {
                     Exception ex = expectThrows(IOE, () -> sender.send(sendPkt));
                     System.out.println(name + " got expected exception: " + ex);
                 } else {
                     sender.send(sendPkt);
                     var receivePkt = new DatagramPacket(new byte[capacity], capacity);
                     receiver.receive(receivePkt);
+
+                    // check packet data has been fragmented and re-assembled correctly at receiver
+                    assertEquals(receivePkt.getLength(), capacity);
+                    assertEquals(receivePkt.getData(), testData);
                 }
             }
         }

test/jdk/java/nio/channels/DatagramChannel/SendReceiveMaxSize.java

@@ -23,19 +23,21 @@
 
 /*
  * @test
- * @bug 8239355 8242885
+ * @bug 8239355 8242885 8240901
+ * @key randomness
  * @summary Check that it is possible to send and receive datagrams of
  *          maximum size on macOS.
  * @library /test/lib
  * @build jdk.test.lib.net.IPSupport
- * @requires os.family == "mac"
  * @run testng/othervm SendReceiveMaxSize
  * @run testng/othervm -Djava.net.preferIPv4Stack=true SendReceiveMaxSize
  * @run testng/othervm -Djdk.net.usePlainDatagramSocketImpl SendReceiveMaxSize
  * @run testng/othervm -Djdk.net.usePlainDatagramSocketImpl -Djava.net.preferIPv4Stack=true SendReceiveMaxSize
  */
 
+import jdk.test.lib.RandomFactory;
 import jdk.test.lib.NetworkConfiguration;
+import jdk.test.lib.Platform;
 import jdk.test.lib.net.IPSupport;
 import org.testng.annotations.BeforeTest;
 import org.testng.annotations.DataProvider;
@@ -49,6 +51,7 @@
 import java.nio.ByteBuffer;
 import java.nio.channels.DatagramChannel;
 import java.util.ArrayList;
+import java.util.Random;
 import java.util.function.Predicate;
 
 import static java.net.StandardProtocolFamily.INET;
@@ -65,6 +68,7 @@ public class SendReceiveMaxSize {
     private final static int IPV4_SNDBUF = 65507;
     private final static int IPV6_SNDBUF = 65527;
     private final static Class<IOException> IOE = IOException.class;
+    private final static Random random = RandomFactory.getRandom();
 
     public interface DatagramChannelSupplier {
         DatagramChannel open() throws IOException;
@@ -118,8 +122,10 @@ public Object[][] invariants() throws IOException {
     @Test(dataProvider = "invariants")
     public void testGetOption(DatagramChannelSupplier supplier, int capacity, InetAddress host)
             throws IOException {
-        try (var dc = supplier.open()) {
-            assertTrue(dc.getOption(SO_SNDBUF) >= capacity);
+        if (Platform.isOSX()) {
+            try (var dc = supplier.open()){
+                assertTrue(dc.getOption(SO_SNDBUF) >= capacity);
+            }
         }
     }
 
@@ -133,17 +139,43 @@ public void testSendReceiveMaxSize(DatagramChannelSupplier supplier, int capacit
 
             try (var sender = supplier.open()) {
                 sender.bind(null);
-                var sendBuf = ByteBuffer.allocate(capacity);
+                if (!Platform.isOSX()) {
+                    if (sender.getOption(SO_SNDBUF) < capacity)
+                        sender.setOption(SO_SNDBUF, capacity);
+                }
+                byte[] testData = new byte[capacity];
+                random.nextBytes(testData);
+
+                var sendBuf = ByteBuffer.wrap(testData);
                 sender.send(sendBuf, addr);
                 var receiveBuf = ByteBuffer.allocate(capacity);
                 receiver.receive(receiveBuf);
+
+                sendBuf.flip();
+                receiveBuf.flip();
+
+                // check that data has been fragmented and re-assembled correctly at receiver
+                System.out.println("sendBuf:    " + sendBuf);
+                System.out.println("receiveBuf: " + receiveBuf);
                 assertEquals(sendBuf, receiveBuf);
+                assertEquals(sendBuf.compareTo(receiveBuf), 0);
 
-                sendBuf = ByteBuffer.allocate(capacity - 1);
+                testData = new byte[capacity - 1];
+                random.nextBytes(testData);
+
+                sendBuf = ByteBuffer.wrap(testData);
                 sender.send(sendBuf, addr);
                 receiveBuf = ByteBuffer.allocate(capacity - 1);
                 receiver.receive(receiveBuf);
-                assertTrue(sendBuf.compareTo(receiveBuf) == 0);
+
+                sendBuf.flip();
+                receiveBuf.flip();
+
+                // check that data has been fragmented and re-assembled correctly at receiver
+                System.out.println("sendBuf:    " + sendBuf);
+                System.out.println("receiveBuf: " + receiveBuf);
+                assertEquals(sendBuf, receiveBuf);
+                assertEquals(sendBuf.compareTo(receiveBuf), 0);
 
                 var failSendBuf = ByteBuffer.allocate(capacity + 1);
                 assertThrows(IOE, () ->  sender.send(failSendBuf, addr));