/*
* 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 dalvik.annotation.TestTargetClass;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetNew;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.security.Permission;
import java.util.ArrayList;
import java.util.Enumeration;
@TestTargetClass(NetworkInterface.class)
public class NetworkInterfaceTest extends junit.framework.TestCase {
// private member variables used for tests
boolean atLeastOneInterface = false;
boolean atLeastTwoInterfaces = false;
private NetworkInterface networkInterface1 = null;
private NetworkInterface sameAsNetworkInterface1 = null;
private NetworkInterface networkInterface2 = null;
/**
* @tests java.net.NetworkInterface#getName()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getName",
args = {}
)
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()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getInetAddresses",
args = {}
)
public void test_getInetAddresses() {
// 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");
}
}
}
public void checkPermission(Permission perm) {
// allow everything
}
}
if (atLeastOneInterface) {
Enumeration theAddresses = networkInterface1.getInetAddresses();
if (theAddresses != null) {
while (theAddresses.hasMoreElements()) {
InetAddress theAddress = (InetAddress) theAddresses
.nextElement();
assertTrue("validate that address is not null",
null != theAddress);
}
}
}
if (atLeastTwoInterfaces) {
Enumeration theAddresses = networkInterface2.getInetAddresses();
if (theAddresses != null) {
while (theAddresses.hasMoreElements()) {
InetAddress theAddress = (InetAddress) theAddresses
.nextElement();
assertTrue("validate that address is not null",
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();
if (addresses != null) {
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 it it exists
if (atLeastTwoInterfaces) {
addresses = networkInterface2.getInetAddresses();
index = 0;
if (addresses != null) {
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();
if (reducedAddresses != null) {
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();
if (reducedAddresses != null) {
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();
if (reducedAddresses != null) {
while (reducedAddresses.hasMoreElements()) {
InetAddress nextAddress = (InetAddress) reducedAddresses
.nextElement();
if (nextAddress.equals(okAddresses.get(i))) {
addressReturned = true;
}
}
}
if (atLeastTwoInterfaces) {
reducedAddresses = networkInterface2.getInetAddresses();
if (reducedAddresses != null) {
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++) {
try {
assertNotNull(
"validate we cannot get the NetworkInterface with an address for which we have no privs",
NetworkInterface
.getByInetAddress((InetAddress) notOkAddresses
.get(i)));
} catch (Exception e) {
fail("get NetworkInterface for address with no perm - exception");
}
}
// validate that we can get the network interface for the good
// addresses
try {
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)));
}
} catch (Exception e) {
fail("get NetworkInterface for address with perm - exception");
}
System.setSecurityManager(null);
}
}
/**
* @tests java.net.NetworkInterface#getDisplayName()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getDisplayName",
args = {}
)
public void test_getDisplayName() {
if (atLeastOneInterface) {
assertNotNull("validate that non null display name is returned",
networkInterface1.getDisplayName());
assertFalse(
"validate that non-zero lengtj 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)
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "SocketException checking missed.",
method = "getByName",
args = {java.lang.String.class}
)
public void test_getByNameLjava_lang_String() {
try {
assertNull("validate null handled ok",
NetworkInterface.getByName(null));
fail("getByName did not throw NullPointerException for null argument");
} catch (NullPointerException e) {
} catch (Exception e) {
fail("getByName, null inetAddress - raised exception : "
+ e.getMessage());
}
try {
assertNull("validate handled ok if we ask for name not associated with any interface",
NetworkInterface.getByName("8not a name4"));
} catch (Exception e) {
fail("getByName, unknown inetAddress - raised exception : "
+ e.getMessage());
}
// 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) {
try {
assertTrue(
"validate that Interface can be obtained with its name",
NetworkInterface.getByName(theName).equals(
networkInterface1));
} catch (Exception e) {
fail("validate to get network interface using name - socket exception");
}
}
try {
NetworkInterface.getByName(null);
fail("NullPointerException was not thrown.");
} catch(NullPointerException npe) {
//expected
} catch (SocketException e) {
fail("SocketException was thrown.");
}
}
// 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) {
try {
assertTrue(
"validate that Interface can be obtained with its name",
NetworkInterface.getByName(theName).equals(
networkInterface2));
} catch (Exception e) {
fail("validate to get network interface using name - socket exception");
}
}
}
}
/**
* @tests java.net.NetworkInterface#getByInetAddress(java.net.InetAddress)
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "SocketException checking missed.",
method = "getByInetAddress",
args = {java.net.InetAddress.class}
)
public void test_getByInetAddressLjava_net_InetAddress() {
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) {
} catch (Exception e) {
fail("getByInetAddress, null inetAddress should have raised NPE"
+ " but instead threw a : " + e.getMessage());
}
try {
assertNull("validate handled ok if we ask for address not associated with any interface",
NetworkInterface.getByInetAddress(InetAddress
.getByAddress(addressBytes)));
} catch (Exception e) {
fail("getByInetAddress, unknown inetAddress threw exception : " + e);
}
// for each address in an interface validate that we get the right
// interface for that address
if (atLeastOneInterface) {
Enumeration addresses = networkInterface1.getInetAddresses();
if (addresses != null) {
while (addresses.hasMoreElements()) {
InetAddress theAddress = (InetAddress) addresses
.nextElement();
try {
assertTrue(
"validate that Interface can be obtained with any one of its addresses",
NetworkInterface.getByInetAddress(theAddress)
.equals(networkInterface1));
} catch (Exception e) {
fail("validate to get address using inetAddress " +
"threw exception : " + e);
}
}
}
try {
NetworkInterface.getByInetAddress(null);
fail("NullPointerException should be thrown.");
} catch(NullPointerException npe) {
//expected
} catch (SocketException e) {
fail("SocketException was thrown.");
}
}
// 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();
if (addresses != null) {
while (addresses.hasMoreElements()) {
InetAddress theAddress = (InetAddress) addresses
.nextElement();
try {
assertTrue(
"validate that Interface can be obtained with any one of its addresses",
NetworkInterface.getByInetAddress(theAddress)
.equals(networkInterface2));
} catch (Exception e) {
fail("validate to get address using inetAddress "
+ "threw exception : " + e);
}
}
}
}
}
/**
* @tests java.net.NetworkInterface#getNetworkInterfaces()
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "SocketException checking missed.",
method = "getNetworkInterfaces",
args = {}
)
public void test_getNetworkInterfaces() {
// 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
try {
Enumeration theInterfaces = NetworkInterface.getNetworkInterfaces();
} catch (Exception e) {
fail("get Network Interfaces - raised exception : "
+ e.getMessage());
}
}
/**
* @tests java.net.NetworkInterface#equals(java.lang.Object)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "equals",
args = {java.lang.Object.class}
)
public void test_equalsLjava_lang_Object() {
// Test for method boolean
// java.net.SocketPermission.equals(java.lang.Object)
if (atLeastOneInterface) {
assertTrue("If objects are the same true is returned",
networkInterface1.equals(sameAsNetworkInterface1));
assertFalse("Validate Null handled ok", networkInterface1
.equals(null));
}
if (atLeastTwoInterfaces) {
assertFalse("If objects are different false is returned",
networkInterface1.equals(networkInterface2));
}
}
/**
* @tests java.net.NetworkInterface#hashCode()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "hashCode",
args = {}
)
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()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "toString",
args = {}
)
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()));
}
}
protected void setUp() {
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() != null) {
// 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() != null) {
// 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 != null) {
try {
if (addresses.hasMoreElements()) {
sameAsNetworkInterface1 = NetworkInterface
.getByInetAddress((InetAddress) addresses
.nextElement());
}
} catch (SocketException e) {
fail("SocketException occurred : " + e);
}
}
}// end if atLeastOneInterface
}
}
protected void tearDown() {
System.setSecurityManager(null);
}
}
|
