libcore/luni/src/test/java/tests/api/java/net/NetworkInterfaceTest.java - platform/dalvik - Git at Google

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

 import java.net.InetAddress;
 import java.net.InterfaceAddress;
 import java.net.NetworkInterface;
 import java.net.SocketException;
 import java.util.ArrayList;
 import java.util.Enumeration;
 import java.util.List;

 public class NetworkInterfaceTest extends junit.framework.TestCase {

 	// private member variables used for tests
     Enumeration<NetworkInterface> theInterfaces = null;

 	boolean atLeastOneInterface = false;

 	boolean atLeastTwoInterfaces = false;

 	private NetworkInterface networkInterface1 = null;

 	private NetworkInterface sameAsNetworkInterface1 = null;

 	private NetworkInterface networkInterface2 = null;

 	/**
 	 * @tests java.net.NetworkInterface#getName()
 	 */
 	public void test_getName() {
 		if (atLeastOneInterface) {
 			assertNotNull("validate that non null name is returned",
 					networkInterface1.getName());
 			assertFalse("validate that non-zero length name is generated",
 					networkInterface1.getName().equals(""));
 		}
 		if (atLeastTwoInterfaces) {
 			assertFalse(
 					"Validate strings are different for different interfaces",
 					networkInterface1.getName().equals(
 							networkInterface2.getName()));
 		}
 	}

 	/**
 	 * @tests java.net.NetworkInterface#getInetAddresses()
 	 */
 	public void test_getInetAddresses() throws Exception {

 		// security manager that allows us to check that we only return the
 		// addresses that we should
 		class mySecurityManager extends SecurityManager {

 			ArrayList disallowedNames = null;

 			public mySecurityManager(ArrayList addresses) {
 				disallowedNames = new ArrayList();
 				for (int i = 0; i < addresses.size(); i++) {
 					disallowedNames.add(((InetAddress) addresses.get(i))
 							.getHostName());
 					disallowedNames.add(((InetAddress) addresses.get(i))
 							.getHostAddress());
 				}
 			}

 			public void checkConnect(String host, int port) {

 				if (host == null) {
 					throw new NullPointerException("host was null)");
 				}

 				for (int i = 0; i < disallowedNames.size(); i++) {
 					if (((String) disallowedNames.get(i)).equals(host)) {
 						throw new SecurityException("not allowed");
 					}
 				}
 			}

 		}

 		if (atLeastOneInterface) {
             Enumeration theAddresses = networkInterface1.getInetAddresses();
             while (theAddresses.hasMoreElements()) {
                 InetAddress theAddress = (InetAddress) theAddresses
                         .nextElement();
                 assertNotNull("validate that address is not null", theAddress);
             }
         }

 		if (atLeastTwoInterfaces) {
 			Enumeration theAddresses = networkInterface2.getInetAddresses();
 			while (theAddresses.hasMoreElements()) {
                 InetAddress theAddress = (InetAddress) theAddresses
                         .nextElement();
                 assertNotNull("validate that address is not null", theAddress);
             }
 		}

 		// create the list of ok and not ok addresses to return
 		if (atLeastOneInterface) {
 			ArrayList okAddresses = new ArrayList();
 			Enumeration addresses = networkInterface1.getInetAddresses();
 			int index = 0;
 			ArrayList notOkAddresses = new ArrayList();
 			while (addresses.hasMoreElements()) {
                 InetAddress theAddress = (InetAddress) addresses.nextElement();
                 if (index != 0) {
                     okAddresses.add(theAddress);
                 } else {
                     notOkAddresses.add(theAddress);
                 }
                 index++;
             }

 			// do the same for network interface 2 if it exists
 			if (atLeastTwoInterfaces) {
 				addresses = networkInterface2.getInetAddresses();
 				index = 0;
 				while (addresses.hasMoreElements()) {
 					InetAddress theAddress = (InetAddress) addresses
 							.nextElement();
 					if (index != 0) {
 						okAddresses.add(theAddress);
 					} else {
 						notOkAddresses.add(theAddress);
 					}
 					index++;
 				}
 			}

 			// set the security manager that will make the first address not
 			// visible
 			System.setSecurityManager(new mySecurityManager(notOkAddresses));

 			// validate not ok addresses are not returned
 			for (int i = 0; i < notOkAddresses.size(); i++) {
 				Enumeration reducedAddresses = networkInterface1
 						.getInetAddresses();
 				while (reducedAddresses.hasMoreElements()) {
                     InetAddress nextAddress = (InetAddress) reducedAddresses
                             .nextElement();
                     assertTrue(
                             "validate that address without permission is not returned",
                             !nextAddress.equals(notOkAddresses.get(i)));
                 }
 				if (atLeastTwoInterfaces) {
                     reducedAddresses = networkInterface2.getInetAddresses();
 					while (reducedAddresses.hasMoreElements()) {
 						InetAddress nextAddress = (InetAddress) reducedAddresses
 								.nextElement();
 						assertTrue(
 								"validate that address without permission is not returned",
 								!nextAddress.equals(notOkAddresses.get(i)));
 					}
 				}
 			}

 			// validate that ok addresses are returned
 			for (int i = 0; i < okAddresses.size(); i++) {
 				boolean addressReturned = false;
 				Enumeration reducedAddresses = networkInterface1
 						.getInetAddresses();
 				while (reducedAddresses.hasMoreElements()) {
                     InetAddress nextAddress = (InetAddress) reducedAddresses
                             .nextElement();
                     if (nextAddress.equals(okAddresses.get(i))) {
                         addressReturned = true;
                     }
                 }
 				if (atLeastTwoInterfaces) {
 					reducedAddresses = networkInterface2.getInetAddresses();
 					while (reducedAddresses.hasMoreElements()) {
 						InetAddress nextAddress = (InetAddress) reducedAddresses
 								.nextElement();
 						if (nextAddress.equals(okAddresses.get(i))) {
 							addressReturned = true;
 						}
 					}
 				}
 				assertTrue("validate that address with permission is returned",
 						addressReturned);
 			}

 			// validate that we can get the interface by specifying the address.
 			// This is to be compatible
 			for (int i = 0; i < notOkAddresses.size(); i++) {
                 assertNotNull(
                         "validate we cannot get the NetworkInterface with an address for which we have no privs",
                         NetworkInterface
                                 .getByInetAddress((InetAddress) notOkAddresses
                                         .get(i)));
             }

 			// validate that we can get the network interface for the good
 			// addresses
 			for (int i = 0; i < okAddresses.size(); i++) {
                 assertNotNull(
                         "validate we cannot get the NetworkInterface with an address fro which we have no privs",
                         NetworkInterface
                                 .getByInetAddress((InetAddress) okAddresses
                                         .get(i)));
             }

 			System.setSecurityManager(null);
 		}
 	}

 	/**
 	 * @tests java.net.NetworkInterface#getDisplayName()
 	 */
 	public void test_getDisplayName() {
 		if (atLeastOneInterface) {
 			assertNotNull("validate that non null display name is returned",
 					networkInterface1.getDisplayName());
 			assertFalse(
 					"validate that non-zero length display name is generated",
 					networkInterface1.getDisplayName().equals(""));
 		}
 		if (atLeastTwoInterfaces) {
 			assertFalse(
 					"Validate strings are different for different interfaces",
 					networkInterface1.getDisplayName().equals(
 							networkInterface2.getDisplayName()));
 		}
 	}

 	/**
 	 * @tests java.net.NetworkInterface#getByName(java.lang.String)
 	 */
 	public void test_getByNameLjava_lang_String() throws Exception {
 		try {
 			assertNull("validate null handled ok",
                                    NetworkInterface.getByName(null));
 			fail("getByName did not throw NullPointerException for null argument");
 		} catch (NullPointerException e) {
 		}

 		assertNull("validate handled ok if we ask for name not associated with any interface",
                                   NetworkInterface.getByName("8not a name4"));

 		// for each address in an interface validate that we get the right
 		// interface for that name
 		if (atLeastOneInterface) {
 			String theName = networkInterface1.getName();
 			if (theName != null) {
                 assertEquals(
                         "validate that Interface can be obtained with its name",
                         networkInterface1, NetworkInterface.getByName(theName));
             }
 		}

 		// validate that we get the right interface with the second interface as
 		// well (ie we just don't always get the first interface
 		if (atLeastTwoInterfaces) {
 			String theName = networkInterface2.getName();
 			if (theName != null) {
                 assertEquals(
                         "validate that Interface can be obtained with its name",
                         networkInterface2, NetworkInterface.getByName(theName));
             }
 		}
 	}

 	/**
 	 * @tests java.net.NetworkInterface#getByInetAddress(java.net.InetAddress)
 	 */
 	public void test_getByInetAddressLjava_net_InetAddress() throws Exception {

 		byte addressBytes[] = new byte[4];
 		addressBytes[0] = 0;
 		addressBytes[1] = 0;
 		addressBytes[2] = 0;
 		addressBytes[3] = 0;

 		try {
 			assertNull("validate null handled ok",
                                    NetworkInterface.getByInetAddress(null));
 			fail("should not get here if getByInetAddress throws "
 					+ "NullPointerException if null passed in");
 		} catch (NullPointerException e) {
 		}

                 assertNull("validate handled ok if we ask for address not associated with any interface",
                            NetworkInterface.getByInetAddress(InetAddress
                                                 .getByAddress(addressBytes)));

 		// for each address in an interface validate that we get the right
 		// interface for that address
 		if (atLeastOneInterface) {
 			Enumeration addresses = networkInterface1.getInetAddresses();
 			while (addresses.hasMoreElements()) {
                 InetAddress theAddress = (InetAddress) addresses.nextElement();
                 assertEquals(
                         "validate that Interface can be obtained with any one of its addresses",
                         networkInterface1, NetworkInterface
                                 .getByInetAddress(theAddress));
             }
 		}

 		// validate that we get the right interface with the second interface as
 		// well (ie we just don't always get the first interface
 		if (atLeastTwoInterfaces) {
 			Enumeration addresses = networkInterface2.getInetAddresses();
 			while (addresses.hasMoreElements()) {
                 InetAddress theAddress = (InetAddress) addresses.nextElement();
                 assertEquals(
                         "validate that Interface can be obtained with any one of its addresses",
                         networkInterface2, NetworkInterface
                                 .getByInetAddress(theAddress));
             }
 		}
 	}

 	/**
 	 * @tests java.net.NetworkInterface#getNetworkInterfaces()
 	 */
 	public void test_getNetworkInterfaces() throws Exception {

 		// really this is tested by all of the other calls but just make sure we
 		// can call it and get a list of interfaces if they exist
 		Enumeration theInterfaces = NetworkInterface.getNetworkInterfaces();
 	}

 	/**
 	 * @tests java.net.NetworkInterface#equals(java.lang.Object)
 	 */
 	public void test_equalsLjava_lang_Object() {
 		// Test for method boolean
 		// java.net.SocketPermission.equals(java.lang.Object)
 		if (atLeastOneInterface) {
             assertEquals("If objects are the same true is returned",
                     sameAsNetworkInterface1, networkInterface1);
             assertNotNull("Validate Null handled ok", networkInterface1);
         }
 		if (atLeastTwoInterfaces) {
 			assertFalse("If objects are different false is returned",
 					networkInterface1.equals(networkInterface2));
 		}
 	}

 	/**
 	 * @tests java.net.NetworkInterface#hashCode()
 	 */
 	public void test_hashCode() {

 		if (atLeastOneInterface) {
 			assertTrue(
 					"validate that hash codes are the same for two calls on the same object",
 					networkInterface1.hashCode() == networkInterface1
 							.hashCode());
 			assertTrue(
 					"validate that hash codes are the same for two objects for which equals is true",
 					networkInterface1.hashCode() == sameAsNetworkInterface1
 							.hashCode());
 		}
 	}

 	/**
 	 * @tests java.net.NetworkInterface#toString()
 	 */
 	public void test_toString() {
 		if (atLeastOneInterface) {
 			assertNotNull("validate that non null string is generated",
 					networkInterface1.toString());
 			assertFalse("validate that non-zero length string is generated",
 					networkInterface1.toString().equals(""));
 		}
 		if (atLeastTwoInterfaces) {
 			assertFalse(
 					"Validate strings are different for different interfaces",
 					networkInterface1.toString().equals(
 							networkInterface2.toString()));
 		}
 	}

     private class MockSecurityManager extends SecurityManager {
         @Override
         public void checkConnect(String host, int port) {
             throw new SecurityException();
         }
     }

     /**
      *
      * @tests java.net.NetworkInterface#getInterfaceAddresses()
      *
      * @since 1.6
      */
     public void test_getInterfaceAddresses() throws SocketException {
         if (theInterfaces != null) {
             SecurityManager oldSM = System.getSecurityManager();
             System.setSecurityManager(new MockSecurityManager());

             while (theInterfaces.hasMoreElements()) {
                 NetworkInterface netif = theInterfaces.nextElement();
                 assertEquals(netif.getName()
                         + " getInterfaceAddresses should contain no element", 0,
                         netif.getInterfaceAddresses().size());
             }
             System.setSecurityManager(oldSM);

             theInterfaces = NetworkInterface.getNetworkInterfaces();
             while (theInterfaces.hasMoreElements()) {
                 NetworkInterface netif = theInterfaces.nextElement();
                 List<InterfaceAddress> interfaceAddrs = netif.getInterfaceAddresses();
                 assertTrue(interfaceAddrs instanceof ArrayList);
                 for (InterfaceAddress addr : interfaceAddrs) {
                     assertNotNull(addr);
                 }

                 List<InterfaceAddress> interfaceAddrs2 = netif.getInterfaceAddresses();
                 // RI fails on this since it cannot tolerate null broadcast address.
                 assertEquals(interfaceAddrs, interfaceAddrs2);
             }
         }
     }

     /**
      * @tests java.net.NetworkInterface#isLoopback()
      *
      * @since 1.6
      */
     public void test_isLoopback() throws SocketException {
         if (theInterfaces != null) {
             while (theInterfaces.hasMoreElements()) {
                 NetworkInterface netif = theInterfaces.nextElement();
                 boolean loopback = false;
                 Enumeration<InetAddress> addrs = netif.getInetAddresses();
                 while(addrs != null && addrs.hasMoreElements()){
                     if(addrs.nextElement().isLoopbackAddress()){
                         loopback = true;
                         break;
                     }
                 }
                 assertEquals(loopback, netif.isLoopback());
             }
         }
     }

     /**
      * @tests java.net.NetworkInterface#getHardwareAddress()
      *
      * @since 1.6
      */
     public void test_getHardwareAddress() throws SocketException {
         if (theInterfaces != null) {
             while (theInterfaces.hasMoreElements()) {
                 NetworkInterface netif = theInterfaces.nextElement();
                 byte[] hwAddr = netif.getHardwareAddress();
                 if (netif.isLoopback()) {
                     assertTrue(hwAddr == null || hwAddr.length == 0);
                 } else {
                     assertTrue(hwAddr.length >= 0);
                 }
             }
         }
     }

     /**
      *
      * @tests java.net.NetworkInterface#getHardwareAddress()
      *
      * @since 1.6
      */
     public void test_getMTU() throws SocketException {
         if (theInterfaces != null) {
             while (theInterfaces.hasMoreElements()) {
                 NetworkInterface netif = theInterfaces.nextElement();
                 assertTrue(netif.getName() + "has non-positive MTU", netif.getMTU() >= 0);
             }
         }
     }

 	protected void setUp() throws SocketException {

 		Enumeration theInterfaces = null;
 		try {
 			theInterfaces = NetworkInterface.getNetworkInterfaces();
 		} catch (Exception e) {
 			fail("Exception occurred getting network interfaces : " + e);
 		}

 		// Set up NetworkInterface instance members. Note that because the call
 		// to NetworkInterface.getNetworkInterfaces() returns *all* of the
 		// interfaces on the test machine it is possible that one or more of
 		// them will not currently be bound to an InetAddress. e.g. a laptop
 		// running connected by a wire to the local network may also have a
 		// wireless interface that is not active and so has no InetAddress
 		// bound to it. For these tests only work with NetworkInterface objects
 		// that are bound to an InetAddress.
 		if ((theInterfaces != null) && (theInterfaces.hasMoreElements())) {
 			while ((theInterfaces.hasMoreElements())
 					&& (atLeastOneInterface == false)) {
 				NetworkInterface theInterface = (NetworkInterface) theInterfaces
 						.nextElement();
 				if (theInterface.getInetAddresses().hasMoreElements()) {
 					// Ensure that the current NetworkInterface has at least
 					// one InetAddress bound to it.
 					Enumeration addrs = theInterface.getInetAddresses();
 					if ((addrs != null) && (addrs.hasMoreElements())) {
 						atLeastOneInterface = true;
 						networkInterface1 = theInterface;
 					}// end if
 				}
 			}

 			while ((theInterfaces.hasMoreElements())
 					&& (atLeastTwoInterfaces == false)) {
 				NetworkInterface theInterface = (NetworkInterface) theInterfaces
 						.nextElement();
 				if (theInterface.getInetAddresses().hasMoreElements()) {
 					// Ensure that the current NetworkInterface has at least
 					// one InetAddress bound to it.
 					Enumeration addrs = theInterface.getInetAddresses();
 					if ((addrs != null) && (addrs.hasMoreElements())) {
 						atLeastTwoInterfaces = true;
 						networkInterface2 = theInterface;
 					}// end if
 				}
 			}

 			// Only set sameAsNetworkInterface1 if we succeeded in finding
 			// at least one good NetworkInterface
 			if (atLeastOneInterface) {
 				Enumeration addresses = networkInterface1.getInetAddresses();
 				if (addresses.hasMoreElements()) {
 					try {
 						if (addresses.hasMoreElements()) {
 							sameAsNetworkInterface1 = NetworkInterface
 							.getByInetAddress((InetAddress) addresses
 									.nextElement());
 						}
 					} catch (SocketException e) {
 						fail("SocketException occurred : " + e);
 					}
 				}
 			}// end if atLeastOneInterface
 		}
         theInterfaces = NetworkInterface.getNetworkInterfaces();
 	}

 	protected void tearDown() {
 		System.setSecurityManager(null);
 	}
 }
	/*
	* 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 tests.api.java.net;

	import java.net.InetAddress;
	import java.net.InterfaceAddress;
	import java.net.NetworkInterface;
	import java.net.SocketException;
	import java.util.ArrayList;
	import java.util.Enumeration;
	import java.util.List;

	public class NetworkInterfaceTest extends junit.framework.TestCase {

	// private member variables used for tests
	Enumeration<NetworkInterface> theInterfaces = null;

	boolean atLeastOneInterface = false;

	boolean atLeastTwoInterfaces = false;

	private NetworkInterface networkInterface1 = null;

	private NetworkInterface sameAsNetworkInterface1 = null;

	private NetworkInterface networkInterface2 = null;

	/**
	* @tests java.net.NetworkInterface#getName()
	*/
	public void test_getName() {
	if (atLeastOneInterface) {
	assertNotNull("validate that non null name is returned",
	networkInterface1.getName());
	assertFalse("validate that non-zero length name is generated",
	networkInterface1.getName().equals(""));
	}
	if (atLeastTwoInterfaces) {
	assertFalse(
	"Validate strings are different for different interfaces",
	networkInterface1.getName().equals(
	networkInterface2.getName()));
	}
	}

	/**
	* @tests java.net.NetworkInterface#getInetAddresses()
	*/
	public void test_getInetAddresses() throws Exception {

	// security manager that allows us to check that we only return the
	// addresses that we should
	class mySecurityManager extends SecurityManager {

	ArrayList disallowedNames = null;

	public mySecurityManager(ArrayList addresses) {
	disallowedNames = new ArrayList();
	for (int i = 0; i < addresses.size(); i++) {
	disallowedNames.add(((InetAddress) addresses.get(i))
	.getHostName());
	disallowedNames.add(((InetAddress) addresses.get(i))
	.getHostAddress());
	}
	}

	public void checkConnect(String host, int port) {

	if (host == null) {
	throw new NullPointerException("host was null)");
	}

	for (int i = 0; i < disallowedNames.size(); i++) {
	if (((String) disallowedNames.get(i)).equals(host)) {
	throw new SecurityException("not allowed");
	}
	}
	}

	}

	if (atLeastOneInterface) {
	Enumeration theAddresses = networkInterface1.getInetAddresses();
	while (theAddresses.hasMoreElements()) {
	InetAddress theAddress = (InetAddress) theAddresses
	.nextElement();
	assertNotNull("validate that address is not null", theAddress);
	}
	}

	if (atLeastTwoInterfaces) {
	Enumeration theAddresses = networkInterface2.getInetAddresses();
	while (theAddresses.hasMoreElements()) {
	InetAddress theAddress = (InetAddress) theAddresses
	.nextElement();
	assertNotNull("validate that address is not null", theAddress);
	}
	}

	// create the list of ok and not ok addresses to return
	if (atLeastOneInterface) {
	ArrayList okAddresses = new ArrayList();
	Enumeration addresses = networkInterface1.getInetAddresses();
	int index = 0;
	ArrayList notOkAddresses = new ArrayList();
	while (addresses.hasMoreElements()) {
	InetAddress theAddress = (InetAddress) addresses.nextElement();
	if (index != 0) {
	okAddresses.add(theAddress);
	} else {
	notOkAddresses.add(theAddress);
	}
	index++;
	}

	// do the same for network interface 2 if it exists
	if (atLeastTwoInterfaces) {
	addresses = networkInterface2.getInetAddresses();
	index = 0;
	while (addresses.hasMoreElements()) {
	InetAddress theAddress = (InetAddress) addresses
	.nextElement();
	if (index != 0) {
	okAddresses.add(theAddress);
	} else {
	notOkAddresses.add(theAddress);
	}
	index++;
	}
	}

	// set the security manager that will make the first address not
	// visible
	System.setSecurityManager(new mySecurityManager(notOkAddresses));

	// validate not ok addresses are not returned
	for (int i = 0; i < notOkAddresses.size(); i++) {
	Enumeration reducedAddresses = networkInterface1
	.getInetAddresses();
	while (reducedAddresses.hasMoreElements()) {
	InetAddress nextAddress = (InetAddress) reducedAddresses
	.nextElement();
	assertTrue(
	"validate that address without permission is not returned",
	!nextAddress.equals(notOkAddresses.get(i)));
	}
	if (atLeastTwoInterfaces) {
	reducedAddresses = networkInterface2.getInetAddresses();
	while (reducedAddresses.hasMoreElements()) {
	InetAddress nextAddress = (InetAddress) reducedAddresses
	.nextElement();
	assertTrue(
	"validate that address without permission is not returned",
	!nextAddress.equals(notOkAddresses.get(i)));
	}
	}
	}

	// validate that ok addresses are returned
	for (int i = 0; i < okAddresses.size(); i++) {
	boolean addressReturned = false;
	Enumeration reducedAddresses = networkInterface1
	.getInetAddresses();
	while (reducedAddresses.hasMoreElements()) {
	InetAddress nextAddress = (InetAddress) reducedAddresses
	.nextElement();
	if (nextAddress.equals(okAddresses.get(i))) {
	addressReturned = true;
	}
	}
	if (atLeastTwoInterfaces) {
	reducedAddresses = networkInterface2.getInetAddresses();
	while (reducedAddresses.hasMoreElements()) {
	InetAddress nextAddress = (InetAddress) reducedAddresses
	.nextElement();
	if (nextAddress.equals(okAddresses.get(i))) {
	addressReturned = true;
	}
	}
	}
	assertTrue("validate that address with permission is returned",
	addressReturned);
	}

	// validate that we can get the interface by specifying the address.
	// This is to be compatible
	for (int i = 0; i < notOkAddresses.size(); i++) {
	assertNotNull(
	"validate we cannot get the NetworkInterface with an address for which we have no privs",
	NetworkInterface
	.getByInetAddress((InetAddress) notOkAddresses
	.get(i)));
	}

	// validate that we can get the network interface for the good
	// addresses
	for (int i = 0; i < okAddresses.size(); i++) {
	assertNotNull(
	"validate we cannot get the NetworkInterface with an address fro which we have no privs",
	NetworkInterface
	.getByInetAddress((InetAddress) okAddresses
	.get(i)));
	}

	System.setSecurityManager(null);
	}
	}

	/**
	* @tests java.net.NetworkInterface#getDisplayName()
	*/
	public void test_getDisplayName() {
	if (atLeastOneInterface) {
	assertNotNull("validate that non null display name is returned",
	networkInterface1.getDisplayName());
	assertFalse(
	"validate that non-zero length display name is generated",
	networkInterface1.getDisplayName().equals(""));
	}
	if (atLeastTwoInterfaces) {
	assertFalse(
	"Validate strings are different for different interfaces",
	networkInterface1.getDisplayName().equals(
	networkInterface2.getDisplayName()));
	}
	}

	/**
	* @tests java.net.NetworkInterface#getByName(java.lang.String)
	*/
	public void test_getByNameLjava_lang_String() throws Exception {
	try {
	assertNull("validate null handled ok",
	NetworkInterface.getByName(null));
	fail("getByName did not throw NullPointerException for null argument");
	} catch (NullPointerException e) {
	}

	assertNull("validate handled ok if we ask for name not associated with any interface",
	NetworkInterface.getByName("8not a name4"));

	// for each address in an interface validate that we get the right
	// interface for that name
	if (atLeastOneInterface) {
	String theName = networkInterface1.getName();
	if (theName != null) {
	assertEquals(
	"validate that Interface can be obtained with its name",
	networkInterface1, NetworkInterface.getByName(theName));
	}
	}

	// validate that we get the right interface with the second interface as
	// well (ie we just don't always get the first interface
	if (atLeastTwoInterfaces) {
	String theName = networkInterface2.getName();
	if (theName != null) {
	assertEquals(
	"validate that Interface can be obtained with its name",
	networkInterface2, NetworkInterface.getByName(theName));
	}
	}
	}

	/**
	* @tests java.net.NetworkInterface#getByInetAddress(java.net.InetAddress)
	*/
	public void test_getByInetAddressLjava_net_InetAddress() throws Exception {

	byte addressBytes[] = new byte[4];
	addressBytes[0] = 0;
	addressBytes[1] = 0;
	addressBytes[2] = 0;
	addressBytes[3] = 0;

	try {
	assertNull("validate null handled ok",
	NetworkInterface.getByInetAddress(null));
	fail("should not get here if getByInetAddress throws "
	+ "NullPointerException if null passed in");
	} catch (NullPointerException e) {
	}

	assertNull("validate handled ok if we ask for address not associated with any interface",
	NetworkInterface.getByInetAddress(InetAddress
	.getByAddress(addressBytes)));

	// for each address in an interface validate that we get the right
	// interface for that address
	if (atLeastOneInterface) {
	Enumeration addresses = networkInterface1.getInetAddresses();
	while (addresses.hasMoreElements()) {
	InetAddress theAddress = (InetAddress) addresses.nextElement();
	assertEquals(
	"validate that Interface can be obtained with any one of its addresses",
	networkInterface1, NetworkInterface
	.getByInetAddress(theAddress));
	}
	}

	// validate that we get the right interface with the second interface as
	// well (ie we just don't always get the first interface
	if (atLeastTwoInterfaces) {
	Enumeration addresses = networkInterface2.getInetAddresses();
	while (addresses.hasMoreElements()) {
	InetAddress theAddress = (InetAddress) addresses.nextElement();
	assertEquals(
	"validate that Interface can be obtained with any one of its addresses",
	networkInterface2, NetworkInterface
	.getByInetAddress(theAddress));
	}
	}
	}

	/**
	* @tests java.net.NetworkInterface#getNetworkInterfaces()
	*/
	public void test_getNetworkInterfaces() throws Exception {

	// really this is tested by all of the other calls but just make sure we
	// can call it and get a list of interfaces if they exist
	Enumeration theInterfaces = NetworkInterface.getNetworkInterfaces();
	}

	/**
	* @tests java.net.NetworkInterface#equals(java.lang.Object)
	*/
	public void test_equalsLjava_lang_Object() {
	// Test for method boolean
	// java.net.SocketPermission.equals(java.lang.Object)
	if (atLeastOneInterface) {
	assertEquals("If objects are the same true is returned",
	sameAsNetworkInterface1, networkInterface1);
	assertNotNull("Validate Null handled ok", networkInterface1);
	}
	if (atLeastTwoInterfaces) {
	assertFalse("If objects are different false is returned",
	networkInterface1.equals(networkInterface2));
	}
	}

	/**
	* @tests java.net.NetworkInterface#hashCode()
	*/
	public void test_hashCode() {

	if (atLeastOneInterface) {
	assertTrue(
	"validate that hash codes are the same for two calls on the same object",
	networkInterface1.hashCode() == networkInterface1
	.hashCode());
	assertTrue(
	"validate that hash codes are the same for two objects for which equals is true",
	networkInterface1.hashCode() == sameAsNetworkInterface1
	.hashCode());
	}
	}

	/**
	* @tests java.net.NetworkInterface#toString()
	*/
	public void test_toString() {
	if (atLeastOneInterface) {
	assertNotNull("validate that non null string is generated",
	networkInterface1.toString());
	assertFalse("validate that non-zero length string is generated",
	networkInterface1.toString().equals(""));
	}
	if (atLeastTwoInterfaces) {
	assertFalse(
	"Validate strings are different for different interfaces",
	networkInterface1.toString().equals(
	networkInterface2.toString()));
	}
	}

	private class MockSecurityManager extends SecurityManager {
	@Override
	public void checkConnect(String host, int port) {
	throw new SecurityException();
	}
	}

	/**
	*
	* @tests java.net.NetworkInterface#getInterfaceAddresses()
	*
	* @since 1.6
	*/
	public void test_getInterfaceAddresses() throws SocketException {
	if (theInterfaces != null) {
	SecurityManager oldSM = System.getSecurityManager();
	System.setSecurityManager(new MockSecurityManager());

	while (theInterfaces.hasMoreElements()) {
	NetworkInterface netif = theInterfaces.nextElement();
	assertEquals(netif.getName()
	+ " getInterfaceAddresses should contain no element", 0,
	netif.getInterfaceAddresses().size());
	}
	System.setSecurityManager(oldSM);

	theInterfaces = NetworkInterface.getNetworkInterfaces();
	while (theInterfaces.hasMoreElements()) {
	NetworkInterface netif = theInterfaces.nextElement();
	List<InterfaceAddress> interfaceAddrs = netif.getInterfaceAddresses();
	assertTrue(interfaceAddrs instanceof ArrayList);
	for (InterfaceAddress addr : interfaceAddrs) {
	assertNotNull(addr);
	}

	List<InterfaceAddress> interfaceAddrs2 = netif.getInterfaceAddresses();
	// RI fails on this since it cannot tolerate null broadcast address.
	assertEquals(interfaceAddrs, interfaceAddrs2);
	}
	}
	}

	/**
	* @tests java.net.NetworkInterface#isLoopback()
	*
	* @since 1.6
	*/
	public void test_isLoopback() throws SocketException {
	if (theInterfaces != null) {
	while (theInterfaces.hasMoreElements()) {
	NetworkInterface netif = theInterfaces.nextElement();
	boolean loopback = false;
	Enumeration<InetAddress> addrs = netif.getInetAddresses();
	while(addrs != null && addrs.hasMoreElements()){
	if(addrs.nextElement().isLoopbackAddress()){
	loopback = true;
	break;
	}
	}
	assertEquals(loopback, netif.isLoopback());
	}
	}
	}

	/**
	* @tests java.net.NetworkInterface#getHardwareAddress()
	*
	* @since 1.6
	*/
	public void test_getHardwareAddress() throws SocketException {
	if (theInterfaces != null) {
	while (theInterfaces.hasMoreElements()) {
	NetworkInterface netif = theInterfaces.nextElement();
	byte[] hwAddr = netif.getHardwareAddress();
	if (netif.isLoopback()) {
	assertTrue(hwAddr == null \|\| hwAddr.length == 0);
	} else {
	assertTrue(hwAddr.length >= 0);
	}
	}
	}
	}

	/**
	*
	* @tests java.net.NetworkInterface#getHardwareAddress()
	*
	* @since 1.6
	*/
	public void test_getMTU() throws SocketException {
	if (theInterfaces != null) {
	while (theInterfaces.hasMoreElements()) {
	NetworkInterface netif = theInterfaces.nextElement();
	assertTrue(netif.getName() + "has non-positive MTU", netif.getMTU() >= 0);
	}
	}
	}

	protected void setUp() throws SocketException {

	Enumeration theInterfaces = null;
	try {
	theInterfaces = NetworkInterface.getNetworkInterfaces();
	} catch (Exception e) {
	fail("Exception occurred getting network interfaces : " + e);
	}

	// Set up NetworkInterface instance members. Note that because the call
	// to NetworkInterface.getNetworkInterfaces() returns all of the
	// interfaces on the test machine it is possible that one or more of
	// them will not currently be bound to an InetAddress. e.g. a laptop
	// running connected by a wire to the local network may also have a
	// wireless interface that is not active and so has no InetAddress
	// bound to it. For these tests only work with NetworkInterface objects
	// that are bound to an InetAddress.
	if ((theInterfaces != null) && (theInterfaces.hasMoreElements())) {
	while ((theInterfaces.hasMoreElements())
	&& (atLeastOneInterface == false)) {
	NetworkInterface theInterface = (NetworkInterface) theInterfaces
	.nextElement();
	if (theInterface.getInetAddresses().hasMoreElements()) {
	// Ensure that the current NetworkInterface has at least
	// one InetAddress bound to it.
	Enumeration addrs = theInterface.getInetAddresses();
	if ((addrs != null) && (addrs.hasMoreElements())) {
	atLeastOneInterface = true;
	networkInterface1 = theInterface;
	}// end if
	}
	}

	while ((theInterfaces.hasMoreElements())
	&& (atLeastTwoInterfaces == false)) {
	NetworkInterface theInterface = (NetworkInterface) theInterfaces
	.nextElement();
	if (theInterface.getInetAddresses().hasMoreElements()) {
	// Ensure that the current NetworkInterface has at least
	// one InetAddress bound to it.
	Enumeration addrs = theInterface.getInetAddresses();
	if ((addrs != null) && (addrs.hasMoreElements())) {
	atLeastTwoInterfaces = true;
	networkInterface2 = theInterface;
	}// end if
	}
	}

	// Only set sameAsNetworkInterface1 if we succeeded in finding
	// at least one good NetworkInterface
	if (atLeastOneInterface) {
	Enumeration addresses = networkInterface1.getInetAddresses();
	if (addresses.hasMoreElements()) {
	try {
	if (addresses.hasMoreElements()) {
	sameAsNetworkInterface1 = NetworkInterface
	.getByInetAddress((InetAddress) addresses
	.nextElement());
	}
	} catch (SocketException e) {
	fail("SocketException occurred : " + e);
	}
	}
	}// end if atLeastOneInterface
	}
	theInterfaces = NetworkInterface.getNetworkInterfaces();
	}

	protected void tearDown() {
	System.setSecurityManager(null);
	}
	}