harmony-tests/src/test/java/org/apache/harmony/tests/java/net/DatagramPacketTest.java

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

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.SocketAddress;

import tests.support.Support_Configuration;

public class DatagramPacketTest extends junit.framework.TestCase {

    volatile boolean started = false;

    /**
     * java.net.DatagramPacket#DatagramPacket(byte[], int)
     */
    public void test_Constructor$BI() {
        DatagramPacket dp = new DatagramPacket("Hello".getBytes(), 5);
        assertEquals("Created incorrect packet", "Hello", new String(dp
                .getData(), 0, dp.getData().length));
        assertEquals("Wrong length", 5, dp.getLength());

        // Regression for HARMONY-890
        dp = new DatagramPacket(new byte[942], 4);
        assertEquals(-1, dp.getPort());
        try {
            dp.getSocketAddress();
            fail("Should throw IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            // expected
        }
    }

    /**
     * java.net.DatagramPacket#DatagramPacket(byte[], int, int)
     */
    public void test_Constructor$BII() {
        DatagramPacket dp = new DatagramPacket("Hello".getBytes(), 2, 3);
        assertEquals("Created incorrect packet", "Hello", new String(dp
                .getData(), 0, dp.getData().length));
        assertEquals("Wrong length", 3, dp.getLength());
        assertEquals("Wrong offset", 2, dp.getOffset());
    }

    /**
     * java.net.DatagramPacket#DatagramPacket(byte[], int, int,
     *java.net.InetAddress, int)
     */
    public void test_Constructor$BIILjava_net_InetAddressI() throws IOException {
        DatagramPacket dp = new DatagramPacket("Hello".getBytes(), 2, 3,
                InetAddress.getLocalHost(), 0);
        assertEquals("Wrong host", InetAddress.getLocalHost(), dp.getAddress());
        assertEquals("Wrong port", 0, dp.getPort());
        assertEquals("Wrong length", 3, dp.getLength());
        assertEquals("Wrong offset", 2, dp.getOffset());
    }

    /**
     * java.net.DatagramPacket#DatagramPacket(byte[], int,
     *java.net.InetAddress, int)
     */
    public void test_Constructor$BILjava_net_InetAddressI() throws IOException {
        DatagramPacket dp = new DatagramPacket("Hello".getBytes(), 5,
                InetAddress.getLocalHost(), 0);
        assertEquals("Wrong address", InetAddress.getLocalHost(), dp
                .getAddress());
        assertEquals("Wrong port", 0, dp.getPort());
        assertEquals("Wrong length", 5, dp.getLength());
    }

    /**
     * java.net.DatagramPacket#getAddress()
     */
    public void test_getAddress() throws IOException {
        DatagramPacket dp = new DatagramPacket("Hello".getBytes(), 5,
                InetAddress.getLocalHost(), 0);
        assertEquals("Incorrect address returned", InetAddress.getLocalHost(),
                dp.getAddress());
    }

    /**
     * java.net.DatagramPacket#getData()
     */
    public void test_getData() {
        DatagramPacket dp = new DatagramPacket("Hello".getBytes(), 5);
        assertEquals("Incorrect length returned", "Hello", new String(dp
                .getData(), 0, dp.getData().length));
    }

    /**
     * java.net.DatagramPacket#getLength()
     */
    public void test_getLength() {
        DatagramPacket dp = new DatagramPacket("Hello".getBytes(), 5);
        assertEquals("Incorrect length returned", 5, dp.getLength());
    }

    /**
     * java.net.DatagramPacket#getOffset()
     */
    public void test_getOffset() {
        DatagramPacket dp = new DatagramPacket("Hello".getBytes(), 3, 2);
        assertEquals("Incorrect length returned", 3, dp.getOffset());
    }

    /**
     * java.net.DatagramPacket#getPort()
     */
    public void test_getPort() throws IOException {
        DatagramPacket dp = new DatagramPacket("Hello".getBytes(), 5,
                InetAddress.getLocalHost(), 1000);
        assertEquals("Incorrect port returned", 1000, dp.getPort());

        final InetAddress localhost = InetAddress.getLocalHost();
        DatagramSocket socket = new DatagramSocket(0, localhost);
        final int port = socket.getLocalPort();

        socket.setSoTimeout(3000);
        DatagramPacket packet = new DatagramPacket(new byte[] { 1, 2, 3, 4, 5,
                6 }, 6, localhost, port);
        socket.send(packet);
        socket.receive(packet);
        socket.close();
        assertTrue("datagram received wrong port: " + packet.getPort(), packet
                .getPort() == port);
    }

    /**
     * java.net.DatagramPacket#setAddress(java.net.InetAddress)
     */
    public void test_setAddressLjava_net_InetAddress() throws IOException {
        InetAddress ia = InetAddress.getByName("127.0.0.1");
        DatagramPacket dp = new DatagramPacket("Hello".getBytes(), 5,
                InetAddress.getLocalHost(), 0);
        dp.setAddress(ia);
        assertEquals("Incorrect address returned", ia, dp.getAddress());
    }

    /**
     * java.net.DatagramPacket#setData(byte[], int, int)
     */
    public void test_setData$BII() {
        DatagramPacket dp = new DatagramPacket("Hello".getBytes(), 5);
        dp.setData("Wagga Wagga".getBytes(), 2, 3);
        assertEquals("Incorrect data set", "Wagga Wagga", new String(dp
                .getData()));
    }

    /**
     * java.net.DatagramPacket#setData(byte[])
     */
    public void test_setData$B() {
        DatagramPacket dp = new DatagramPacket("Hello".getBytes(), 5);
        dp.setData("Ralph".getBytes());
        assertEquals("Incorrect data set", "Ralph", new String(dp.getData(), 0,
                dp.getData().length));
    }

    /**
     * java.net.DatagramPacket#setLength(int)
     */
    public void test_setLengthI() {
        DatagramPacket dp = new DatagramPacket("Hello".getBytes(), 5);
        dp.setLength(1);
        assertEquals("Failed to set packet length", 1, dp.getLength());
    }

    /**
     * java.net.DatagramPacket#setPort(int)
     */
    public void test_setPortI() throws Exception {
        DatagramPacket dp = new DatagramPacket("Hello".getBytes(), 5,
                InetAddress.getLocalHost(), 1000);
        dp.setPort(2000);
        assertEquals("Port not set", 2000, dp.getPort());
    }

    /**
     * java.net.DatagramPacket#DatagramPacket(byte[], int,
     *java.net.SocketAddress)
     */
    public void test_Constructor$BILjava_net_SocketAddress() throws IOException {
        @SuppressWarnings("serial")
        class UnsupportedSocketAddress extends SocketAddress {

            public UnsupportedSocketAddress() {
            }
        }

        // Unsupported SocketAddress subclass
        byte buf[] = new byte[1];
        try {
            new DatagramPacket(buf, 1, new UnsupportedSocketAddress());
            fail("No exception when constructing using unsupported SocketAddress subclass");
        } catch (IllegalArgumentException ex) {
            // Expected
        }

        // Case were we try to pass in null
        try {
            new DatagramPacket(buf, 1, null);
            fail("No exception when constructing address using null");
        } catch (IllegalArgumentException ex) {
            // Expected
        }

        // Now validate we can construct
        InetSocketAddress theAddress = new InetSocketAddress(InetAddress
                .getLocalHost(), 2067);
        DatagramPacket thePacket = new DatagramPacket(buf, 1, theAddress);
        assertEquals("Socket address not set correctly (1)", theAddress,
                thePacket.getSocketAddress());
        assertEquals("Socket address not set correctly (2)", theAddress,
                new InetSocketAddress(thePacket.getAddress(), thePacket
                        .getPort()));
    }

    /**
     * java.net.DatagramPacket#DatagramPacket(byte[], int, int,
     *java.net.SocketAddress)
     */
    public void test_Constructor$BIILjava_net_SocketAddress()
            throws IOException {
        @SuppressWarnings("serial")
        class UnsupportedSocketAddress extends SocketAddress {

            public UnsupportedSocketAddress() {
            }
        }

        // Unsupported SocketAddress subclass
        byte buf[] = new byte[2];
        try {
            new DatagramPacket(buf, 1, 1, new UnsupportedSocketAddress());
            fail("No exception when constructing using unsupported SocketAddress subclass");
        } catch (IllegalArgumentException ex) {
            // Expected
        }

        // Case were we try to pass in null
        try {
            new DatagramPacket(buf, 1, 1, null);
            fail("No exception when constructing address using null");
        } catch (IllegalArgumentException ex) {
            // Expected
        }

        // now validate we can construct
        InetSocketAddress theAddress = new InetSocketAddress(InetAddress
                .getLocalHost(), 2067);
        DatagramPacket thePacket = new DatagramPacket(buf, 1, 1, theAddress);
        assertEquals("Socket address not set correctly (1)", theAddress,
                thePacket.getSocketAddress());
        assertEquals("Socket address not set correctly (2)", theAddress,
                new InetSocketAddress(thePacket.getAddress(), thePacket
                        .getPort()));
        assertEquals("Offset not set correctly", 1, thePacket.getOffset());
    }

    /**
     * java.net.DatagramPacket#getSocketAddress()
     */
    public void test_getSocketAddress() throws IOException {
        byte buf[] = new byte[1];
        DatagramPacket thePacket = new DatagramPacket(buf, 1);

        // Validate get returns the value we set
        InetSocketAddress theAddress = new InetSocketAddress(InetAddress
                .getLocalHost(), 0);
        thePacket = new DatagramPacket(buf, 1);
        thePacket.setSocketAddress(theAddress);
        assertEquals("Socket address not set correctly (1)", theAddress,
                thePacket.getSocketAddress());
    }

    /**
     * java.net.DatagramPacket#setSocketAddress(java.net.SocketAddress)
     */
    public void test_setSocketAddressLjava_net_SocketAddress()
            throws IOException {

        @SuppressWarnings("serial")
        class UnsupportedSocketAddress extends SocketAddress {

            public UnsupportedSocketAddress() {
            }
        }

        // Unsupported SocketAddress subclass
        byte buf[] = new byte[1];
        DatagramPacket thePacket = new DatagramPacket(buf, 1);
        try {
            thePacket.setSocketAddress(new UnsupportedSocketAddress());
            fail("No exception when setting address using unsupported SocketAddress subclass");
        } catch (IllegalArgumentException ex) {
            // Expected
        }

        // Case were we try to pass in null
        thePacket = new DatagramPacket(buf, 1);
        try {
            thePacket.setSocketAddress(null);
            fail("No exception when setting address using null");
        } catch (IllegalArgumentException ex) {
            // Expected
        }

        // Now validate we can set it correctly
        InetSocketAddress theAddress = new InetSocketAddress(InetAddress
                .getLocalHost(), 2049);
        thePacket = new DatagramPacket(buf, 1);
        thePacket.setSocketAddress(theAddress);
        assertEquals("Socket address not set correctly (1)", theAddress,
                thePacket.getSocketAddress());
        assertEquals("Socket address not set correctly (2)", theAddress,
                new InetSocketAddress(thePacket.getAddress(), thePacket
                        .getPort()));
    }
}