/*
 *  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.harmony.luni.tests.java.net;

import java.io.IOException;
import java.net.BindException;
import java.net.DatagramPacket;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.MulticastSocket;
import java.net.NetworkInterface;
import java.net.SocketAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Enumeration;

import tests.support.Support_PortManager;

public class MulticastSocketTest extends junit.framework.TestCase {

    private boolean atLeastTwoInterfaces = false;

    private NetworkInterface networkInterface1 = null;

    private NetworkInterface networkInterface2 = null;

    private NetworkInterface IPV6networkInterface1 = null;

    private static InetAddress lookup(String s) {
        try {
            return InetAddress.getByName(s);
        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }
    }

    // These IP addresses aren't inherently "good" or "bad"; they're just used like that.
    // We use the "good" addresses for our actual group, and the "bad" addresses are for
    // a group that we won't actually set up.

    private static InetAddress GOOD_IPv4 = lookup("224.0.0.3");
    private static InetAddress BAD_IPv4 = lookup("224.0.0.4");

    private static InetAddress GOOD_IPv6 = lookup("ff05::7:7");
    private static InetAddress BAD_IPv6 = lookup("ff05::7:8");

    static class MulticastServer extends Thread {

        public MulticastSocket ms;

        boolean running = true;

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

        volatile DatagramPacket rdp = null;

        private InetAddress groupAddr = null;
        private SocketAddress groupSockAddr = null;
        private NetworkInterface groupNI = null;

        public void run() {
            try {
                byte[] tmpbuf = new byte[512];
                DatagramPacket tmpPack = new DatagramPacket(tmpbuf, tmpbuf.length);

                while (running) {
                    try {
                        ms.receive(tmpPack);

                        System.arraycopy(tmpPack.getData(), 0, rdp.getData(), rdp.getOffset(), tmpPack.getLength());
                        rdp.setLength(tmpPack.getLength());
                        rdp.setAddress(tmpPack.getAddress());
                        rdp.setPort(tmpPack.getPort());
                    } 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;
            try {
                if (groupAddr != null) {
                    ms.leaveGroup(groupAddr);
                } else if (groupSockAddr != null) {
                    ms.leaveGroup(groupSockAddr, groupNI);
                }
            } catch (IOException e) {}
        }

        public MulticastServer(InetAddress anAddress, int aPort) throws java.io.IOException {
            rbuf = new byte[512];
            rbuf[0] = -1;
            rdp = new DatagramPacket(rbuf, rbuf.length);
            ms = new MulticastSocket(aPort);
            ms.setSoTimeout(2000);
            groupAddr = anAddress;
            ms.joinGroup(groupAddr);
        }

        public MulticastServer(SocketAddress anAddress, int aPort, NetworkInterface netInterface) throws java.io.IOException {
            rbuf = new byte[512];
            rbuf[0] = -1;
            rdp = new DatagramPacket(rbuf, rbuf.length);
            ms = new MulticastSocket(aPort);
            ms.setSoTimeout(2000);
            groupSockAddr = anAddress;
            groupNI = netInterface;
            ms.joinGroup(groupSockAddr, groupNI);
        }
    }

    public void test_Constructor() throws IOException {
        // regression test for 497
        MulticastSocket s = new MulticastSocket();
        // regression test for Harmony-1162
        assertTrue(s.getReuseAddress());
    }

    public void test_ConstructorI() throws IOException {
        MulticastSocket orig = new MulticastSocket();
        int port = orig.getLocalPort();
        orig.close();
        MulticastSocket dup = null;
        try {
            dup = new MulticastSocket(port);
            // regression test for Harmony-1162
            assertTrue(dup.getReuseAddress());
        } catch (IOException e) {
            fail("duplicate binding not allowed: " + e);
        }
        if (dup != null) {
            dup.close();
        }
    }

    public void test_getInterface() throws Exception {
        int groupPort = Support_PortManager.getNextPortForUDP();

        // validate that we get the expected response when one was not set
        MulticastSocket mss = new MulticastSocket(groupPort);
        // we expect an ANY address in this case
        assertTrue(mss.getInterface().isAnyLocalAddress());

        // validate that we get the expected response when we set via
        // setInterface
        Enumeration addresses = networkInterface1.getInetAddresses();
        if (addresses.hasMoreElements()) {
            InetAddress firstAddress = (InetAddress) addresses.nextElement();
            mss.setInterface(firstAddress);
            assertEquals("getNetworkInterface did not return interface set by setInterface", firstAddress, mss.getInterface());

            groupPort = Support_PortManager.getNextPortForUDP();
            mss = new MulticastSocket(groupPort);
            mss.setNetworkInterface(networkInterface1);
            assertEquals("getInterface did not return interface set by setNetworkInterface", networkInterface1, NetworkInterface.getByInetAddress(mss.getInterface()));
        }

        mss.close();
    }

    public void test_getNetworkInterface() throws IOException {
        int groupPort = Support_PortManager.getNextPortForUDP();

        // validate that we get the expected response when one was not set
        MulticastSocket mss = new MulticastSocket(groupPort);
        NetworkInterface theInterface = mss.getNetworkInterface();
        assertTrue("network interface returned wrong network interface when not set:" + theInterface,
                theInterface.getInetAddresses().hasMoreElements());
        InetAddress firstAddress = (InetAddress) theInterface.getInetAddresses().nextElement();
        // validate we the first address in the network interface is the ANY address
        assertTrue(firstAddress.isAnyLocalAddress());

        mss.setNetworkInterface(networkInterface1);
        assertEquals("getNetworkInterface did not return interface set by setNeworkInterface",
                networkInterface1, mss.getNetworkInterface());

        if (atLeastTwoInterfaces) {
            mss.setNetworkInterface(networkInterface2);
            assertEquals("getNetworkInterface did not return network interface set by second setNetworkInterface call",
                    networkInterface2, mss.getNetworkInterface());
        }
        mss.close();

        groupPort = Support_PortManager.getNextPortForUDP();
        mss = new MulticastSocket(groupPort);
        if (IPV6networkInterface1 != null) {
            mss.setNetworkInterface(IPV6networkInterface1);
            assertEquals("getNetworkInterface did not return interface set by setNeworkInterface",
                    IPV6networkInterface1, mss.getNetworkInterface());
        }

        // validate that we get the expected response when we set via setInterface
        groupPort = Support_PortManager.getNextPortForUDP();
        mss = new MulticastSocket(groupPort);
        Enumeration addresses = networkInterface1.getInetAddresses();
        if (addresses.hasMoreElements()) {
            firstAddress = (InetAddress) addresses.nextElement();
            mss.setInterface(firstAddress);
            assertEquals("getNetworkInterface did not return interface set by setInterface",
                    networkInterface1, mss.getNetworkInterface());
        }
        mss.close();
    }

    public void test_getTimeToLive() throws Exception {
        MulticastSocket mss = new MulticastSocket();
        mss.setTimeToLive(120);
        assertEquals("Returned incorrect 1st TTL", 120, mss.getTimeToLive());
        mss.setTimeToLive(220);
        assertEquals("Returned incorrect 2nd TTL", 220, mss.getTimeToLive());
    }

    public void test_getTTL() throws Exception {
        MulticastSocket mss = new MulticastSocket();
        mss.setTTL((byte) 120);
        assertEquals("Returned incorrect TTL", 120, mss.getTTL());
    }

    public void test_joinGroupLjava_net_InetAddress_IPv4() throws Exception {
        test_joinGroupLjava_net_InetAddress(GOOD_IPv4);
    }

    public void test_joinGroupLjava_net_InetAddress_IPv6() throws Exception {
        test_joinGroupLjava_net_InetAddress(GOOD_IPv6);
    }

    private void test_joinGroupLjava_net_InetAddress(InetAddress group) throws Exception {
        int[] ports = Support_PortManager.getNextPortsForUDP(2);
        int groupPort = ports[0];

        MulticastServer server = new MulticastServer(group, groupPort);
        server.start();
        Thread.sleep(1000);
        String msg = "Hello World";
        MulticastSocket mss = new MulticastSocket(ports[1]);
        DatagramPacket sdp = new DatagramPacket(msg.getBytes(), msg.length(), group, groupPort);
        mss.send(sdp, (byte) 10);
        Thread.sleep(1000);
        String receivedMessage = new String(server.rdp.getData(), 0, server.rdp.getLength());
        assertEquals("Group member did not recv data", msg, receivedMessage);
        mss.close();
        server.stopServer();
    }

    public void test_joinGroup_null_null() throws Exception {
        MulticastSocket mss = new MulticastSocket(0);
        try {
            mss.joinGroup(null, null);
            fail();
        } catch (IllegalArgumentException expected) {
        }
        mss.close();
    }

    public void test_joinGroup_non_multicast_address_IPv4() throws Exception {
        MulticastSocket mss = new MulticastSocket(0);
        try {
            mss.joinGroup(new InetSocketAddress(InetAddress.getByName("127.0.0.1"), 0), null);
            fail();
        } catch (IOException expected) {
        }
        mss.close();
    }

    public void test_joinGroup_non_multicast_address_IPv6() throws Exception {
        MulticastSocket mss = new MulticastSocket(0);
        try {
            mss.joinGroup(new InetSocketAddress(InetAddress.getByName("::1"), 0), null);
            fail();
        } catch (IOException expected) {
        }
        mss.close();
    }

    public void test_joinGroupLjava_net_SocketAddressLjava_net_NetworkInterface_IPv4() throws Exception {
        test_joinGroupLjava_net_SocketAddressLjava_net_NetworkInterface(GOOD_IPv4, BAD_IPv4);
    }

    public void test_joinGroupLjava_net_SocketAddressLjava_net_NetworkInterface_IPv6() throws Exception {
        test_joinGroupLjava_net_SocketAddressLjava_net_NetworkInterface(GOOD_IPv6, BAD_IPv6);
    }

    private void test_joinGroupLjava_net_SocketAddressLjava_net_NetworkInterface(InetAddress group, InetAddress group2) throws Exception {
        int[] ports = Support_PortManager.getNextPortsForUDP(2);
        int groupPort = ports[0];
        int serverPort = ports[1];

        SocketAddress groupSockAddr = new InetSocketAddress(group, groupPort);

        // Check that we can join a group using a null network interface.
        MulticastSocket mss = new MulticastSocket(groupPort);
        mss.joinGroup(groupSockAddr, null);
        mss.setTimeToLive(2);
        Thread.sleep(1000);

        // set up the server and join the group on networkInterface1
        MulticastServer server = new MulticastServer(groupSockAddr, serverPort, networkInterface1);
        server.start();
        Thread.sleep(1000);
        String msg = "Hello World";
        DatagramPacket sdp = new DatagramPacket(msg.getBytes(), msg.length(), group, serverPort);
        mss.setTimeToLive(2);
        mss.send(sdp);
        Thread.sleep(1000);
        // now validate that we received the data as expected
        assertEquals("Group member did not recv data", msg, new String(server.rdp.getData(), 0, server.rdp.getLength()));
        server.stopServer();
        mss.close();

        // now validate that we handled the case were we join a
        // different multicast address.
        // verify we do not receive the data
        ports = Support_PortManager.getNextPortsForUDP(2);
        serverPort = ports[0];
        server = new MulticastServer(groupSockAddr, serverPort, networkInterface1);
        server.start();
        Thread.sleep(1000);

        groupPort = ports[1];
        mss = new MulticastSocket(groupPort);
        mss.setTimeToLive(10);
        msg = "Hello World - Different Group";
        sdp = new DatagramPacket(msg.getBytes(), msg.length(), group2, serverPort);
        mss.send(sdp);
        Thread.sleep(1000);
        assertFalse("Group member received data when sent on different group: ",
                new String(server.rdp.getData(), 0, server.rdp.getLength()).equals(msg));
        server.stopServer();
        mss.close();
    }

    public void test_joinGroupLjava_net_SocketAddressLjava_net_NetworkInterface() throws Exception {
        // if there is more than one network interface then check that
        // we can join on specific interfaces and that we only receive
        // if data is received on that interface
        if (!atLeastTwoInterfaces) {
            return;
        }
        // set up server on first interfaces
        NetworkInterface loopbackInterface = NetworkInterface.getByInetAddress(InetAddress.getByName("127.0.0.1"));

        boolean anyLoop = networkInterface1.equals(loopbackInterface) || networkInterface2.equals(loopbackInterface);
        System.err.println("anyLoop="+anyLoop);

        ArrayList<NetworkInterface> realInterfaces = new ArrayList<NetworkInterface>();
        Enumeration<NetworkInterface> theInterfaces = NetworkInterface.getNetworkInterfaces();
        while (theInterfaces.hasMoreElements()) {
            NetworkInterface thisInterface = (NetworkInterface) theInterfaces.nextElement();
            if (thisInterface.getInetAddresses().hasMoreElements()){
                realInterfaces.add(thisInterface);
            }
        }

        for (int i = 0; i < realInterfaces.size(); i++) {
            NetworkInterface thisInterface = realInterfaces.get(i);

            // get the first address on the interface

            // start server which is joined to the group and has
            // only asked for packets on this interface
            Enumeration<InetAddress> addresses = thisInterface.getInetAddresses();

            NetworkInterface sendingInterface = null;
            InetAddress group = null;
            if (addresses.hasMoreElements()) {
                InetAddress firstAddress = (InetAddress) addresses.nextElement();
                if (firstAddress instanceof Inet4Address) {
                    group = InetAddress.getByName("224.0.0.4");
                    if (anyLoop) {
                        if (networkInterface1.equals(loopbackInterface)) {
                            sendingInterface = networkInterface2;
                        } else {
                            sendingInterface = networkInterface1;
                        }
                    } else {
                        if (i == 1){
                            sendingInterface = networkInterface2;
                        } else {
                            sendingInterface = networkInterface1;
                        }
                    }
                } else {
                    // if this interface only seems to support IPV6 addresses
                    group = InetAddress.getByName("FF01:0:0:0:0:0:2:8001");
                    sendingInterface = IPV6networkInterface1;
                }
            }

            int[] ports = Support_PortManager.getNextPortsForUDP(2);
            int serverPort = ports[0];
            int groupPort = ports[1];
            InetSocketAddress groupSockAddr = new InetSocketAddress(group, serverPort);
            MulticastServer server = new MulticastServer(groupSockAddr, serverPort, thisInterface);
            server.start();
            Thread.sleep(1000);

            // Now send out a package on interface
            // networkInterface 1. We should
            // only see the packet if we send it on interface 1
            MulticastSocket mss = new MulticastSocket(groupPort);
            mss.setNetworkInterface(sendingInterface);
            String msg = "Hello World - Again" + thisInterface.getName();
            DatagramPacket sdp = new DatagramPacket(msg.getBytes(), msg.length(), group, serverPort);
            System.err.println(thisInterface + " " + group);
            mss.send(sdp);
            Thread.sleep(1000);
            if (thisInterface.equals(sendingInterface)) {
                assertEquals("Group member did not recv data when bound on specific interface",
                msg, new String(server.rdp.getData(), 0, server.rdp.getLength()));
            } else {
                assertFalse("Group member received data on other interface when only asked for it on one interface: ",
                new String(server.rdp.getData(), 0, server.rdp.getLength()).equals(msg));
            }

            server.stopServer();
            mss.close();
        }
    }

    public void test_joinGroupLjava_net_SocketAddressLjava_net_NetworkInterface_multiple_joins_IPv4() throws Exception {
        test_joinGroupLjava_net_SocketAddressLjava_net_NetworkInterface_multiple_joins(GOOD_IPv4);
    }

    public void test_joinGroupLjava_net_SocketAddressLjava_net_NetworkInterface_multiple_joins_IPv6() throws Exception {
        test_joinGroupLjava_net_SocketAddressLjava_net_NetworkInterface_multiple_joins(GOOD_IPv6);
    }

    private void test_joinGroupLjava_net_SocketAddressLjava_net_NetworkInterface_multiple_joins(InetAddress group) throws Exception {
        // validate that we can join the same address on two
        // different interfaces but not on the same interface
        int groupPort = Support_PortManager.getNextPortForUDP();
        MulticastSocket mss = new MulticastSocket(groupPort);
        SocketAddress groupSockAddr = new InetSocketAddress(group, groupPort);
        mss.joinGroup(groupSockAddr, networkInterface1);
        mss.joinGroup(groupSockAddr, networkInterface2);
        try {
            mss.joinGroup(groupSockAddr, networkInterface1);
            fail("Did not get expected exception when joining for second time on same interface");
        } catch (IOException e) {
        }
        mss.close();
    }

    public void test_leaveGroupLjava_net_InetAddress_IPv4() throws Exception {
        test_leaveGroupLjava_net_InetAddress(GOOD_IPv4);
    }

    public void test_leaveGroupLjava_net_InetAddress_IPv6() throws Exception {
        test_leaveGroupLjava_net_InetAddress(GOOD_IPv6);
    }

    private void test_leaveGroupLjava_net_InetAddress(InetAddress group) throws Exception {
        int[] ports = Support_PortManager.getNextPortsForUDP(2);
        int groupPort = ports[0];

        String msg = "Hello World";
        MulticastSocket mss = new MulticastSocket(ports[1]);
        DatagramPacket sdp = new DatagramPacket(msg.getBytes(), msg.length(), group, groupPort);
        mss.send(sdp, (byte) 10);
        try {
            // Try to leave a group we didn't join.
            mss.leaveGroup(group);
            fail();
        } catch (IOException expected) {
        }
        mss.close();
    }

    public void test_leaveGroup_null_null() throws Exception {
        MulticastSocket mss = new MulticastSocket(0);
        try {
            mss.leaveGroup(null, null);
            fail();
        } catch (IllegalArgumentException expected) {
        }
        mss.close();
    }

    public void test_leaveGroup_non_multicast_address_IPv4() throws Exception {
        MulticastSocket mss = new MulticastSocket(0);
        try {
            mss.leaveGroup(new InetSocketAddress(InetAddress.getByName("127.0.0.1"), 0), null);
            fail();
        } catch (IOException expected) {
        }
        mss.close();
    }

    public void test_leaveGroup_non_multicast_address_IPv6() throws Exception {
        MulticastSocket mss = new MulticastSocket(0);
        try {
            mss.leaveGroup(new InetSocketAddress(InetAddress.getByName("::1"), 0), null);
            fail();
        } catch (IOException expected) {
        }
        mss.close();
    }

    public void test_leaveGroupLjava_net_SocketAddressLjava_net_NetworkInterface_IPv4() throws Exception {
        test_leaveGroupLjava_net_SocketAddressLjava_net_NetworkInterface(GOOD_IPv4, BAD_IPv4);
    }

    public void test_leaveGroupLjava_net_SocketAddressLjava_net_NetworkInterface_IPv6() throws Exception {
        test_leaveGroupLjava_net_SocketAddressLjava_net_NetworkInterface(GOOD_IPv6, BAD_IPv6);
    }

    private void test_leaveGroupLjava_net_SocketAddressLjava_net_NetworkInterface(InetAddress group, InetAddress group2) throws Exception {
        String msg = null;
        int groupPort = Support_PortManager.getNextPortForUDP();
        SocketAddress groupSockAddr = null;
        SocketAddress groupSockAddr2 = null;

        groupSockAddr = new InetSocketAddress(group, groupPort);

        // now test that we can join and leave a group successfully
        groupPort = Support_PortManager.getNextPortForUDP();
        MulticastSocket mss = new MulticastSocket(groupPort);
        groupSockAddr = new InetSocketAddress(group, groupPort);
        mss.joinGroup(groupSockAddr, null);
        mss.leaveGroup(groupSockAddr, null);
        try {
            mss.leaveGroup(groupSockAddr, null);
            fail("Did not get exception when trying to leave group that was already left");
        } catch (IOException expected) {
        }

        groupSockAddr2 = new InetSocketAddress(group2, groupPort);
        mss.joinGroup(groupSockAddr, networkInterface1);
        try {
            mss.leaveGroup(groupSockAddr2, networkInterface1);
            fail("Did not get exception when trying to leave group that was never joined");
        } catch (IOException expected) {
        }

        mss.leaveGroup(groupSockAddr, networkInterface1);
        if (atLeastTwoInterfaces) {
            mss.joinGroup(groupSockAddr, networkInterface1);
            try {
                mss.leaveGroup(groupSockAddr, networkInterface2);
                fail("Did not get exception when trying to leave group on wrong interface joined on [" + networkInterface1 + "] left on [" + networkInterface2 + "]");
            } catch (IOException expected) {
            }
        }
    }

    public void test_sendLjava_net_DatagramPacketB_IPv4() throws Exception {
        test_sendLjava_net_DatagramPacketB(GOOD_IPv4);
    }

    public void test_sendLjava_net_DatagramPacketB_IPv6() throws Exception {
        test_sendLjava_net_DatagramPacketB(GOOD_IPv6);
    }

    private void test_sendLjava_net_DatagramPacketB(InetAddress group) throws Exception {
        String msg = "Hello World";
        int[] ports = Support_PortManager.getNextPortsForUDP(2);
        int groupPort = ports[0];

        MulticastSocket mss = new MulticastSocket(ports[1]);
        MulticastServer server = new MulticastServer(group, groupPort);
        server.start();
        Thread.sleep(200);
        DatagramPacket sdp = new DatagramPacket(msg.getBytes(), msg.length(), group, groupPort);
        mss.send(sdp, (byte) 10);
        Thread.sleep(1000);
        mss.close();
        byte[] data = server.rdp.getData();
        int length = server.rdp.getLength();
        assertEquals("Failed to send data. Received " + length, msg, new String(data, 0, length));
        server.stopServer();
    }

    public void test_setInterfaceLjava_net_InetAddress() throws Exception {
        MulticastSocket mss = new MulticastSocket();
        mss.setInterface(InetAddress.getLocalHost());
        InetAddress theInterface = mss.getInterface();
        // under IPV6 we are not guarrenteed to get the same address back as
        // the address, all we should be guaranteed is that we get an
        // address on the same interface
        if (theInterface instanceof Inet6Address) {
            assertTrue("Failed to return correct interface IPV6", NetworkInterface.getByInetAddress(mss.getInterface()).equals(NetworkInterface.getByInetAddress(theInterface)));
        } else {
            assertTrue("Failed to return correct interface IPV4 got:" + mss.getInterface() + " excpeted: " + InetAddress.getLocalHost(), mss.getInterface().equals(InetAddress.getLocalHost()));
        }
        mss.close();
    }

    public void test_setInterface_unbound_address_IPv4() throws Exception {
        test_setInterface_unbound_address(GOOD_IPv4);
    }

    public void test_setInterface_unbound_address_IPv6() throws Exception {
        test_setInterface_unbound_address(GOOD_IPv6);
    }

    // Regression test for Harmony-2410
    private void test_setInterface_unbound_address(InetAddress address) throws Exception {
        MulticastSocket mss = new MulticastSocket();
        try {
            mss.setInterface(address);
            fail();
        } catch (SocketException expected) {
        }
        mss.close();
    }

    public void test_setNetworkInterfaceLjava_net_NetworkInterface_null() throws Exception {
        // validate that null interface is handled ok
        MulticastSocket mss = new MulticastSocket();
        try {
            mss.setNetworkInterface(null);
            fail("No socket exception when we set then network interface with NULL");
        } catch (SocketException ex) {
        }
        mss.close();
    }

    public void test_setNetworkInterfaceLjava_net_NetworkInterface_round_trip() throws Exception {
        // validate that we can get and set the interface
        MulticastSocket mss = new MulticastSocket();
        mss.setNetworkInterface(networkInterface1);
        assertEquals("Interface did not seem to be set by setNeworkInterface", networkInterface1, mss.getNetworkInterface());
        mss.close();
    }

    public void test_setNetworkInterfaceLjava_net_NetworkInterface_IPv4() throws Exception {
        test_setNetworkInterfaceLjava_net_NetworkInterface(GOOD_IPv4);
    }

    public void test_setNetworkInterfaceLjava_net_NetworkInterface_IPv6() throws Exception {
        test_setNetworkInterfaceLjava_net_NetworkInterface(GOOD_IPv6);
    }

    private void test_setNetworkInterfaceLjava_net_NetworkInterface(InetAddress group) throws IOException, InterruptedException {
        // set up the server and join the group
        Enumeration theInterfaces = NetworkInterface.getNetworkInterfaces();
        while (theInterfaces.hasMoreElements()) {
            NetworkInterface thisInterface = (NetworkInterface) theInterfaces.nextElement();
            if (thisInterface.getInetAddresses().hasMoreElements()) {
                if ((!((InetAddress) thisInterface.getInetAddresses().nextElement()).isLoopbackAddress())) {
                    int[] ports = Support_PortManager.getNextPortsForUDP(2);
                    int serverPort = ports[0];
                    int groupPort = ports[1];

                    MulticastServer server = new MulticastServer(group, serverPort);
                    server.start();
                    // give the server some time to start up
                    Thread.sleep(1000);

                    // Send the packets on a particular interface. The
                    // source address in the received packet
                    // should be one of the addresses for the interface
                    // set
                    MulticastSocket mss = new MulticastSocket(groupPort);
                    mss.setNetworkInterface(thisInterface);
                    String msg = thisInterface.getName();
                    byte theBytes[] = msg.getBytes();
                    DatagramPacket sdp = new DatagramPacket(theBytes, theBytes.length, group, serverPort);
                    mss.send(sdp);
                    Thread.sleep(1000);
                    String receivedMessage = new String(server.rdp.getData(), 0, server.rdp.getLength());
                    assertEquals("Group member did not recv data sent on a specific interface", msg, receivedMessage);
                    // stop the server
                    server.stopServer();
                    mss.close();
                }
            }
        }
    }

    public void test_setTimeToLiveI() throws Exception {
        MulticastSocket mss = new MulticastSocket();
        mss.setTimeToLive(120);
        assertEquals("Returned incorrect 1st TTL", 120, mss.getTimeToLive());
        mss.setTimeToLive(220);
        assertEquals("Returned incorrect 2nd TTL", 220, mss.getTimeToLive());
        mss.close();
    }

    public void test_setTTLB() throws Exception {
        MulticastSocket mss = new MulticastSocket();
        mss.setTTL((byte) 120);
        assertEquals("Failed to set TTL", 120, mss.getTTL());
        mss.close();
    }

    public void test_ConstructorLjava_net_SocketAddress() throws Exception {
        MulticastSocket ms = new MulticastSocket((SocketAddress) null);
        assertTrue("should not be bound", !ms.isBound() && !ms.isClosed() && !ms.isConnected());
        ms.bind(new InetSocketAddress(InetAddress.getLocalHost(), Support_PortManager.getNextPortForUDP()));
        assertTrue("should be bound", ms.isBound() && !ms.isClosed() && !ms.isConnected());
        ms.close();
        assertTrue("should be closed", ms.isClosed());
        ms = new MulticastSocket(new InetSocketAddress(InetAddress.getLocalHost(), Support_PortManager.getNextPortForUDP()));
        assertTrue("should be bound", ms.isBound() && !ms.isClosed() && !ms.isConnected());
        ms.close();
        assertTrue("should be closed", ms.isClosed());
        ms = new MulticastSocket(new InetSocketAddress("localhost", Support_PortManager.getNextPortForUDP()));
        assertTrue("should be bound", ms.isBound() && !ms.isClosed() && !ms.isConnected());
        ms.close();
        assertTrue("should be closed", ms.isClosed());
        try {
            ms = new MulticastSocket(new InetSocketAddress("unresolvedname", Support_PortManager.getNextPortForUDP()));
            fail();
        } catch (IOException expected) {
        }

        // regression test for Harmony-1162
        InetSocketAddress addr = new InetSocketAddress("0.0.0.0", 0);
        MulticastSocket s = new MulticastSocket(addr);
        assertTrue(s.getReuseAddress());
    }

    public void test_getLoopbackMode() throws Exception {
        MulticastSocket ms = new MulticastSocket((SocketAddress) null);
        assertTrue("should not be bound", !ms.isBound() && !ms.isClosed() && !ms.isConnected());
        ms.getLoopbackMode();
        assertTrue("should not be bound", !ms.isBound() && !ms.isClosed() && !ms.isConnected());
        ms.close();
        assertTrue("should be closed", ms.isClosed());
    }

    public void test_setLoopbackModeZ() throws Exception {
        MulticastSocket ms = new MulticastSocket();
        ms.setLoopbackMode(true);
        assertTrue("loopback should be true", ms.getLoopbackMode());
        ms.setLoopbackMode(false);
        assertTrue("loopback should be false", !ms.getLoopbackMode());
        ms.close();
        assertTrue("should be closed", ms.isClosed());
    }

    public void test_setLoopbackModeSendReceive_IPv4() throws Exception {
        test_setLoopbackModeSendReceive(GOOD_IPv4);
    }

    public void test_setLoopbackModeSendReceive_IPv6() throws Exception {
        test_setLoopbackModeSendReceive(GOOD_IPv6);
    }

    private void test_setLoopbackModeSendReceive(InetAddress group) throws IOException{
        final int PORT = Support_PortManager.getNextPortForUDP();
        final String message = "Hello, world!";

        // test send receive
        MulticastSocket socket = new MulticastSocket(PORT);
        socket.setLoopbackMode(false); // false indicates doing loop back
        socket.joinGroup(group);

        // send the datagram
        byte[] sendData = message.getBytes();
        DatagramPacket sendDatagram = new DatagramPacket(sendData, 0, sendData.length, new InetSocketAddress(group, PORT));
        socket.send(sendDatagram);

        // receive the datagram
        byte[] recvData = new byte[100];
        DatagramPacket recvDatagram = new DatagramPacket(recvData, recvData.length);
        socket.setSoTimeout(5000); // prevent eternal block in
        socket.receive(recvDatagram);
        String recvMessage = new String(recvData, 0, recvDatagram.getLength());
        assertEquals(message, recvMessage);
        socket.close();
    }

    public void test_setReuseAddressZ() throws Exception {
        // test case were we set it to false
        MulticastSocket theSocket1 = null;
        MulticastSocket theSocket2 = null;
        try {
            InetSocketAddress theAddress = new InetSocketAddress(InetAddress.getLocalHost(), Support_PortManager.getNextPortForUDP());
            theSocket1 = new MulticastSocket(null);
            theSocket2 = new MulticastSocket(null);
            theSocket1.setReuseAddress(false);
            theSocket2.setReuseAddress(false);
            theSocket1.bind(theAddress);
            theSocket2.bind(theAddress);
            fail("No exception when trying to connect to do duplicate socket bind with re-useaddr set to false");
        } catch (BindException expected) {
        }
        if (theSocket1 != null) {
            theSocket1.close();
        }
        if (theSocket2 != null) {
            theSocket2.close();
        }

        // test case were we set it to true
        InetSocketAddress theAddress = new InetSocketAddress(InetAddress.getLocalHost(), Support_PortManager.getNextPortForUDP());
        theSocket1 = new MulticastSocket(null);
        theSocket2 = new MulticastSocket(null);
        theSocket1.setReuseAddress(true);
        theSocket2.setReuseAddress(true);
        theSocket1.bind(theAddress);
        theSocket2.bind(theAddress);

        if (theSocket1 != null) {
            theSocket1.close();
        }
        if (theSocket2 != null) {
            theSocket2.close();
        }

        // test the default case which we expect to be
        // the same on all platforms
        theAddress = new InetSocketAddress(InetAddress.getLocalHost(), Support_PortManager.getNextPortForUDP());
        theSocket1 = new MulticastSocket(null);
        theSocket2 = new MulticastSocket(null);
        theSocket1.bind(theAddress);
        theSocket2.bind(theAddress);
        if (theSocket1 != null) {
            theSocket1.close();
        }
        if (theSocket2 != null) {
            theSocket2.close();
        }
    }

    @Override protected void setUp() {
        Enumeration theInterfaces = null;
        try {
            theInterfaces = NetworkInterface.getNetworkInterfaces();
        } catch (Exception e) {
        }

        // only consider interfaces that have addresses associated with them.
        // Otherwise tests don't work so well
        if (theInterfaces != null) {
            boolean atLeastOneInterface = false;
            while (theInterfaces.hasMoreElements() && (atLeastOneInterface == false)) {
                networkInterface1 = (NetworkInterface) theInterfaces.nextElement();
                if (networkInterface1.getInetAddresses().hasMoreElements()) {
                    atLeastOneInterface = true;
                }
            }
            assertTrue(atLeastOneInterface);

            atLeastTwoInterfaces = false;
            if (theInterfaces.hasMoreElements()) {
                while (theInterfaces.hasMoreElements() && (atLeastTwoInterfaces == false)) {
                    networkInterface2 = (NetworkInterface) theInterfaces.nextElement();
                    if (networkInterface2.getInetAddresses().hasMoreElements()) {
                        atLeastTwoInterfaces = true;
                    }
                }
            }

            // first the first interface that supports IPV6 if one exists
            try {
                theInterfaces = NetworkInterface.getNetworkInterfaces();
            } catch (Exception e) {
            }
            boolean found = false;
            while (theInterfaces.hasMoreElements() && !found) {
                NetworkInterface nextInterface = (NetworkInterface) theInterfaces.nextElement();
                Enumeration addresses = nextInterface.getInetAddresses();
                if (addresses.hasMoreElements()) {
                    while (addresses.hasMoreElements()) {
                        InetAddress nextAddress = (InetAddress) addresses.nextElement();
                        if (nextAddress instanceof Inet6Address) {
                            IPV6networkInterface1 = nextInterface;
                            found = true;
                            break;
                        }
                    }
                }
            }
        }
    }
}