Examples with DatagramPacket java.net.DatagramPacket used on opensource projects

Example 56 with DatagramPacket

use of java.net.DatagramPacket in project robovm by robovm.

the class OldDatagramSocketTest method test_sendLjava_net_DatagramPacket.

public void test_sendLjava_net_DatagramPacket() throws Exception {
    // Test for method void
    // java.net.DatagramSocket.send(java.net.DatagramPacket)
    int[] ports = Support_PortManager.getNextPortsForUDP(2);
    final int portNumber = ports[0];
    class TestDGSend implements Runnable {

        Thread pThread;

        public TestDGSend(Thread t) {
            pThread = t;
        }

        public void run() {
            try {
                byte[] rbuf = new byte[1000];
                sds = new DatagramSocket(portNumber);
                DatagramPacket sdp = new DatagramPacket(rbuf, rbuf.length);
                sds.setSoTimeout(6000);
                sds.receive(sdp);
                retval = new String(rbuf, 0, testString.length());
                pThread.interrupt();
            } catch (java.io.InterruptedIOException e) {
                System.out.println("Recv operation timed out");
                pThread.interrupt();
                ds.close();
            } catch (Exception e) {
                System.out.println("Failed to establish Dgram server: " + e);
            }
        }
    }
    try {
        new Thread(new TestDGSend(Thread.currentThread()), "DGServer").start();
        ds = new java.net.DatagramSocket(ports[1]);
        dp = new DatagramPacket(testString.getBytes(), testString.length(), InetAddress.getLocalHost(), portNumber);
        // Wait to allow send to occur
        try {
            Thread.sleep(500);
            ds.send(dp);
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            ds.close();
            assertTrue("Incorrect data sent: " + retval, retval.equals(testString));
        }
    } catch (Exception e) {
        fail("Exception during send test : " + e.getMessage());
    } finally {
        ds.close();
    }
    /*
        SecurityManager sm = new SecurityManager() {

            public void checkPermission(Permission perm) {
            }

            public void checkMulticast(InetAddress maddr) {
                throw new SecurityException();
            }

            public void checkConnect(String host,
                    int port) {
                throw new SecurityException();
            }
        };
        try {

            ds = new java.net.DatagramSocket(ports[1]);
            dp = new DatagramPacket(testString.getBytes(), testString.length(),
                    InetAddress.getLocalHost(), portNumber);

            SecurityManager oldSm = System.getSecurityManager();
            System.setSecurityManager(sm);
            try {
                ds.send(dp);
                fail("SecurityException should be thrown.");
            } catch (SecurityException e) {
                // expected
            } catch (SocketException e) {
                fail("SocketException was thrown.");
            } finally {
                System.setSecurityManager(oldSm);
            }
        } catch(Exception e) {
            fail("Unexpected exception was thrown: " + e.getMessage());
        }
        */
    DatagramSocket socket = null;
    try {
        byte[] rbuf = new byte[1000];
        DatagramPacket rdp = new DatagramPacket(rbuf, rbuf.length);
        SocketAddress address = new InetSocketAddress(portNumber);
        DatagramChannel channel = DatagramChannel.open();
        channel.configureBlocking(false);
        socket = channel.socket();
        socket.send(rdp);
        fail("IllegalBlockingModeException was not thrown.");
    } catch (IllegalBlockingModeException ibme) {
    //expected
    } catch (IOException ioe) {
        fail("IOException was thrown: " + ioe.getMessage());
    } finally {
        socket.close();
    }
    //Regression for HARMONY-1118
    class testDatagramSocket extends DatagramSocket {

        public testDatagramSocket(DatagramSocketImpl impl) {
            super(impl);
        }
    }
    class testDatagramSocketImpl extends DatagramSocketImpl {

        protected void create() throws SocketException {
        }

        protected void bind(int arg0, InetAddress arg1) throws SocketException {
        }

        protected void send(DatagramPacket arg0) throws IOException {
        }

        protected int peek(InetAddress arg0) throws IOException {
            return 0;
        }

        protected int peekData(DatagramPacket arg0) throws IOException {
            return 0;
        }

        protected void receive(DatagramPacket arg0) throws IOException {
        }

        protected void setTTL(byte arg0) throws IOException {
        }

        protected byte getTTL() throws IOException {
            return 0;
        }

        protected void setTimeToLive(int arg0) throws IOException {
        }

        protected int getTimeToLive() throws IOException {
            return 0;
        }

        protected void join(InetAddress arg0) throws IOException {
        }

        protected void leave(InetAddress arg0) throws IOException {
        }

        protected void joinGroup(SocketAddress arg0, NetworkInterface arg1) throws IOException {
        }

        protected void leaveGroup(SocketAddress arg0, NetworkInterface arg1) throws IOException {
        }

        protected void close() {
        }

        public void setOption(int arg0, Object arg1) throws SocketException {
        }

        public Object getOption(int arg0) throws SocketException {
            return null;
        }
    }
    InetSocketAddress sa = new InetSocketAddress(InetAddress.getLocalHost(), 0);
    //no exception expected for next line
    new testDatagramSocket(new testDatagramSocketImpl()).send(new DatagramPacket(new byte[272], 3, sa));
    // Regression test for Harmony-2938
    InetAddress i = InetAddress.getByName("127.0.0.1");
    DatagramSocket d = new DatagramSocket(0, i);
    try {
        d.send(new DatagramPacket(new byte[] { 1 }, 1));
        fail("should throw NPE.");
    } catch (NullPointerException e) {
    // expected;
    } finally {
        d.close();
    }
}

