下面列出了java.net.NetworkInterface#equals ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
public static void main(String[] args) throws Exception {
boolean passed = true;
try {
MulticastSocket ms = new MulticastSocket();
Enumeration<NetworkInterface> networkInterfaces = NetworkInterface
.getNetworkInterfaces();
while (networkInterfaces.hasMoreElements()) {
NetworkInterface netIf = networkInterfaces.nextElement();
if (isNetworkInterfaceTestable(netIf)) {
printNetIfDetails(netIf);
ms.setNetworkInterface(netIf);
NetworkInterface msNetIf = ms.getNetworkInterface();
if (netIf.equals(msNetIf)) {
System.out.println(" OK");
} else {
System.out.println("FAILED!!!");
printNetIfDetails(msNetIf);
passed = false;
}
System.out.println("------------------");
}
}
} catch (IOException e) {
e.printStackTrace();
passed = false;
}
if (!passed) {
throw new RuntimeException("Test Fail");
}
System.out.println("Test passed ");
}
static void assertNetworkInterfaceEqual(
NetworkInterface expectedNetworkInterface,
NetworkInterface deserializedNetworkInterface) {
System.err
.println("Inet6AddressSerializationTest.assertNetworkInterfaceEqual:");
if (expectedNetworkInterface == null) {
if (deserializedNetworkInterface == null) {
// ok, do nothing.
System.err.println("Network Interface equality "
+ " NetworkInterface, expected:"
+ expectedNetworkInterface + ", got :"
+ deserializedNetworkInterface);
} else {
System.err.println("Error checking "
+ " NetworkInterface, expected:"
+ expectedNetworkInterface + ", got :"
+ deserializedNetworkInterface);
failed = true;
}
} else if (!expectedNetworkInterface
.equals(deserializedNetworkInterface)) {
System.err.println("Error checking "
+ // versionStr +
" NetworkInterface, expected:" + expectedNetworkInterface
+ ", got :" + deserializedNetworkInterface);
failed = true;
} else {
System.err.println("Network Interface equality "
+ " NetworkInterface, expected:" + expectedNetworkInterface
+ ", got :" + deserializedNetworkInterface);
}
}
@Override
public void run() {
try {
log.trace("checking if upnp needs restart...");
// Update interface list
List<String> lastInets = inets;
inets = getInets();
boolean changed = false;
if (!inets.equals(lastInets)) {
changed = true;
}
// Run through list of inets even if list is different to update existing data
for (String inet : inets) {
NetworkInterface nif = findNetworkInterface(inet);
InetAddress addr = findBestInet(nif);
NetworkInterface existingNif = netInterfaces.put(inet, nif);
InetAddress existingAddr = ipAddresses.put(inet, addr);
if ((existingNif == null && nif != null) ||
(existingAddr == null && addr != null) ||
(existingNif != null && !existingNif.equals(nif)) ||
(existingAddr != null && !existingAddr.equals(addr))) {
changed = true;
}
}
if (changed) {
restart();
}
} catch (Exception th) {
log.warn("failed to run upnp restart check", th);
}
}
static void assertNetworkInterfaceEqual(
NetworkInterface expectedNetworkInterface,
NetworkInterface deserializedNetworkInterface) {
System.err
.println("Inet6AddressSerializationTest.assertNetworkInterfaceEqual:");
if (expectedNetworkInterface == null) {
if (deserializedNetworkInterface == null) {
// ok, do nothing.
System.err.println("Network Interface equality "
+ " NetworkInterface, expected:"
+ expectedNetworkInterface + ", got :"
+ deserializedNetworkInterface);
} else {
System.err.println("Error checking "
+ " NetworkInterface, expected:"
+ expectedNetworkInterface + ", got :"
+ deserializedNetworkInterface);
failed = true;
}
} else if (!expectedNetworkInterface
.equals(deserializedNetworkInterface)) {
System.err.println("Error checking "
+ // versionStr +
" NetworkInterface, expected:" + expectedNetworkInterface
+ ", got :" + deserializedNetworkInterface);
failed = true;
} else {
System.err.println("Network Interface equality "
+ " NetworkInterface, expected:" + expectedNetworkInterface
+ ", got :" + deserializedNetworkInterface);
}
}
/**
* Block the given sourceToBlock address for the given multicastAddress on the given networkInterface
*/
@Override
public ChannelFuture block(
InetAddress multicastAddress, NetworkInterface networkInterface,
InetAddress sourceToBlock, ChannelPromise promise) {
checkJavaVersion();
if (multicastAddress == null) {
throw new NullPointerException("multicastAddress");
}
if (sourceToBlock == null) {
throw new NullPointerException("sourceToBlock");
}
if (networkInterface == null) {
throw new NullPointerException("networkInterface");
}
synchronized (this) {
if (memberships != null) {
List<MembershipKey> keys = memberships.get(multicastAddress);
for (MembershipKey key: keys) {
if (networkInterface.equals(key.networkInterface())) {
try {
key.block(sourceToBlock);
} catch (IOException e) {
promise.setFailure(e);
}
}
}
}
}
promise.setSuccess();
return promise;
}
public static void main(String[] args) throws Exception {
boolean passed = true;
try {
MulticastSocket ms = new MulticastSocket();
Enumeration<NetworkInterface> networkInterfaces = NetworkInterface
.getNetworkInterfaces();
while (networkInterfaces.hasMoreElements()) {
NetworkInterface netIf = networkInterfaces.nextElement();
if (isNetworkInterfaceTestable(netIf)) {
printNetIfDetails(netIf);
ms.setNetworkInterface(netIf);
NetworkInterface msNetIf = ms.getNetworkInterface();
if (netIf.equals(msNetIf)) {
System.out.println(" OK");
} else {
System.out.println("FAILED!!!");
printNetIfDetails(msNetIf);
passed = false;
}
System.out.println("------------------");
}
}
} catch (IOException e) {
e.printStackTrace();
passed = false;
}
if (!passed) {
throw new RuntimeException("Test Fail");
}
System.out.println("Test passed ");
}
static void assertNetworkInterfaceEqual(
NetworkInterface expectedNetworkInterface,
NetworkInterface deserializedNetworkInterface) {
System.err
.println("Inet6AddressSerializationTest.assertNetworkInterfaceEqual:");
if (expectedNetworkInterface == null) {
if (deserializedNetworkInterface == null) {
// ok, do nothing.
System.err.println("Network Interface equality "
+ " NetworkInterface, expected:"
+ expectedNetworkInterface + ", got :"
+ deserializedNetworkInterface);
} else {
System.err.println("Error checking "
+ " NetworkInterface, expected:"
+ expectedNetworkInterface + ", got :"
+ deserializedNetworkInterface);
failed = true;
}
} else if (!expectedNetworkInterface
.equals(deserializedNetworkInterface)) {
System.err.println("Error checking "
+ // versionStr +
" NetworkInterface, expected:" + expectedNetworkInterface
+ ", got :" + deserializedNetworkInterface);
failed = true;
} else {
System.err.println("Network Interface equality "
+ " NetworkInterface, expected:" + expectedNetworkInterface
+ ", got :" + deserializedNetworkInterface);
}
}
public static void main(String[] args) throws Exception {
boolean passed = true;
try {
MulticastSocket ms = new MulticastSocket();
Enumeration<NetworkInterface> networkInterfaces = NetworkInterface
.getNetworkInterfaces();
while (networkInterfaces.hasMoreElements()) {
NetworkInterface netIf = networkInterfaces.nextElement();
if (isNetworkInterfaceTestable(netIf)) {
printNetIfDetails(netIf);
ms.setNetworkInterface(netIf);
NetworkInterface msNetIf = ms.getNetworkInterface();
if (netIf.equals(msNetIf)) {
System.out.println(" OK");
} else {
System.out.println("FAILED!!!");
printNetIfDetails(msNetIf);
passed = false;
}
System.out.println("------------------");
}
}
} catch (IOException e) {
e.printStackTrace();
passed = false;
}
if (!passed) {
throw new RuntimeException("Test Fail");
}
System.out.println("Test passed ");
}
@Override
public ChannelFuture leaveGroup(
InetAddress multicastAddress, NetworkInterface networkInterface, InetAddress source,
ChannelPromise promise) {
checkJavaVersion();
if (multicastAddress == null) {
throw new NullPointerException("multicastAddress");
}
if (networkInterface == null) {
throw new NullPointerException("networkInterface");
}
synchronized (this) {
if (memberships != null) {
List<MembershipKey> keys = memberships.get(multicastAddress);
if (keys != null) {
Iterator<MembershipKey> keyIt = keys.iterator();
while (keyIt.hasNext()) {
MembershipKey key = keyIt.next();
if (networkInterface.equals(key.networkInterface())) {
if (source == null && key.sourceAddress() == null ||
source != null && source.equals(key.sourceAddress())) {
key.drop();
keyIt.remove();
}
}
}
if (keys.isEmpty()) {
memberships.remove(multicastAddress);
}
}
}
}
promise.setSuccess();
return promise;
}
public static void main(String[] args) throws Exception {
boolean passed = true;
try {
MulticastSocket ms = new MulticastSocket();
Enumeration<NetworkInterface> networkInterfaces = NetworkInterface
.getNetworkInterfaces();
while (networkInterfaces.hasMoreElements()) {
NetworkInterface netIf = networkInterfaces.nextElement();
if (isNetworkInterfaceTestable(netIf)) {
printNetIfDetails(netIf);
ms.setNetworkInterface(netIf);
NetworkInterface msNetIf = ms.getNetworkInterface();
if (netIf.equals(msNetIf)) {
System.out.println(" OK");
} else {
System.out.println("FAILED!!!");
printNetIfDetails(msNetIf);
passed = false;
}
System.out.println("------------------");
}
}
} catch (IOException e) {
e.printStackTrace();
passed = false;
}
if (!passed) {
throw new RuntimeException("Test Fail");
}
System.out.println("Test passed ");
}
static void assertNetworkInterfaceEqual(
NetworkInterface expectedNetworkInterface,
NetworkInterface deserializedNetworkInterface) {
System.err
.println("Inet6AddressSerializationTest.assertNetworkInterfaceEqual:");
if (expectedNetworkInterface == null) {
if (deserializedNetworkInterface == null) {
// ok, do nothing.
System.err.println("Network Interface equality "
+ " NetworkInterface, expected:"
+ expectedNetworkInterface + ", got :"
+ deserializedNetworkInterface);
} else {
System.err.println("Error checking "
+ " NetworkInterface, expected:"
+ expectedNetworkInterface + ", got :"
+ deserializedNetworkInterface);
failed = true;
}
} else if (!expectedNetworkInterface
.equals(deserializedNetworkInterface)) {
System.err.println("Error checking "
+ // versionStr +
" NetworkInterface, expected:" + expectedNetworkInterface
+ ", got :" + deserializedNetworkInterface);
failed = true;
} else {
System.err.println("Network Interface equality "
+ " NetworkInterface, expected:" + expectedNetworkInterface
+ ", got :" + deserializedNetworkInterface);
}
}
public static void main(String[] args) throws Exception {
boolean passed = true;
try {
MulticastSocket ms = new MulticastSocket();
Enumeration<NetworkInterface> networkInterfaces = NetworkInterface
.getNetworkInterfaces();
while (networkInterfaces.hasMoreElements()) {
NetworkInterface netIf = networkInterfaces.nextElement();
if (isNetworkInterfaceTestable(netIf)) {
printNetIfDetails(netIf);
ms.setNetworkInterface(netIf);
NetworkInterface msNetIf = ms.getNetworkInterface();
if (netIf.equals(msNetIf)) {
System.out.println(" OK");
} else {
System.out.println("FAILED!!!");
printNetIfDetails(msNetIf);
passed = false;
}
System.out.println("------------------");
}
}
} catch (IOException e) {
e.printStackTrace();
passed = false;
}
if (!passed) {
throw new RuntimeException("Test Fail");
}
System.out.println("Test passed ");
}
static void assertNetworkInterfaceEqual(
NetworkInterface expectedNetworkInterface,
NetworkInterface deserializedNetworkInterface) {
System.err
.println("Inet6AddressSerializationTest.assertNetworkInterfaceEqual:");
if (expectedNetworkInterface == null) {
if (deserializedNetworkInterface == null) {
// ok, do nothing.
System.err.println("Network Interface equality "
+ " NetworkInterface, expected:"
+ expectedNetworkInterface + ", got :"
+ deserializedNetworkInterface);
} else {
System.err.println("Error checking "
+ " NetworkInterface, expected:"
+ expectedNetworkInterface + ", got :"
+ deserializedNetworkInterface);
failed = true;
}
} else if (!expectedNetworkInterface
.equals(deserializedNetworkInterface)) {
System.err.println("Error checking "
+ // versionStr +
" NetworkInterface, expected:" + expectedNetworkInterface
+ ", got :" + deserializedNetworkInterface);
failed = true;
} else {
System.err.println("Network Interface equality "
+ " NetworkInterface, expected:" + expectedNetworkInterface
+ ", got :" + deserializedNetworkInterface);
}
}
public static void main(String[] args) throws Exception {
boolean passed = true;
try {
MulticastSocket ms = new MulticastSocket();
Enumeration<NetworkInterface> networkInterfaces = NetworkInterface
.getNetworkInterfaces();
while (networkInterfaces.hasMoreElements()) {
NetworkInterface netIf = networkInterfaces.nextElement();
if (isNetworkInterfaceTestable(netIf)) {
printNetIfDetails(netIf);
ms.setNetworkInterface(netIf);
NetworkInterface msNetIf = ms.getNetworkInterface();
if (netIf.equals(msNetIf)) {
System.out.println(" OK");
} else {
System.out.println("FAILED!!!");
printNetIfDetails(msNetIf);
passed = false;
}
System.out.println("------------------");
}
}
} catch (IOException e) {
e.printStackTrace();
passed = false;
}
if (!passed) {
throw new RuntimeException("Test Fail");
}
System.out.println("Test passed ");
}
static void assertNetworkInterfaceEqual(
NetworkInterface expectedNetworkInterface,
NetworkInterface deserializedNetworkInterface) {
System.err
.println("Inet6AddressSerializationTest.assertNetworkInterfaceEqual:");
if (expectedNetworkInterface == null) {
if (deserializedNetworkInterface == null) {
// ok, do nothing.
System.err.println("Network Interface equality "
+ " NetworkInterface, expected:"
+ expectedNetworkInterface + ", got :"
+ deserializedNetworkInterface);
} else {
System.err.println("Error checking "
+ " NetworkInterface, expected:"
+ expectedNetworkInterface + ", got :"
+ deserializedNetworkInterface);
failed = true;
}
} else if (!expectedNetworkInterface
.equals(deserializedNetworkInterface)) {
System.err.println("Error checking "
+ // versionStr +
" NetworkInterface, expected:" + expectedNetworkInterface
+ ", got :" + deserializedNetworkInterface);
failed = true;
} else {
System.err.println("Network Interface equality "
+ " NetworkInterface, expected:" + expectedNetworkInterface
+ ", got :" + deserializedNetworkInterface);
}
}
static void assertNetworkInterfaceEqual(
NetworkInterface expectedNetworkInterface,
NetworkInterface deserializedNetworkInterface) {
System.err
.println("Inet6AddressSerializationTest.assertNetworkInterfaceEqual:");
if (expectedNetworkInterface == null) {
if (deserializedNetworkInterface == null) {
// ok, do nothing.
System.err.println("Network Interface equality "
+ " NetworkInterface, expected:"
+ expectedNetworkInterface + ", got :"
+ deserializedNetworkInterface);
} else {
System.err.println("Error checking "
+ " NetworkInterface, expected:"
+ expectedNetworkInterface + ", got :"
+ deserializedNetworkInterface);
failed = true;
}
} else if (!expectedNetworkInterface
.equals(deserializedNetworkInterface)) {
System.err.println("Error checking "
+ // versionStr +
" NetworkInterface, expected:" + expectedNetworkInterface
+ ", got :" + deserializedNetworkInterface);
failed = true;
} else {
System.err.println("Network Interface equality "
+ " NetworkInterface, expected:" + expectedNetworkInterface
+ ", got :" + deserializedNetworkInterface);
}
}
static void assertNetworkInterfaceEqual(
NetworkInterface expectedNetworkInterface,
NetworkInterface deserializedNetworkInterface) {
System.err
.println("Inet6AddressSerializationTest.assertNetworkInterfaceEqual:");
if (expectedNetworkInterface == null) {
if (deserializedNetworkInterface == null) {
// ok, do nothing.
System.err.println("Network Interface equality "
+ " NetworkInterface, expected:"
+ expectedNetworkInterface + ", got :"
+ deserializedNetworkInterface);
} else {
System.err.println("Error checking "
+ " NetworkInterface, expected:"
+ expectedNetworkInterface + ", got :"
+ deserializedNetworkInterface);
failed = true;
}
} else if (!expectedNetworkInterface
.equals(deserializedNetworkInterface)) {
System.err.println("Error checking "
+ // versionStr +
" NetworkInterface, expected:" + expectedNetworkInterface
+ ", got :" + deserializedNetworkInterface);
failed = true;
} else {
System.err.println("Network Interface equality "
+ " NetworkInterface, expected:" + expectedNetworkInterface
+ ", got :" + deserializedNetworkInterface);
}
}
public static void main(String[] args) throws Exception {
boolean passed = true;
try {
MulticastSocket ms = new MulticastSocket();
Enumeration<NetworkInterface> networkInterfaces = NetworkInterface
.getNetworkInterfaces();
while (networkInterfaces.hasMoreElements()) {
NetworkInterface netIf = networkInterfaces.nextElement();
if (isNetworkInterfaceTestable(netIf)) {
printNetIfDetails(netIf);
ms.setNetworkInterface(netIf);
NetworkInterface msNetIf = ms.getNetworkInterface();
if (netIf.equals(msNetIf)) {
System.out.println(" OK");
} else {
System.out.println("FAILED!!!");
printNetIfDetails(msNetIf);
passed = false;
}
System.out.println("------------------");
}
}
} catch (IOException e) {
e.printStackTrace();
passed = false;
}
if (!passed) {
throw new RuntimeException("Test Fail");
}
System.out.println("Test passed ");
}
static void assertNetworkInterfaceEqual(
NetworkInterface expectedNetworkInterface,
NetworkInterface deserializedNetworkInterface) {
System.err
.println("Inet6AddressSerializationTest.assertNetworkInterfaceEqual:");
if (expectedNetworkInterface == null) {
if (deserializedNetworkInterface == null) {
// ok, do nothing.
System.err.println("Network Interface equality "
+ " NetworkInterface, expected:"
+ expectedNetworkInterface + ", got :"
+ deserializedNetworkInterface);
} else {
System.err.println("Error checking "
+ " NetworkInterface, expected:"
+ expectedNetworkInterface + ", got :"
+ deserializedNetworkInterface);
failed = true;
}
} else if (!expectedNetworkInterface
.equals(deserializedNetworkInterface)) {
System.err.println("Error checking "
+ // versionStr +
" NetworkInterface, expected:" + expectedNetworkInterface
+ ", got :" + deserializedNetworkInterface);
failed = true;
} else {
System.err.println("Network Interface equality "
+ " NetworkInterface, expected:" + expectedNetworkInterface
+ ", got :" + deserializedNetworkInterface);
}
}
public static void main(String[] args) throws Exception {
boolean passed = true;
try {
MulticastSocket ms = new MulticastSocket();
Enumeration<NetworkInterface> networkInterfaces = NetworkInterface
.getNetworkInterfaces();
while (networkInterfaces.hasMoreElements()) {
NetworkInterface netIf = networkInterfaces.nextElement();
if (isNetworkInterfaceTestable(netIf)) {
printNetIfDetails(netIf);
ms.setNetworkInterface(netIf);
NetworkInterface msNetIf = ms.getNetworkInterface();
if (netIf.equals(msNetIf)) {
System.out.println(" OK");
} else {
System.out.println("FAILED!!!");
printNetIfDetails(msNetIf);
passed = false;
}
System.out.println("------------------");
}
}
} catch (IOException e) {
e.printStackTrace();
passed = false;
}
if (!passed) {
throw new RuntimeException("Test Fail");
}
System.out.println("Test passed ");
}