core/tests/coretests/src/android/net/LinkAddressTest.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2013 The Android Open Source Project
  *
  * Licensed 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 android.net;

 import java.net.Inet4Address;
 import java.net.Inet6Address;
 import java.net.InetAddress;
 import java.net.InterfaceAddress;
 import java.net.NetworkInterface;
 import java.net.SocketException;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;

 import android.net.LinkAddress;
 import android.os.Parcel;
 import android.test.AndroidTestCase;
 import static android.test.MoreAsserts.assertNotEqual;
 import android.test.suitebuilder.annotation.SmallTest;

 import static android.system.OsConstants.IFA_F_DEPRECATED;
 import static android.system.OsConstants.IFA_F_PERMANENT;
 import static android.system.OsConstants.IFA_F_TENTATIVE;
 import static android.system.OsConstants.RT_SCOPE_HOST;
 import static android.system.OsConstants.RT_SCOPE_LINK;
 import static android.system.OsConstants.RT_SCOPE_SITE;
 import static android.system.OsConstants.RT_SCOPE_UNIVERSE;

 /**
  * Tests for {@link LinkAddress}.
  */
 public class LinkAddressTest extends AndroidTestCase {

     private static final String V4 = "192.0.2.1";
     private static final String V6 = "2001:db8::1";
     private static final InetAddress V4_ADDRESS = NetworkUtils.numericToInetAddress(V4);
     private static final InetAddress V6_ADDRESS = NetworkUtils.numericToInetAddress(V6);

     public void testConstants() {
         // RT_SCOPE_UNIVERSE = 0, but all the other constants should be nonzero.
         assertNotEqual(0, RT_SCOPE_HOST);
         assertNotEqual(0, RT_SCOPE_LINK);
         assertNotEqual(0, RT_SCOPE_SITE);

         assertNotEqual(0, IFA_F_DEPRECATED);
         assertNotEqual(0, IFA_F_PERMANENT);
         assertNotEqual(0, IFA_F_TENTATIVE);
     }

     public void testConstructors() throws SocketException {
         LinkAddress address;

         // Valid addresses work as expected.
         address = new LinkAddress(V4_ADDRESS, 25);
         assertEquals(V4_ADDRESS, address.getAddress());
         assertEquals(25, address.getPrefixLength());
         assertEquals(0, address.getFlags());
         assertEquals(RT_SCOPE_UNIVERSE, address.getScope());

         address = new LinkAddress(V6_ADDRESS, 127);
         assertEquals(V6_ADDRESS, address.getAddress());
         assertEquals(127, address.getPrefixLength());
         assertEquals(0, address.getFlags());
         assertEquals(RT_SCOPE_UNIVERSE, address.getScope());

         // Nonsensical flags/scopes or combinations thereof are acceptable.
         address = new LinkAddress(V6 + "/64", IFA_F_DEPRECATED | IFA_F_PERMANENT, RT_SCOPE_LINK);
         assertEquals(V6_ADDRESS, address.getAddress());
         assertEquals(64, address.getPrefixLength());
         assertEquals(IFA_F_DEPRECATED | IFA_F_PERMANENT, address.getFlags());
         assertEquals(RT_SCOPE_LINK, address.getScope());

         address = new LinkAddress(V4 + "/23", 123, 456);
         assertEquals(V4_ADDRESS, address.getAddress());
         assertEquals(23, address.getPrefixLength());
         assertEquals(123, address.getFlags());
         assertEquals(456, address.getScope());

         // InterfaceAddress doesn't have a constructor. Fetch some from an interface.
         List<InterfaceAddress> addrs = NetworkInterface.getByName("lo").getInterfaceAddresses();

         // We expect to find 127.0.0.1/8 and ::1/128, in any order.
         LinkAddress ipv4Loopback, ipv6Loopback;
         assertEquals(2, addrs.size());
         if (addrs.get(0).getAddress() instanceof Inet4Address) {
             ipv4Loopback = new LinkAddress(addrs.get(0));
             ipv6Loopback = new LinkAddress(addrs.get(1));
         } else {
             ipv4Loopback = new LinkAddress(addrs.get(1));
             ipv6Loopback = new LinkAddress(addrs.get(0));
         }

         assertEquals(NetworkUtils.numericToInetAddress("127.0.0.1"), ipv4Loopback.getAddress());
         assertEquals(8, ipv4Loopback.getPrefixLength());

         assertEquals(NetworkUtils.numericToInetAddress("::1"), ipv6Loopback.getAddress());
         assertEquals(128, ipv6Loopback.getPrefixLength());

         // Null addresses are rejected.
         try {
             address = new LinkAddress(null, 24);
             fail("Null InetAddress should cause IllegalArgumentException");
         } catch(IllegalArgumentException expected) {}

         try {
             address = new LinkAddress((String) null, IFA_F_PERMANENT, RT_SCOPE_UNIVERSE);
             fail("Null string should cause IllegalArgumentException");
         } catch(IllegalArgumentException expected) {}

         try {
             address = new LinkAddress((InterfaceAddress) null);
             fail("Null string should cause NullPointerException");
         } catch(NullPointerException expected) {}

         // Invalid prefix lengths are rejected.
         try {
             address = new LinkAddress(V4_ADDRESS, -1);
             fail("Negative IPv4 prefix length should cause IllegalArgumentException");
         } catch(IllegalArgumentException expected) {}

         try {
             address = new LinkAddress(V6_ADDRESS, -1);
             fail("Negative IPv6 prefix length should cause IllegalArgumentException");
         } catch(IllegalArgumentException expected) {}

         try {
             address = new LinkAddress(V4_ADDRESS, 33);
             fail("/33 IPv4 prefix length should cause IllegalArgumentException");
         } catch(IllegalArgumentException expected) {}

         try {
             address = new LinkAddress(V4 + "/33", IFA_F_PERMANENT, RT_SCOPE_UNIVERSE);
             fail("/33 IPv4 prefix length should cause IllegalArgumentException");
         } catch(IllegalArgumentException expected) {}


         try {
             address = new LinkAddress(V6_ADDRESS, 129, IFA_F_PERMANENT, RT_SCOPE_UNIVERSE);
             fail("/129 IPv6 prefix length should cause IllegalArgumentException");
         } catch(IllegalArgumentException expected) {}

         try {
             address = new LinkAddress(V6 + "/129", IFA_F_PERMANENT, RT_SCOPE_UNIVERSE);
             fail("/129 IPv6 prefix length should cause IllegalArgumentException");
         } catch(IllegalArgumentException expected) {}

         // Multicast addresses are rejected.
         try {
             address = new LinkAddress("224.0.0.2/32");
             fail("IPv4 multicast address should cause IllegalArgumentException");
         } catch(IllegalArgumentException expected) {}

         try {
             address = new LinkAddress("ff02::1/128");
             fail("IPv6 multicast address should cause IllegalArgumentException");
         } catch(IllegalArgumentException expected) {}
     }

     public void testAddressScopes() {
         assertEquals(RT_SCOPE_HOST, new LinkAddress("::/128").getScope());
         assertEquals(RT_SCOPE_HOST, new LinkAddress("0.0.0.0/32").getScope());

         assertEquals(RT_SCOPE_LINK, new LinkAddress("::1/128").getScope());
         assertEquals(RT_SCOPE_LINK, new LinkAddress("127.0.0.5/8").getScope());
         assertEquals(RT_SCOPE_LINK, new LinkAddress("fe80::ace:d00d/64").getScope());
         assertEquals(RT_SCOPE_LINK, new LinkAddress("169.254.5.12/16").getScope());

         assertEquals(RT_SCOPE_SITE, new LinkAddress("fec0::dead/64").getScope());

         assertEquals(RT_SCOPE_UNIVERSE, new LinkAddress("10.1.2.3/21").getScope());
         assertEquals(RT_SCOPE_UNIVERSE, new LinkAddress("192.0.2.1/25").getScope());
         assertEquals(RT_SCOPE_UNIVERSE, new LinkAddress("2001:db8::/64").getScope());
         assertEquals(RT_SCOPE_UNIVERSE, new LinkAddress("5000::/127").getScope());
     }

     private void assertIsSameAddressAs(LinkAddress l1, LinkAddress l2) {
         assertTrue(l1 + " unexpectedly does not have same address as " + l2,
                 l1.isSameAddressAs(l2));
         assertTrue(l2 + " unexpectedly does not have same address as " + l1,
                 l2.isSameAddressAs(l1));
     }

     private void assertIsNotSameAddressAs(LinkAddress l1, LinkAddress l2) {
         assertFalse(l1 + " unexpectedly has same address as " + l2,
                 l1.isSameAddressAs(l2));
         assertFalse(l2 + " unexpectedly has same address as " + l1,
                 l1.isSameAddressAs(l2));
     }

     private void assertLinkAddressesEqual(LinkAddress l1, LinkAddress l2) {
         assertTrue(l1 + " unexpectedly not equal to " + l2, l1.equals(l2));
         assertTrue(l2 + " unexpectedly not equal to " + l1, l2.equals(l1));
         assertEquals(l1.hashCode(), l2.hashCode());
     }

     private void assertLinkAddressesNotEqual(LinkAddress l1, LinkAddress l2) {
         assertFalse(l1 + " unexpectedly equal to " + l2, l1.equals(l2));
         assertFalse(l2 + " unexpectedly equal to " + l1, l2.equals(l1));
     }

     public void testEqualsAndSameAddressAs() {
         LinkAddress l1, l2, l3;

         l1 = new LinkAddress("2001:db8::1/64");
         l2 = new LinkAddress("2001:db8::1/64");
         assertLinkAddressesEqual(l1, l2);
         assertIsSameAddressAs(l1, l2);

         l2 = new LinkAddress("2001:db8::1/65");
         assertLinkAddressesNotEqual(l1, l2);
         assertIsNotSameAddressAs(l1, l2);

         l2 = new LinkAddress("2001:db8::2/64");
         assertLinkAddressesNotEqual(l1, l2);
         assertIsNotSameAddressAs(l1, l2);


         l1 = new LinkAddress("192.0.2.1/24");
         l2 = new LinkAddress("192.0.2.1/24");
         assertLinkAddressesEqual(l1, l2);
         assertIsSameAddressAs(l1, l2);

         l2 = new LinkAddress("192.0.2.1/23");
         assertLinkAddressesNotEqual(l1, l2);
         assertIsNotSameAddressAs(l1, l2);

         l2 = new LinkAddress("192.0.2.2/24");
         assertLinkAddressesNotEqual(l1, l2);
         assertIsNotSameAddressAs(l1, l2);


         // Check equals() and isSameAddressAs() on identical addresses with different flags.
         l1 = new LinkAddress(V6_ADDRESS, 64);
         l2 = new LinkAddress(V6_ADDRESS, 64, 0, RT_SCOPE_UNIVERSE);
         assertLinkAddressesEqual(l1, l2);
         assertIsSameAddressAs(l1, l2);

         l2 = new LinkAddress(V6_ADDRESS, 64, IFA_F_DEPRECATED, RT_SCOPE_UNIVERSE);
         assertLinkAddressesNotEqual(l1, l2);
         assertIsSameAddressAs(l1, l2);

         // Check equals() and isSameAddressAs() on identical addresses with different scope.
         l1 = new LinkAddress(V4_ADDRESS, 24);
         l2 = new LinkAddress(V4_ADDRESS, 24, 0, RT_SCOPE_UNIVERSE);
         assertLinkAddressesEqual(l1, l2);
         assertIsSameAddressAs(l1, l2);

         l2 = new LinkAddress(V4_ADDRESS, 24, 0, RT_SCOPE_HOST);
         assertLinkAddressesNotEqual(l1, l2);
         assertIsSameAddressAs(l1, l2);

         // Addresses with the same start or end bytes aren't equal between families.
         l1 = new LinkAddress("32.1.13.184/24");
         l2 = new LinkAddress("2001:db8::1/24");
         l3 = new LinkAddress("::2001:db8/24");

         byte[] ipv4Bytes = l1.getAddress().getAddress();
         byte[] l2FirstIPv6Bytes = Arrays.copyOf(l2.getAddress().getAddress(), 4);
         byte[] l3LastIPv6Bytes = Arrays.copyOfRange(l3.getAddress().getAddress(), 12, 16);
         assertTrue(Arrays.equals(ipv4Bytes, l2FirstIPv6Bytes));
         assertTrue(Arrays.equals(ipv4Bytes, l3LastIPv6Bytes));

         assertLinkAddressesNotEqual(l1, l2);
         assertIsNotSameAddressAs(l1, l2);

         assertLinkAddressesNotEqual(l1, l3);
         assertIsNotSameAddressAs(l1, l3);

         // Because we use InetAddress, an IPv4 address is equal to its IPv4-mapped address.
         // TODO: Investigate fixing this.
         String addressString = V4 + "/24";
         l1 = new LinkAddress(addressString);
         l2 = new LinkAddress("::ffff:" + addressString);
         assertLinkAddressesEqual(l1, l2);
         assertIsSameAddressAs(l1, l2);
     }

     public void testHashCode() {
         LinkAddress l;

         l = new LinkAddress(V4_ADDRESS, 23);
         assertEquals(-982787, l.hashCode());

         l = new LinkAddress(V4_ADDRESS, 23, 0, RT_SCOPE_HOST);
         assertEquals(-971865, l.hashCode());

         l = new LinkAddress(V4_ADDRESS, 27);
         assertEquals(-982743, l.hashCode());

         l = new LinkAddress(V6_ADDRESS, 64);
         assertEquals(1076522926, l.hashCode());

         l = new LinkAddress(V6_ADDRESS, 128);
         assertEquals(1076523630, l.hashCode());

         l = new LinkAddress(V6_ADDRESS, 128, IFA_F_TENTATIVE, RT_SCOPE_UNIVERSE);
         assertEquals(1076524846, l.hashCode());
     }

     private LinkAddress passThroughParcel(LinkAddress l) {
         Parcel p = Parcel.obtain();
         LinkAddress l2 = null;
         try {
             l.writeToParcel(p, 0);
             p.setDataPosition(0);
             l2 = LinkAddress.CREATOR.createFromParcel(p);
         } finally {
             p.recycle();
         }
         assertNotNull(l2);
         return l2;
     }

     private void assertParcelingIsLossless(LinkAddress l) {
       LinkAddress l2 = passThroughParcel(l);
       assertEquals(l, l2);
     }

     public void testParceling() {
         LinkAddress l;

         l = new LinkAddress(V6_ADDRESS, 64, 123, 456);
         assertParcelingIsLossless(l);

         l = new LinkAddress(V4 + "/28", IFA_F_PERMANENT, RT_SCOPE_LINK);
         assertParcelingIsLossless(l);
     }
 }
	/*
	* Copyright (C) 2013 The Android Open Source Project
	*
	* Licensed 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 android.net;

	import java.net.Inet4Address;
	import java.net.Inet6Address;
	import java.net.InetAddress;
	import java.net.InterfaceAddress;
	import java.net.NetworkInterface;
	import java.net.SocketException;
	import java.util.Arrays;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.List;

	import android.net.LinkAddress;
	import android.os.Parcel;
	import android.test.AndroidTestCase;
	import static android.test.MoreAsserts.assertNotEqual;
	import android.test.suitebuilder.annotation.SmallTest;

	import static android.system.OsConstants.IFA_F_DEPRECATED;
	import static android.system.OsConstants.IFA_F_PERMANENT;
	import static android.system.OsConstants.IFA_F_TENTATIVE;
	import static android.system.OsConstants.RT_SCOPE_HOST;
	import static android.system.OsConstants.RT_SCOPE_LINK;
	import static android.system.OsConstants.RT_SCOPE_SITE;
	import static android.system.OsConstants.RT_SCOPE_UNIVERSE;

	/**
	* Tests for {@link LinkAddress}.
	*/
	public class LinkAddressTest extends AndroidTestCase {

	private static final String V4 = "192.0.2.1";
	private static final String V6 = "2001:db8::1";
	private static final InetAddress V4_ADDRESS = NetworkUtils.numericToInetAddress(V4);
	private static final InetAddress V6_ADDRESS = NetworkUtils.numericToInetAddress(V6);

	public void testConstants() {
	// RT_SCOPE_UNIVERSE = 0, but all the other constants should be nonzero.
	assertNotEqual(0, RT_SCOPE_HOST);
	assertNotEqual(0, RT_SCOPE_LINK);
	assertNotEqual(0, RT_SCOPE_SITE);

	assertNotEqual(0, IFA_F_DEPRECATED);
	assertNotEqual(0, IFA_F_PERMANENT);
	assertNotEqual(0, IFA_F_TENTATIVE);
	}

	public void testConstructors() throws SocketException {
	LinkAddress address;

	// Valid addresses work as expected.
	address = new LinkAddress(V4_ADDRESS, 25);
	assertEquals(V4_ADDRESS, address.getAddress());
	assertEquals(25, address.getPrefixLength());
	assertEquals(0, address.getFlags());
	assertEquals(RT_SCOPE_UNIVERSE, address.getScope());

	address = new LinkAddress(V6_ADDRESS, 127);
	assertEquals(V6_ADDRESS, address.getAddress());
	assertEquals(127, address.getPrefixLength());
	assertEquals(0, address.getFlags());
	assertEquals(RT_SCOPE_UNIVERSE, address.getScope());

	// Nonsensical flags/scopes or combinations thereof are acceptable.
	address = new LinkAddress(V6 + "/64", IFA_F_DEPRECATED \| IFA_F_PERMANENT, RT_SCOPE_LINK);
	assertEquals(V6_ADDRESS, address.getAddress());
	assertEquals(64, address.getPrefixLength());
	assertEquals(IFA_F_DEPRECATED \| IFA_F_PERMANENT, address.getFlags());
	assertEquals(RT_SCOPE_LINK, address.getScope());

	address = new LinkAddress(V4 + "/23", 123, 456);
	assertEquals(V4_ADDRESS, address.getAddress());
	assertEquals(23, address.getPrefixLength());
	assertEquals(123, address.getFlags());
	assertEquals(456, address.getScope());

	// InterfaceAddress doesn't have a constructor. Fetch some from an interface.
	List<InterfaceAddress> addrs = NetworkInterface.getByName("lo").getInterfaceAddresses();

	// We expect to find 127.0.0.1/8 and ::1/128, in any order.
	LinkAddress ipv4Loopback, ipv6Loopback;
	assertEquals(2, addrs.size());
	if (addrs.get(0).getAddress() instanceof Inet4Address) {
	ipv4Loopback = new LinkAddress(addrs.get(0));
	ipv6Loopback = new LinkAddress(addrs.get(1));
	} else {
	ipv4Loopback = new LinkAddress(addrs.get(1));
	ipv6Loopback = new LinkAddress(addrs.get(0));
	}

	assertEquals(NetworkUtils.numericToInetAddress("127.0.0.1"), ipv4Loopback.getAddress());
	assertEquals(8, ipv4Loopback.getPrefixLength());

	assertEquals(NetworkUtils.numericToInetAddress("::1"), ipv6Loopback.getAddress());
	assertEquals(128, ipv6Loopback.getPrefixLength());

	// Null addresses are rejected.
	try {
	address = new LinkAddress(null, 24);
	fail("Null InetAddress should cause IllegalArgumentException");
	} catch(IllegalArgumentException expected) {}

	try {
	address = new LinkAddress((String) null, IFA_F_PERMANENT, RT_SCOPE_UNIVERSE);
	fail("Null string should cause IllegalArgumentException");
	} catch(IllegalArgumentException expected) {}

	try {
	address = new LinkAddress((InterfaceAddress) null);
	fail("Null string should cause NullPointerException");
	} catch(NullPointerException expected) {}

	// Invalid prefix lengths are rejected.
	try {
	address = new LinkAddress(V4_ADDRESS, -1);
	fail("Negative IPv4 prefix length should cause IllegalArgumentException");
	} catch(IllegalArgumentException expected) {}

	try {
	address = new LinkAddress(V6_ADDRESS, -1);
	fail("Negative IPv6 prefix length should cause IllegalArgumentException");
	} catch(IllegalArgumentException expected) {}

	try {
	address = new LinkAddress(V4_ADDRESS, 33);
	fail("/33 IPv4 prefix length should cause IllegalArgumentException");
	} catch(IllegalArgumentException expected) {}

	try {
	address = new LinkAddress(V4 + "/33", IFA_F_PERMANENT, RT_SCOPE_UNIVERSE);
	fail("/33 IPv4 prefix length should cause IllegalArgumentException");
	} catch(IllegalArgumentException expected) {}


	try {
	address = new LinkAddress(V6_ADDRESS, 129, IFA_F_PERMANENT, RT_SCOPE_UNIVERSE);
	fail("/129 IPv6 prefix length should cause IllegalArgumentException");
	} catch(IllegalArgumentException expected) {}

	try {
	address = new LinkAddress(V6 + "/129", IFA_F_PERMANENT, RT_SCOPE_UNIVERSE);
	fail("/129 IPv6 prefix length should cause IllegalArgumentException");
	} catch(IllegalArgumentException expected) {}

	// Multicast addresses are rejected.
	try {
	address = new LinkAddress("224.0.0.2/32");
	fail("IPv4 multicast address should cause IllegalArgumentException");
	} catch(IllegalArgumentException expected) {}

	try {
	address = new LinkAddress("ff02::1/128");
	fail("IPv6 multicast address should cause IllegalArgumentException");
	} catch(IllegalArgumentException expected) {}
	}

	public void testAddressScopes() {
	assertEquals(RT_SCOPE_HOST, new LinkAddress("::/128").getScope());
	assertEquals(RT_SCOPE_HOST, new LinkAddress("0.0.0.0/32").getScope());

	assertEquals(RT_SCOPE_LINK, new LinkAddress("::1/128").getScope());
	assertEquals(RT_SCOPE_LINK, new LinkAddress("127.0.0.5/8").getScope());
	assertEquals(RT_SCOPE_LINK, new LinkAddress("fe80::ace:d00d/64").getScope());
	assertEquals(RT_SCOPE_LINK, new LinkAddress("169.254.5.12/16").getScope());

	assertEquals(RT_SCOPE_SITE, new LinkAddress("fec0::dead/64").getScope());

	assertEquals(RT_SCOPE_UNIVERSE, new LinkAddress("10.1.2.3/21").getScope());
	assertEquals(RT_SCOPE_UNIVERSE, new LinkAddress("192.0.2.1/25").getScope());
	assertEquals(RT_SCOPE_UNIVERSE, new LinkAddress("2001:db8::/64").getScope());
	assertEquals(RT_SCOPE_UNIVERSE, new LinkAddress("5000::/127").getScope());
	}

	private void assertIsSameAddressAs(LinkAddress l1, LinkAddress l2) {
	assertTrue(l1 + " unexpectedly does not have same address as " + l2,
	l1.isSameAddressAs(l2));
	assertTrue(l2 + " unexpectedly does not have same address as " + l1,
	l2.isSameAddressAs(l1));
	}

	private void assertIsNotSameAddressAs(LinkAddress l1, LinkAddress l2) {
	assertFalse(l1 + " unexpectedly has same address as " + l2,
	l1.isSameAddressAs(l2));
	assertFalse(l2 + " unexpectedly has same address as " + l1,
	l1.isSameAddressAs(l2));
	}

	private void assertLinkAddressesEqual(LinkAddress l1, LinkAddress l2) {
	assertTrue(l1 + " unexpectedly not equal to " + l2, l1.equals(l2));
	assertTrue(l2 + " unexpectedly not equal to " + l1, l2.equals(l1));
	assertEquals(l1.hashCode(), l2.hashCode());
	}

	private void assertLinkAddressesNotEqual(LinkAddress l1, LinkAddress l2) {
	assertFalse(l1 + " unexpectedly equal to " + l2, l1.equals(l2));
	assertFalse(l2 + " unexpectedly equal to " + l1, l2.equals(l1));
	}

	public void testEqualsAndSameAddressAs() {
	LinkAddress l1, l2, l3;

	l1 = new LinkAddress("2001:db8::1/64");
	l2 = new LinkAddress("2001:db8::1/64");
	assertLinkAddressesEqual(l1, l2);
	assertIsSameAddressAs(l1, l2);

	l2 = new LinkAddress("2001:db8::1/65");
	assertLinkAddressesNotEqual(l1, l2);
	assertIsNotSameAddressAs(l1, l2);

	l2 = new LinkAddress("2001:db8::2/64");
	assertLinkAddressesNotEqual(l1, l2);
	assertIsNotSameAddressAs(l1, l2);


	l1 = new LinkAddress("192.0.2.1/24");
	l2 = new LinkAddress("192.0.2.1/24");
	assertLinkAddressesEqual(l1, l2);
	assertIsSameAddressAs(l1, l2);

	l2 = new LinkAddress("192.0.2.1/23");
	assertLinkAddressesNotEqual(l1, l2);
	assertIsNotSameAddressAs(l1, l2);

	l2 = new LinkAddress("192.0.2.2/24");
	assertLinkAddressesNotEqual(l1, l2);
	assertIsNotSameAddressAs(l1, l2);


	// Check equals() and isSameAddressAs() on identical addresses with different flags.
	l1 = new LinkAddress(V6_ADDRESS, 64);
	l2 = new LinkAddress(V6_ADDRESS, 64, 0, RT_SCOPE_UNIVERSE);
	assertLinkAddressesEqual(l1, l2);
	assertIsSameAddressAs(l1, l2);

	l2 = new LinkAddress(V6_ADDRESS, 64, IFA_F_DEPRECATED, RT_SCOPE_UNIVERSE);
	assertLinkAddressesNotEqual(l1, l2);
	assertIsSameAddressAs(l1, l2);

	// Check equals() and isSameAddressAs() on identical addresses with different scope.
	l1 = new LinkAddress(V4_ADDRESS, 24);
	l2 = new LinkAddress(V4_ADDRESS, 24, 0, RT_SCOPE_UNIVERSE);
	assertLinkAddressesEqual(l1, l2);
	assertIsSameAddressAs(l1, l2);

	l2 = new LinkAddress(V4_ADDRESS, 24, 0, RT_SCOPE_HOST);
	assertLinkAddressesNotEqual(l1, l2);
	assertIsSameAddressAs(l1, l2);

	// Addresses with the same start or end bytes aren't equal between families.
	l1 = new LinkAddress("32.1.13.184/24");
	l2 = new LinkAddress("2001:db8::1/24");
	l3 = new LinkAddress("::2001:db8/24");

	byte[] ipv4Bytes = l1.getAddress().getAddress();
	byte[] l2FirstIPv6Bytes = Arrays.copyOf(l2.getAddress().getAddress(), 4);
	byte[] l3LastIPv6Bytes = Arrays.copyOfRange(l3.getAddress().getAddress(), 12, 16);
	assertTrue(Arrays.equals(ipv4Bytes, l2FirstIPv6Bytes));
	assertTrue(Arrays.equals(ipv4Bytes, l3LastIPv6Bytes));

	assertLinkAddressesNotEqual(l1, l2);
	assertIsNotSameAddressAs(l1, l2);

	assertLinkAddressesNotEqual(l1, l3);
	assertIsNotSameAddressAs(l1, l3);

	// Because we use InetAddress, an IPv4 address is equal to its IPv4-mapped address.
	// TODO: Investigate fixing this.
	String addressString = V4 + "/24";
	l1 = new LinkAddress(addressString);
	l2 = new LinkAddress("::ffff:" + addressString);
	assertLinkAddressesEqual(l1, l2);
	assertIsSameAddressAs(l1, l2);
	}

	public void testHashCode() {
	LinkAddress l;

	l = new LinkAddress(V4_ADDRESS, 23);
	assertEquals(-982787, l.hashCode());

	l = new LinkAddress(V4_ADDRESS, 23, 0, RT_SCOPE_HOST);
	assertEquals(-971865, l.hashCode());

	l = new LinkAddress(V4_ADDRESS, 27);
	assertEquals(-982743, l.hashCode());

	l = new LinkAddress(V6_ADDRESS, 64);
	assertEquals(1076522926, l.hashCode());

	l = new LinkAddress(V6_ADDRESS, 128);
	assertEquals(1076523630, l.hashCode());

	l = new LinkAddress(V6_ADDRESS, 128, IFA_F_TENTATIVE, RT_SCOPE_UNIVERSE);
	assertEquals(1076524846, l.hashCode());
	}

	private LinkAddress passThroughParcel(LinkAddress l) {
	Parcel p = Parcel.obtain();
	LinkAddress l2 = null;
	try {
	l.writeToParcel(p, 0);
	p.setDataPosition(0);
	l2 = LinkAddress.CREATOR.createFromParcel(p);
	} finally {
	p.recycle();
	}
	assertNotNull(l2);
	return l2;
	}

	private void assertParcelingIsLossless(LinkAddress l) {
	LinkAddress l2 = passThroughParcel(l);
	assertEquals(l, l2);
	}

	public void testParceling() {
	LinkAddress l;

	l = new LinkAddress(V6_ADDRESS, 64, 123, 456);
	assertParcelingIsLossless(l);

	l = new LinkAddress(V4 + "/28", IFA_F_PERMANENT, RT_SCOPE_LINK);
	assertParcelingIsLossless(l);
	}
	}