Example 57 with DatagramPacket

use of java.net.DatagramPacket in project robovm by robovm.

the class OldDatagramSocketTest method test_connectLjava_net_InetAddressI.

public void test_connectLjava_net_InetAddressI() throws UnknownHostException, SocketException {
    try {
        ds = new java.net.DatagramSocket();
        InetAddress inetAddress = InetAddress.getLocalHost();
        int portNumber = Support_PortManager.getNextPortForUDP();
        ds.connect(inetAddress, portNumber);
        assertTrue("Incorrect InetAddress", ds.getInetAddress().equals(inetAddress));
        assertTrue("Incorrect Port", ds.getPort() == portNumber);
        ds.disconnect();
    } catch (Exception e) {
        fail("Exception during test : " + e.getMessage());
    }
    System.out.println("Running test_connectLjava_net_InetAddressI" + "(DatagramSocketTest) with IPv6GlobalAddressJcl4: " + Support_Configuration.IPv6GlobalAddressJcl4);
    try {
        ds = new java.net.DatagramSocket();
        InetAddress inetAddress = InetAddress.getByName(Support_Configuration.IPv6GlobalAddressJcl4);
        int portNumber = Support_PortManager.getNextPortForUDP();
        ds.connect(inetAddress, portNumber);
        assertTrue("Incorrect InetAddress", ds.getInetAddress().equals(inetAddress));
        assertTrue("Incorrect Port", ds.getPort() == portNumber);
        ds.disconnect();
    } catch (Exception e) {
        fail("Exception during test : " + e.getMessage());
    }
    try {
        // Create a connected datagram socket to test
        // PlainDatagramSocketImpl.peek()
        InetAddress localHost = InetAddress.getLocalHost();
        DatagramSocket ds = new DatagramSocket();
        int port = ds.getLocalPort();
        ds.connect(localHost, port);
        DatagramPacket send = new DatagramPacket(new byte[10], 10, localHost, port);
        ds.send(send);
        DatagramPacket receive = new DatagramPacket(new byte[20], 20);
        ds.setSoTimeout(2000);
        ds.receive(receive);
        ds.close();
        assertTrue("Wrong size: " + receive.getLength(), receive.getLength() == 10);
        assertTrue("Wrong receiver", receive.getAddress().equals(localHost));
    } catch (IOException e) {
        fail("Unexpected IOException : " + e.getMessage());
    }
    class DatagramServer extends Thread {

        public DatagramSocket ms;

        boolean running = true;

        public byte[] rbuf = new byte[512];

        DatagramPacket rdp = null;

        public void run() {
            try {
                while (running) {
                    try {
                        ms.receive(rdp);
                        // echo the packet back
                        ms.send(rdp);
                    } catch (java.io.InterruptedIOException e) {
                        Thread.yield();
                    }
                }
            } catch (java.io.IOException e) {
                System.out.println("Multicast server failed: " + e);
            } finally {
                ms.close();
            }
        }

        public void stopServer() {
            running = false;
        }

        public DatagramServer(int aPort, InetAddress address) throws java.io.IOException {
            rbuf = new byte[512];
            rbuf[0] = -1;
            rdp = new DatagramPacket(rbuf, rbuf.length);
            ms = new DatagramSocket(aPort, address);
            ms.setSoTimeout(2000);
        }
    }
    // send a dgram to a server that is not running and then do a recv
    try {
        ds = new java.net.DatagramSocket();
        InetAddress inetAddress = InetAddress.getLocalHost();
        int portNumber = Support_PortManager.getNextPortForUDP();
        ds.connect(inetAddress, portNumber);
        DatagramPacket send = new DatagramPacket(new byte[10], 10);
        ds.send(send);
        DatagramPacket receive = new DatagramPacket(new byte[20], 20);
        ds.setSoTimeout(10000);
        ds.receive(receive);
        ds.close();
        fail("No PortUnreachableException when connected at native level on recv ");
    } catch (Exception e) {
        assertTrue("Wrong exception when trying to connect at native level on recv: " + e.toString(), (e instanceof PortUnreachableException));
    }
    // validate that we can send/receive with datagram sockets connected at
    // the native level
    DatagramServer server = null;
    int[] ports = Support_PortManager.getNextPortsForUDP(3);
    int serverPortNumber = ports[0];
    try {
        InetAddress localHost = InetAddress.getLocalHost();
        DatagramSocket ds = new DatagramSocket(ports[1]);
        DatagramSocket ds2 = new DatagramSocket(ports[2]);
        try {
            server = new DatagramServer(serverPortNumber, localHost);
            server.start();
            Thread.sleep(1000);
        } catch (Exception e) {
            fail("Failed to set up datagram server for native connected Dgram socket test ");
        }
        int port = ds.getLocalPort();
        ds.connect(localHost, serverPortNumber);
        byte[] sendBytes = { 'T', 'e', 's', 't', 0 };
        DatagramPacket send = new DatagramPacket(sendBytes, sendBytes.length);
        ds.send(send);
        DatagramPacket receive = new DatagramPacket(new byte[20], 20);
        ds.setSoTimeout(2000);
        ds.receive(receive);
        ds.close();
        assertTrue("Wrong size data received: " + receive.getLength(), receive.getLength() == sendBytes.length);
        assertTrue("Wrong data received" + new String(receive.getData(), 0, receive.getLength()) + ":" + new String(sendBytes), new String(receive.getData(), 0, receive.getLength()).equals(new String(sendBytes)));
        assertTrue("Wrong receiver:" + receive.getAddress() + ":" + localHost, receive.getAddress().equals(localHost));
    } catch (Exception e) {
        fail("Unexpected exception when sending data on dgram connected at native level:" + e.toString());
    }
    if (server != null) {
        server.stopServer();
    }
    // validate that we can disconnect
    try {
        ds = new java.net.DatagramSocket();
        InetAddress inetAddress = InetAddress.getLocalHost();
        int portNumber = Support_PortManager.getNextPortForUDP();
        ds.connect(inetAddress, portNumber);
        ds.disconnect();
        ds.close();
    } catch (Exception e) {
        assertTrue("Unexpected exception when trying to connect at native" + e.toString(), (e instanceof PortUnreachableException));
    }
    // validate that once connected we cannot send to another address
    try {
        ds = new java.net.DatagramSocket();
        InetAddress inetAddress = InetAddress.getLocalHost();
        int portNumber = Support_PortManager.getNextPortForUDP();
        ds.connect(inetAddress, portNumber);
        DatagramPacket send = new DatagramPacket(new byte[10], 10, inetAddress, portNumber + 1);
        ds.send(send);
        ds.close();
        fail("No Exception when trying to send to a different address on a connected socket ");
    } catch (Exception e) {
        assertTrue("Wrong exception when trying to send to a different address on a connected socket: " + e.toString(), (e instanceof IllegalArgumentException));
    }
    // validate that we can connect, then disconnect, then connect then
    // send/recv
    server = null;
    ports = Support_PortManager.getNextPortsForUDP(3);
    serverPortNumber = ports[0];
    try {
        InetAddress localHost = InetAddress.getLocalHost();
        DatagramSocket ds = new DatagramSocket(ports[1]);
        DatagramSocket ds2 = new DatagramSocket(ports[2]);
        try {
            server = new DatagramServer(serverPortNumber, localHost);
            server.start();
            Thread.sleep(1000);
        } catch (Exception e) {
            fail("Failed to set up datagram server for native connected Dgram socket test ");
        }
        int port = ds.getLocalPort();
        ds.connect(localHost, serverPortNumber + 1);
        ds.disconnect();
        ds.connect(localHost, serverPortNumber);
        byte[] sendBytes = { 'T', 'e', 's', 't', 0 };
        DatagramPacket send = new DatagramPacket(sendBytes, sendBytes.length);
        ds.send(send);
        DatagramPacket receive = new DatagramPacket(new byte[20], 20);
        ds.setSoTimeout(2000);
        ds.receive(receive);
        ds.close();
        assertTrue("connect/disconnect/connect - Wrong size data received: " + receive.getLength(), receive.getLength() == sendBytes.length);
        assertTrue("connect/disconnect/connect - Wrong data received" + new String(receive.getData(), 0, receive.getLength()) + ":" + new String(sendBytes), new String(receive.getData(), 0, receive.getLength()).equals(new String(sendBytes)));
        assertTrue("connect/disconnect/connect - Wrong receiver:" + receive.getAddress() + ":" + localHost, receive.getAddress().equals(localHost));
    } catch (Exception e) {
        fail("Unexpected exception when sending data on dgram connected at native level after connect/disconnect/connect:" + e.toString());
    }
    if (server != null) {
        server.stopServer();
    }
    // validate that we can connect/disconnect then send/recv to any address
    server = null;
    ports = Support_PortManager.getNextPortsForUDP(3);
    serverPortNumber = ports[0];
    try {
        InetAddress localHost = InetAddress.getLocalHost();
        DatagramSocket ds = new DatagramSocket(ports[1]);
        DatagramSocket ds2 = new DatagramSocket(ports[2]);
        try {
            server = new DatagramServer(serverPortNumber, localHost);
            server.start();
            Thread.sleep(1000);
        } catch (Exception e) {
            fail("Failed to set up datagram server for native connected Dgram socket test ");
        }
        int port = ds.getLocalPort();
        ds.connect(localHost, serverPortNumber + 1);
        ds.disconnect();
        byte[] sendBytes = { 'T', 'e', 's', 't', 0 };
        DatagramPacket send = new DatagramPacket(sendBytes, sendBytes.length, localHost, serverPortNumber);
        ds.send(send);
        DatagramPacket receive = new DatagramPacket(new byte[20], 20);
        ds.setSoTimeout(2000);
        ds.receive(receive);
        ds.close();
        assertTrue("connect/disconnect - Wrong size data received: " + receive.getLength(), receive.getLength() == sendBytes.length);
        assertTrue("connect/disconnect - Wrong data received" + new String(receive.getData(), 0, receive.getLength()) + ":" + new String(sendBytes), new String(receive.getData(), 0, receive.getLength()).equals(new String(sendBytes)));
        assertTrue("connect/disconnect - Wrong receiver:" + receive.getAddress() + ":" + localHost, receive.getAddress().equals(localHost));
    } catch (Exception e) {
        fail("Unexpected exception when sending data on dgram connected at native level after connect/disconnect:" + e.toString());
    }
    if (server != null) {
        server.stopServer();
    }
    // validate that we can connect on an allready connected socket and then
    // send/recv
    server = null;
    ports = Support_PortManager.getNextPortsForUDP(3);
    serverPortNumber = ports[0];
    try {
        InetAddress localHost = InetAddress.getLocalHost();
        DatagramSocket ds = new DatagramSocket(ports[1]);
        DatagramSocket ds2 = new DatagramSocket(ports[2]);
        try {
            server = new DatagramServer(serverPortNumber, localHost);
            server.start();
            Thread.sleep(1000);
        } catch (Exception e) {
            fail("Failed to set up datagram server for native connected Dgram socket test ");
        }
        int port = ds.getLocalPort();
        ds.connect(localHost, serverPortNumber + 1);
        ds.connect(localHost, serverPortNumber);
        byte[] sendBytes = { 'T', 'e', 's', 't', 0 };
        DatagramPacket send = new DatagramPacket(sendBytes, sendBytes.length);
        ds.send(send);
        DatagramPacket receive = new DatagramPacket(new byte[20], 20);
        ds.setSoTimeout(2000);
        ds.receive(receive);
        ds.close();
        assertTrue("connect/connect - Wrong size data received: " + receive.getLength(), receive.getLength() == sendBytes.length);
        assertTrue("connect/connect - Wrong data received" + new String(receive.getData(), 0, receive.getLength()) + ":" + new String(sendBytes), new String(receive.getData(), 0, receive.getLength()).equals(new String(sendBytes)));
        assertTrue("connect/connect - Wrong receiver:" + receive.getAddress() + ":" + localHost, receive.getAddress().equals(localHost));
    } catch (Exception e) {
        fail("Unexpected exception when sending data on dgram connected at native level after connect/connect: " + e.toString());
    }
    if (server != null) {
        server.stopServer();
    }
    // there should be no exception
    try {
        ds = new java.net.DatagramSocket();
        byte[] addressBytes = { 0, 0, 0, 0 };
        InetAddress inetAddress = InetAddress.getByAddress(addressBytes);
        int portNumber = Support_PortManager.getNextPortForUDP();
        ds.connect(inetAddress, portNumber);
    } catch (Exception e) {
        fail("Unexcpected exception when trying to connect at native level with bad address for signature with no exception to be returned: " + e.toString());
    }
    System.out.println("Running test_connectLjava_net_InetAddressI(DatagramSocketTest) with IPv6 address");
    try {
        ds = new java.net.DatagramSocket();
        byte[] addressBytes = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
        InetAddress inetAddress = InetAddress.getByAddress(addressBytes);
        int portNumber = Support_PortManager.getNextPortForUDP();
        ds.connect(inetAddress, portNumber);
    } catch (Exception e) {
        fail("Unexcpected exception when trying to connect at native level with bad IPv6 address for signature with no exception to be returned: " + e.toString());
    }
}

Example 58 with DatagramPacket

use of java.net.DatagramPacket in project robovm by robovm.

the class OldDatagramSocketTest method test_bindLjava_net_SocketAddress.

public void test_bindLjava_net_SocketAddress() throws Exception {
    int[] ports = Support_PortManager.getNextPortsForUDP(3);
    int serverPortNumber = ports[1];
    // now create a socket that is not bound and then bind it
    InetAddress localHost = InetAddress.getLocalHost();
    InetSocketAddress localAddress1 = new InetSocketAddress(localHost, ports[0]);
    DatagramSocket theSocket = new DatagramSocket(localAddress1);
    // validate that the localSocketAddress reflects the address we bound to
    assertEquals(localAddress1, theSocket.getLocalSocketAddress());
    // now make sure that datagrams sent from this socket appear to come
    // from the address we bound to
    InetSocketAddress localAddress2 = new InetSocketAddress(localHost, ports[2]);
    DatagramSocket ds = new DatagramSocket((SocketAddress) null);
    ds.bind(localAddress2);
    DatagramServer server = new DatagramServer(serverPortNumber, localHost);
    server.start();
    Thread.sleep(1000);
    ds.connect(new InetSocketAddress(localHost, serverPortNumber));
    byte[] sendBytes = { 'T', 'e', 's', 't', 0 };
    DatagramPacket send = new DatagramPacket(sendBytes, sendBytes.length);
    ds.send(send);
    Thread.sleep(1000);
    ds.close();
    // Check that the address in the packet matches the bound address.
    assertEquals(localAddress2, server.rdp.getSocketAddress());
    if (server != null) {
        server.stopServer();
    }
}

Example 59 with DatagramPacket

use of java.net.DatagramPacket in project robovm by robovm.

the class OldDatagramSocketTest method test_close.

public void test_close() {
    // Test for method void java.net.DatagramSocket.close()
    try {
        int portNumber = Support_PortManager.getNextPortForUDP();
        ds = new java.net.DatagramSocket(portNumber);
        dp = new DatagramPacket("Test String".getBytes(), 11, InetAddress.getLocalHost(), 0);
        ds.close();
        try {
            ds.send(dp);
            fail("IOException was not thrown.");
        } catch (IOException ioe) {
        //expected
        }
    } catch (Exception e) {
        fail("Unexpected exception: " + e.getMessage());
    }
}

Example 60 with DatagramPacket

use of java.net.DatagramPacket in project robovm by robovm.

the class OldDatagramSocketTest method test_receiveLjava_net_DatagramPacket.

public void test_receiveLjava_net_DatagramPacket() throws Exception {
    // Test for method void
    // java.net.DatagramSocket.receive(java.net.DatagramPacket)
    receive_oversize_java_net_DatagramPacket();
    final int[] ports = Support_PortManager.getNextPortsForUDP(2);
    final int portNumber = ports[0];
    class TestDGRcv implements Runnable {

        public void run() {
            try {
                InetAddress localHost = InetAddress.getLocalHost();
                Thread.sleep(1000);
                DatagramSocket sds = new DatagramSocket(ports[1]);
                sds.send(new DatagramPacket("Test".getBytes("UTF-8"), "Test".length(), localHost, portNumber));
                sds.send(new DatagramPacket("Longer test".getBytes("UTF-8"), "Longer test".length(), localHost, portNumber));
                sds.send(new DatagramPacket("3 Test".getBytes("UTF-8"), "3 Test".length(), localHost, portNumber));
                sds.send(new DatagramPacket("4 Test".getBytes("UTF-8"), "4 Test".length(), localHost, portNumber));
                sds.send(new DatagramPacket("5".getBytes("UTF-8"), "5".length(), localHost, portNumber));
                sds.close();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }
    try {
        new Thread(new TestDGRcv(), "datagram receiver").start();
        ds = new java.net.DatagramSocket(portNumber);
        ds.setSoTimeout(6000);
        byte[] rbuf = new byte[1000];
        DatagramPacket rdp = new DatagramPacket(rbuf, rbuf.length);
        // Receive the first packet.
        ds.receive(rdp);
        assertEquals("Test", new String(rbuf, 0, rdp.getLength()));
        // Check that we can still receive a longer packet (http://code.google.com/p/android/issues/detail?id=24748).
        ds.receive(rdp);
        assertEquals("Longer test", new String(rbuf, 0, rdp.getLength()));
        // See what happens if we manually call DatagramPacket.setLength.
        rdp.setLength(4);
        ds.receive(rdp);
        assertEquals("3 Te", new String(rbuf, 0, rdp.getLength()));
        // And then another.
        ds.receive(rdp);
        assertEquals("4 Te", new String(rbuf, 0, rdp.getLength()));
        // And then a packet shorter than the user-supplied length.
        ds.receive(rdp);
        assertEquals("5", new String(rbuf, 0, rdp.getLength()));
        ds.close();
    } finally {
        ds.close();
    }
    DatagramSocket socket = null;
    try {
        byte[] rbuf = new byte[1000];
        DatagramPacket rdp = new DatagramPacket(rbuf, rbuf.length);
        DatagramChannel channel = DatagramChannel.open();
        channel.configureBlocking(false);
        socket = channel.socket();
        socket.receive(rdp);
        fail("IllegalBlockingModeException was not thrown.");
    } catch (IllegalBlockingModeException expected) {
    } finally {
        socket.close();
    }
    try {
        ds = new java.net.DatagramSocket(portNumber);
        ds.setSoTimeout(1000);
        byte[] rbuf = new byte[1000];
        DatagramPacket rdp = new DatagramPacket(rbuf, rbuf.length);
        ds.receive(rdp);
        fail("SocketTimeoutException was not thrown.");
    } catch (SocketTimeoutException expected) {
    } finally {
        ds.close();
    }
    interrupted = false;
    final DatagramSocket ds = new DatagramSocket();
    ds.setSoTimeout(12000);
    Runnable runnable = new Runnable() {

        public void run() {
            try {
                ds.receive(new DatagramPacket(new byte[1], 1));
            } catch (InterruptedIOException e) {
                interrupted = true;
            } catch (IOException ignored) {
            }
        }
    };
    Thread thread = new Thread(runnable, "DatagramSocket.receive1");
    thread.start();
    do {
        Thread.sleep(500);
    } while (!thread.isAlive());
    ds.close();
    int c = 0;
    do {
        Thread.sleep(500);
        if (interrupted) {
            fail("received interrupt");
        }
        if (++c > 4) {
            fail("read call did not exit");
        }
    } while (thread.isAlive());
    interrupted = false;
    final int portNum = ports[0];
    final DatagramSocket ds2 = new DatagramSocket(ports[1]);
    ds2.setSoTimeout(12000);
    Runnable runnable2 = new Runnable() {

        public void run() {
            try {
                ds2.receive(new DatagramPacket(new byte[1], 1, InetAddress.getLocalHost(), portNum));
            } catch (InterruptedIOException e) {
                interrupted = true;
            } catch (IOException ignored) {
            }
        }
    };
    Thread thread2 = new Thread(runnable2, "DatagramSocket.receive2");
    thread2.start();
    try {
        do {
            Thread.sleep(500);
        } while (!thread2.isAlive());
    } catch (InterruptedException ignored) {
    }
    ds2.close();
    int c2 = 0;
    do {
        Thread.sleep(500);
        if (interrupted) {
            fail("receive2 was interrupted");
        }
        if (++c2 > 4) {
            fail("read2 call did not exit");
        }
    } while (thread2.isAlive());
    interrupted = false;
    DatagramSocket ds3 = new DatagramSocket();
    ds3.setSoTimeout(500);
    Date start = new Date();
    try {
        ds3.receive(new DatagramPacket(new byte[1], 1));
    } catch (InterruptedIOException e) {
        interrupted = true;
    }
    ds3.close();
    assertTrue("receive not interrupted", interrupted);
    int delay = (int) (new Date().getTime() - start.getTime());
    assertTrue("timeout too soon: " + delay, delay >= 490);
}