mappingservice/lisp-proto/src/test/java/org/opendaylight/lispflowmapping/lisp/util/LispAddressUtilTest.java

   1 /**
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.lispflowmapping.lisp.util;
   9
  10
  11 import static org.junit.Assert.assertArrayEquals;
  12 import static org.junit.Assert.assertEquals;
  13 import static org.junit.Assert.assertFalse;
  14 import static org.junit.Assert.assertNotNull;
  15 import static org.junit.Assert.assertNull;
  16 import static org.junit.Assert.assertTrue;
  17
  18 import com.google.common.net.InetAddresses;
  19 import java.net.Inet4Address;
  20 import java.net.Inet6Address;
  21 import java.net.InetAddress;
  22 import java.net.UnknownHostException;
  23 import java.util.Arrays;
  24 import java.util.List;
  25 import org.junit.Test;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.AsNumber;
  27 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  28 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
  29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.AsNumberAfi;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.DistinguishedNameAfi;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.DistinguishedNameType;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.ExplicitLocatorPathLcaf;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.InstanceIdType;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4Afi;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4PrefixAfi;
  40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv6Afi;
  41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv6PrefixAfi;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.KeyValueAddressLcaf;
  43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.LispAddress;
  44 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.LispAddressFamily;
  45 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.MacAfi;
  46 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.NoAddressAfi;
  47 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.ServicePathIdType;
  48 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.ServicePathLcaf;
  49 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SimpleAddress;
  50 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SourceDestKeyLcaf;
  51 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.Address;
  52 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.DistinguishedName;
  53 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ExplicitLocatorPath;
  54 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4;
  55 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4Builder;
  56 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4PrefixBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6;
  58 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6Builder;
  59 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6PrefixBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.KeyValueAddress;
  61 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Mac;
  62 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.MacBuilder;
  63 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.NoAddress;
  64 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.explicit.locator.path.explicit.locator.path.Hop;
  65 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.service.path.ServicePath;
  66 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.source.dest.key.SourceDestKey;
  67 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.source.dest.key.SourceDestKeyBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv4AddressBinary;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv6AddressBinary;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.Ipv4BinaryAfi;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.Ipv4PrefixBinaryAfi;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.Ipv6BinaryAfi;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.Ipv6PrefixBinaryAfi;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.augmented.lisp.address.address.Ipv4Binary;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.augmented.lisp.address.address.Ipv4BinaryBuilder;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.augmented.lisp.address.address.Ipv4PrefixBinary;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.augmented.lisp.address.address.Ipv4PrefixBinaryBuilder;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.augmented.lisp.address.address.Ipv6Binary;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.augmented.lisp.address.address.Ipv6BinaryBuilder;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.augmented.lisp.address.address.Ipv6PrefixBinary;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.augmented.lisp.address.address.Ipv6PrefixBinaryBuilder;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.EidBuilder;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecord;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.RlocBuilder;
  88
  89 public class LispAddressUtilTest {
  90
  91     private static final char[] DUMMY_CHARACTER_ARRAY_TEST = new char[]{'a', 'b', 'c', 'd'};
  92     private static final Long NUMBER_TEST = 5L;
  93
  94     private static final byte[] IPV4_ADDRESS_BYTES_A_TEST = new byte[]{(byte) 192, (byte) 168, 1, 1};
  95     private static final byte[] IPV4_ADDRESS_BYTES_B_TEST = new byte[]{(byte) 192, (byte) 168, 1, 2};
  96
  97     private static final short MASK_OK_TEST = 30;
  98     private static final short MASK_OK_DEFAULT_IPV4_TEST = 32;
  99     private static final short MASK_OK_DEFAULT_IPV6_TEST = 128;
 100
 101     private static final Long AS_NUMBER_TEST = 100L;
 102     private static final Long INSTANCE_ID_TYPE_VALUE_TEST = 121L;
 103     private static final Short INSTANCE_ID_TYPE_VALUE_SHORT_TEST = 122;
 104     private static final InstanceIdType INSTANCE_ID_TYPE_TEST = new InstanceIdType(INSTANCE_ID_TYPE_VALUE_TEST);
 105     private static final String INCORRECT_IP_ADDRESS_TEST = "incorrect ip address";
 106
 107     private static final String MAC_ADDRESS_VALUE_TEST = "aa:bb:cc:dd:ee:ff";
 108     private static final MacAddress MAC_ADDRESS_TEST = new MacAddress(MAC_ADDRESS_VALUE_TEST);
 109     private static final Mac MAC = new MacBuilder().setMac(MAC_ADDRESS_TEST).build();
 110     private static final Eid MAC_ADDRESS_EID = new EidBuilder()
 111             .setAddress(MAC)
 112             .setAddressType(MacAfi.class)
 113             .setVirtualNetworkId(INSTANCE_ID_TYPE_TEST).build();
 114
 115     private static final String IPV4_ADDRESS_VALUE_TEST = "192.168.1.1";
 116     private static final String IPV4_ADDRESS_PREFIX_VALUE_TEST = IPV4_ADDRESS_VALUE_TEST + "/" + MASK_OK_TEST;
 117     private static final Ipv4Address IPV4_ADDRESS_TEST = new Ipv4Address(IPV4_ADDRESS_VALUE_TEST);
 118     private static final Ipv4 IPV4 = new Ipv4Builder().setIpv4(IPV4_ADDRESS_TEST).build();
 119     private static final Ipv4AddressBinary IPV4_ADDRESS_BINARY_TEST = new Ipv4AddressBinary(IPV4_ADDRESS_BYTES_A_TEST);
 120     private static final Ipv4Binary IPV4_BINARY = new Ipv4BinaryBuilder()
 121             .setIpv4Binary(IPV4_ADDRESS_BINARY_TEST).build();
 122     private static final IpAddress IP_ADDRESS_IPV4_TEST = new IpAddress(IPV4_ADDRESS_TEST);
 123     private static final Ipv4Prefix IPV4_ADDRESS_PREFIX_TEST = new Ipv4Prefix(IPV4_ADDRESS_PREFIX_VALUE_TEST);
 124     private static final Ipv4PrefixBinary IPV4_ADDRESS_PREFIX_BINARY = new Ipv4PrefixBinaryBuilder()
 125             .setIpv4AddressBinary(new Ipv4AddressBinary(IPV4_ADDRESS_BYTES_A_TEST))
 126             .setIpv4MaskLength(MASK_OK_TEST).build();
 127     private static final IpPrefix IP_ADDRESS_PREFIX_WITH_IPV4_TEST = new IpPrefix(IPV4_ADDRESS_PREFIX_TEST);
 128     private static final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp
 129             .address.address.Ipv4Prefix IPV4_PREFIX = new Ipv4PrefixBuilder()
 130             .setIpv4Prefix(IPV4_ADDRESS_PREFIX_TEST).build();
 131     private static final Eid IPV4_ADDRESS_PREFIX_BINARY_EID = new EidBuilder()
 132             .setAddress(IPV4_ADDRESS_PREFIX_BINARY)
 133             .setAddressType(Ipv4PrefixBinaryAfi.class)
 134             .setVirtualNetworkId(INSTANCE_ID_TYPE_TEST).build();
 135     private static final Eid IPV4_ADDRESS_BINARY_EID = new EidBuilder()
 136             .setAddress(IPV4_BINARY)
 137             .setAddressType(Ipv4BinaryAfi.class)
 138             .setVirtualNetworkId(INSTANCE_ID_TYPE_TEST).build();
 139     private static final Rloc IPV4_RLOC = new RlocBuilder()
 140             .setAddress(IPV4)
 141             .setAddressType(Ipv4Afi.class).build();
 142     private static final Rloc IPV4_BINARY_RLOC = new RlocBuilder()
 143             .setAddress(IPV4_BINARY)
 144             .setAddressType(Ipv4BinaryAfi.class).build();
 145
 146     private static final byte[] IPV6_ADDRESS_BYTES_A_TEST = new byte[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
 147         15, 16};
 148     private static final byte[] IPV6_ADDRESS_BYTES_B_TEST = new byte[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
 149         15, 17};
 150     private static final String IPV6_ADDRESS_VALUE_TEST = "102:304:506:708:90a:b0c:d0e:f10";
 151     private static final String IPV6_ADDRESS_PREFIX_VALUE_TEST = IPV6_ADDRESS_VALUE_TEST + "/" + MASK_OK_TEST;
 152     private static final Ipv6Prefix IPV6_ADDRESS_PREFIX_TEST = new Ipv6Prefix(IPV6_ADDRESS_PREFIX_VALUE_TEST);
 153     private static final Ipv6Address IPV6_ADDRESS_TEST = new Ipv6Address(IPV6_ADDRESS_VALUE_TEST);
 154     private static final Ipv6 IPV6 = new Ipv6Builder().setIpv6(IPV6_ADDRESS_TEST).build();
 155     private static final Ipv6AddressBinary IPV6_ADDRESS_BINARY_TEST = new Ipv6AddressBinary(IPV6_ADDRESS_BYTES_A_TEST);
 156     private static final Ipv6Binary IPV6_BINARY = new Ipv6BinaryBuilder()
 157             .setIpv6Binary(IPV6_ADDRESS_BINARY_TEST).build();
 158     private static final IpPrefix IP_ADDRESS_PREFIX_WITH_IPV6_TEST = new IpPrefix(IPV6_ADDRESS_PREFIX_TEST);
 159     private static final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp
 160             .address.address.Ipv6Prefix IPV6_PREFIX = new Ipv6PrefixBuilder()
 161             .setIpv6Prefix(IPV6_ADDRESS_PREFIX_TEST).build();
 162     private static final IpAddress IP_ADDRESS_IPV6_TEST = new IpAddress(IPV6_ADDRESS_TEST);
 163     private static final Ipv6PrefixBinary IPV6_ADDRESS_PREFIX_BINARY = new Ipv6PrefixBinaryBuilder()
 164             .setIpv6AddressBinary(new Ipv6AddressBinary(IPV6_ADDRESS_BYTES_A_TEST))
 165             .setIpv6MaskLength(MASK_OK_TEST).build();
 166     private static final Eid IPV6_ADDRESS_PREFIX_BINARY_EID = new EidBuilder()
 167             .setAddress(IPV6_ADDRESS_PREFIX_BINARY)
 168             .setAddressType(Ipv6PrefixBinaryAfi.class)
 169             .setVirtualNetworkId(INSTANCE_ID_TYPE_TEST).build();
 170     private static final Eid IPV6_ADDRESS_BINARY_EID = new EidBuilder()
 171             .setAddress(IPV6_BINARY)
 172             .setAddressType(Ipv6BinaryAfi.class)
 173             .setVirtualNetworkId(INSTANCE_ID_TYPE_TEST).build();
 174
 175     private static final Short SERVICE_INDEX_TEST = 45;
 176     private static final Long DUMMY_SERVICE_PATH_ID_TYPE = 46L;
 177     private static final String DISTINGUISHED_NAME_TYPE_VALUE_TEST = "dummy distinguished name type";
 178     private static final String DISTINGUISHED_NAME_TYPE_VALUE_WITH_MAC_TEST = MAC_ADDRESS_VALUE_TEST;
 179     private static final DistinguishedNameType DISTINGUISHED_NAME_TYPE_TEST = new DistinguishedNameType(
 180             DISTINGUISHED_NAME_TYPE_VALUE_TEST);
 181
 182     private static final SimpleAddress SIMPLE_ADDRESS_IPV4_TEST = new SimpleAddress(IP_ADDRESS_IPV4_TEST);
 183     private static final SimpleAddress SIMPLE_ADDRESS_IPV6_TEST = new SimpleAddress(IP_ADDRESS_IPV6_TEST);
 184     private static final SimpleAddress SIMPLE_ADDRESS_MAC_TEST = new SimpleAddress(MAC_ADDRESS_TEST);
 185     private static final SimpleAddress SIMPLE_ADDRESS_DISTINGUISHED_TEST =
 186             new SimpleAddress(DISTINGUISHED_NAME_TYPE_TEST);
 187     private static final SimpleAddress SIMPLE_ADDRESS_IPV4_PREFIX_TEST = new SimpleAddress(
 188             IP_ADDRESS_PREFIX_WITH_IPV4_TEST);
 189     private static final SimpleAddress SIMPLE_ADDRESS_IPV6_PREFIX_TEST = new SimpleAddress(
 190             IP_ADDRESS_PREFIX_WITH_IPV6_TEST);
 191     private static final Long SERVICE_PATH_ID_TEST = 2121L;
 192
 193     /**
 194      * Tests {@link LispAddressUtil#addressTypeFromSimpleAddress} and {@link
 195      * LispAddressUtil#addressFromSimpleAddress} methods
 196      * with ipAddress.
 197      */
 198     @Test
 199     public void addressFromSimpleAddressTest_asAnyIpAddress() {
 200         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromSimpleAddress(
 201                 SIMPLE_ADDRESS_IPV4_TEST);
 202         assertEquals(Ipv4BinaryAfi.class, addressClass);
 203
 204         final Address address = LispAddressUtil.addressFromSimpleAddress(SIMPLE_ADDRESS_IPV4_TEST);
 205         assertTrue(address instanceof Ipv4Binary);
 206     }
 207
 208     /**
 209      * Tests {@link LispAddressUtil#addressTypeFromSimpleAddress} and {@link
 210      * LispAddressUtil#addressFromSimpleAddress} methods
 211      * with ipPrefix.
 212      */
 213     @Test
 214     public void addressFromSimpleAddressTest_asIpPrefix() {
 215         final SimpleAddress simpleAddress = new SimpleAddress(new IpPrefix(new Ipv4Prefix(
 216                 IPV4_ADDRESS_PREFIX_VALUE_TEST)));
 217         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromSimpleAddress(
 218                 simpleAddress);
 219         assertEquals(Ipv4PrefixAfi.class, addressClass);
 220
 221         final Address address = LispAddressUtil.addressFromSimpleAddress(simpleAddress);
 222         assertTrue(address instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address
 223                 .types.rev151105.lisp.address.address.Ipv4Prefix);
 224     }
 225
 226     /**
 227      * Tests {@link LispAddressUtil#addressTypeFromSimpleAddress} and {@link
 228      * LispAddressUtil#addressFromSimpleAddress} methods
 229      * with mac address.
 230      */
 231     @Test
 232     public void addressFromSimpleAddressTest_asMacAddress() {
 233         final SimpleAddress simpleAddress = new SimpleAddress(new MacAddress(MAC_ADDRESS_VALUE_TEST));
 234         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromSimpleAddress(
 235                 simpleAddress);
 236         assertEquals(MacAfi.class, addressClass);
 237
 238         final Address address = LispAddressUtil.addressFromSimpleAddress(simpleAddress);
 239         assertTrue(address instanceof Mac);
 240     }
 241
 242     /**
 243      * Tests {@link LispAddressUtil#addressTypeFromSimpleAddress} and {@link
 244      * LispAddressUtil#addressFromSimpleAddress} methods
 245      * with general address.
 246      */
 247     @Test
 248     public void addressFromSimpleAddressTest_asAddress() {
 249         final SimpleAddress simpleAddress = new SimpleAddress(DUMMY_CHARACTER_ARRAY_TEST);
 250         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromSimpleAddress(
 251                 simpleAddress);
 252         assertEquals(DistinguishedNameAfi.class, addressClass);
 253
 254         final Address address = LispAddressUtil.addressFromSimpleAddress(simpleAddress);
 255         assertTrue(address instanceof DistinguishedName);
 256     }
 257
 258     /**
 259      * Tests {@link LispAddressUtil#addressTypeFromSimpleAddress} and {@link
 260      * LispAddressUtil#addressFromSimpleAddress} methods
 261      * with address as number.
 262      */
 263     @Test
 264     public void addressFromSimpleAddressTest_asNumber() {
 265         final SimpleAddress simpleAddress = new SimpleAddress(new AsNumber(NUMBER_TEST));
 266         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromSimpleAddress(
 267                 simpleAddress);
 268         assertEquals(AsNumberAfi.class, addressClass);
 269
 270         final Address address = LispAddressUtil.addressFromSimpleAddress(simpleAddress);
 271         assertTrue(address instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address
 272                 .types.rev151105.lisp.address.address.AsNumber);
 273     }
 274
 275     /**
 276      * Tests {@link LispAddressUtil#addressFromInet(InetAddress)} and {@link LispAddressUtil#addressTypeFromInet
 277      * (InetAddress)}
 278      * methods with ipv4 address.
 279      */
 280     @Test
 281     public void addressFromInet_ipv4() throws UnknownHostException {
 282         final InetAddress ipv4InetAddress = Inet4Address.getByAddress(IPV4_ADDRESS_BYTES_A_TEST);
 283         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromInet(ipv4InetAddress);
 284         assertEquals(Ipv4Afi.class, addressClass);
 285
 286         final Address address = LispAddressUtil.addressFromInet(ipv4InetAddress);
 287         assertTrue(address instanceof Ipv4);
 288         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4) address).getIpv4().getValue());
 289     }
 290
 291     /**
 292      * Tests {@link LispAddressUtil#addressFromInet(InetAddress)} and {@link LispAddressUtil#addressTypeFromInet
 293      * (InetAddress)}
 294      * methods with ipv6 address.
 295      */
 296     @Test
 297     public void addressFromInet_ipv6() throws UnknownHostException {
 298         final InetAddress ipv6InetAddress = Inet6Address.getByAddress(IPV6_ADDRESS_BYTES_A_TEST);
 299         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromInet(ipv6InetAddress);
 300         assertEquals(Ipv6Afi.class, addressClass);
 301
 302         final Address address = LispAddressUtil.addressFromInet(ipv6InetAddress);
 303         assertTrue(address instanceof Ipv6);
 304         assertEquals(IPV6_ADDRESS_VALUE_TEST, ((Ipv6) address).getIpv6().getValue());
 305     }
 306
 307     /**
 308      * Tests {@link LispAddressUtil#binaryAddressFromInet(InetAddress)} and
 309      * {@link LispAddressUtil#binaryAddressTypeFromInet(InetAddress)} methods with ipv4 address.
 310      */
 311     @Test
 312     public void binaryAddressFromInet_ipv4() throws UnknownHostException {
 313         final InetAddress ipv4InetAddress = Inet4Address.getByAddress(IPV4_ADDRESS_BYTES_A_TEST);
 314         Class<? extends LispAddressFamily> addressClass = LispAddressUtil.binaryAddressTypeFromInet(ipv4InetAddress);
 315         assertEquals(Ipv4BinaryAfi.class, addressClass);
 316
 317         final Address address = LispAddressUtil.binaryAddressFromInet(ipv4InetAddress);
 318         assertTrue(address instanceof Ipv4Binary);
 319         assertArrayEquals(IPV4_ADDRESS_BYTES_A_TEST, ((Ipv4Binary) address).getIpv4Binary().getValue());
 320     }
 321
 322     /**
 323      * Tests {@link LispAddressUtil#binaryAddressFromInet(InetAddress)} and
 324      * {@link LispAddressUtil#binaryAddressTypeFromInet(InetAddress)} methods with ipv6 address.
 325      */
 326     @Test
 327     public void binaryAddressFromInet_ipv6() throws UnknownHostException {
 328         final InetAddress ipv6InetAddress = Inet6Address.getByAddress(IPV6_ADDRESS_BYTES_A_TEST);
 329         Class<? extends LispAddressFamily> addressClass = LispAddressUtil.binaryAddressTypeFromInet(ipv6InetAddress);
 330         assertEquals(Ipv6BinaryAfi.class, addressClass);
 331
 332         final Address address = LispAddressUtil.binaryAddressFromInet(ipv6InetAddress);
 333         assertTrue(address instanceof Ipv6Binary);
 334         assertArrayEquals(IPV6_ADDRESS_BYTES_A_TEST, ((Ipv6Binary) address).getIpv6Binary().getValue());
 335     }
 336
 337     /**
 338      * Tests {@link LispAddressUtil#addressFromIpAddress(IpAddress)} and {@link
 339      * LispAddressUtil#addressTypeFromIpAddress(IpAddress)}
 340      * methods with ipv4 address.
 341      */
 342     @Test
 343     public void addressFromIpAddress_ipv4() {
 344         final IpAddress ipv4Address = new IpAddress(IPV4_ADDRESS_TEST);
 345         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromIpAddress(ipv4Address);
 346         assertEquals(Ipv4Afi.class, addressClass);
 347
 348         final Address address = LispAddressUtil.addressFromIpAddress(ipv4Address);
 349         assertTrue(address instanceof Ipv4);
 350         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4) address).getIpv4().getValue());
 351     }
 352
 353     /**
 354      * Tests {@link LispAddressUtil#addressFromIpAddress(IpAddress)} and {@link
 355      * LispAddressUtil#addressTypeFromIpAddress(IpAddress)}
 356      * methods with ipv6 address.
 357      */
 358     @Test
 359     public void addressFromIpAddress_ipv6() {
 360         final IpAddress ipv6Address = new IpAddress(new Ipv6Address(IPV6_ADDRESS_VALUE_TEST));
 361         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromIpAddress(ipv6Address);
 362         assertEquals(Ipv6Afi.class, addressClass);
 363
 364         final Address address = LispAddressUtil.addressFromIpAddress(ipv6Address);
 365         assertTrue(address instanceof Ipv6);
 366         assertEquals(IPV6_ADDRESS_VALUE_TEST, ((Ipv6) address).getIpv6().getValue());
 367     }
 368
 369     /**
 370      * Tests {@link LispAddressUtil#addressFromIpAddress(IpAddress)} and {@link
 371      * LispAddressUtil#addressTypeFromIpAddress(IpAddress)}
 372      * methods with null value instead off address.
 373      */
 374     @Test
 375     public void addressFromIpAddress_null() {
 376         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromIpAddress(null);
 377         assertNull(addressClass);
 378
 379         final Address address = LispAddressUtil.addressFromIpAddress(null);
 380         assertNull(address);
 381     }
 382
 383     /**
 384      * Tests {@link LispAddressUtil#binaryAddressFromIpAddress(IpAddress)} and {@link
 385      * LispAddressUtil#binaryAddressTypeFromIpAddress(IpAddress)}
 386      * methods with Ipv4Binary address.
 387      */
 388     @Test
 389     public void binaryAddressFromIpAddress_Ipv4Binary() {
 390         final IpAddress ipv4Address = new IpAddress(new Ipv4Address(IPV4_ADDRESS_VALUE_TEST));
 391         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil
 392                 .binaryAddressTypeFromIpAddress(ipv4Address);
 393         assertEquals(Ipv4BinaryAfi.class, addressClass);
 394
 395         final Address address = LispAddressUtil.binaryAddressFromIpAddress(ipv4Address);
 396         assertEquals(IPV4_BINARY, address);
 397     }
 398
 399     /**
 400      * Tests {@link LispAddressUtil#binaryAddressFromIpAddress(IpAddress)} and {@link
 401      * LispAddressUtil#binaryAddressTypeFromIpAddress(IpAddress)}
 402      * methods with Ipv6Binary address.
 403      */
 404     @Test
 405     public void binaryAddressFromIpAddress_Ipv6Binary() {
 406         final IpAddress ipv6Address = new IpAddress(new Ipv6Address(IPV6_ADDRESS_VALUE_TEST));
 407         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil
 408                 .binaryAddressTypeFromIpAddress(ipv6Address);
 409         assertEquals(Ipv6BinaryAfi.class, addressClass);
 410
 411         final Address address = LispAddressUtil.binaryAddressFromIpAddress(ipv6Address);
 412         assertEquals(IPV6_BINARY, address);
 413     }
 414
 415     /**
 416      * Tests {@link LispAddressUtil#binaryAddressFromIpAddress(IpAddress)} and {@link
 417      * LispAddressUtil#binaryAddressTypeFromIpAddress(IpAddress)}
 418      * methods with Ipv6Binary address.
 419      */
 420     @Test
 421     public void binaryAddressFromIpAddress_null() {
 422         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.binaryAddressTypeFromIpAddress(null);
 423         assertNull(addressClass);
 424
 425         final Address address = LispAddressUtil.binaryAddressFromIpAddress(null);
 426         assertNull(address);
 427     }
 428
 429     /**
 430      * Tests {@link LispAddressUtil#addressFromIpPrefix(IpPrefix)} and {@link
 431      * LispAddressUtil#addressTypeFromIpPrefix(IpPrefix)}
 432      * methods with ipv4 address.
 433      */
 434     @Test
 435     public void addressFromIpPrefix_ipv4() {
 436         IpPrefix ipv4Prefix = new IpPrefix(new Ipv4Prefix(IPV4_ADDRESS_PREFIX_VALUE_TEST));
 437         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromIpPrefix(ipv4Prefix);
 438         assertEquals(Ipv4PrefixAfi.class, addressClass);
 439
 440         final Address address = LispAddressUtil.addressFromIpPrefix(ipv4Prefix);
 441         assertTrue(address instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address
 442                 .types.rev151105.lisp.address.address.Ipv4Prefix);
 443         assertEquals(IPV4_ADDRESS_PREFIX_VALUE_TEST, ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf
 444                 .lisp.address.types.rev151105.lisp.address.address.Ipv4Prefix) address).getIpv4Prefix().getValue());
 445     }
 446
 447     /**
 448      * Tests {@link LispAddressUtil#addressFromIpPrefix(IpPrefix)} and {@link
 449      * LispAddressUtil#addressTypeFromIpPrefix(IpPrefix)}
 450      * methods with ipv6 address.
 451      */
 452     @Test
 453     public void addressFromIpPrefix_ipv6() {
 454         IpPrefix ipv6Address = new IpPrefix(new Ipv6Prefix(IPV6_ADDRESS_PREFIX_VALUE_TEST));
 455         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromIpPrefix(ipv6Address);
 456         assertEquals(Ipv6PrefixAfi.class, addressClass);
 457
 458         final Address address = LispAddressUtil.addressFromIpPrefix(ipv6Address);
 459         assertTrue(address instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address
 460                 .types.rev151105.lisp.address.address.Ipv6Prefix);
 461         assertEquals(IPV6_ADDRESS_PREFIX_VALUE_TEST,
 462                 ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp
 463                         .address.address.Ipv6Prefix) address).getIpv6Prefix().getValue());
 464     }
 465
 466     /**
 467      * Tests {@link LispAddressUtil#addressFromIpPrefix(IpPrefix)} and {@link LispAddressUtil#addressTypeFromIpPrefix
 468      * (IpPrefix)}
 469      * methods with null value instead off address.
 470      */
 471     @Test
 472     public void addressFromIpPrefix_null() {
 473         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromIpPrefix(null);
 474         assertNull(addressClass);
 475
 476         final Address address = LispAddressUtil.addressFromIpPrefix(null);
 477         assertNull(address);
 478     }
 479
 480     /**
 481      * Tests {@link LispAddressUtil#addressFromMacAddress(MacAddress)} methods with mac address.
 482      */
 483     @Test
 484     public void addressFromMacAddress_mac() {
 485         final Address address = LispAddressUtil.addressFromMacAddress(new MacAddress(MAC_ADDRESS_VALUE_TEST));
 486         assertTrue(address instanceof Mac);
 487         assertEquals(MAC_ADDRESS_VALUE_TEST, ((Mac) address).getMac().getValue());
 488     }
 489
 490     /**
 491      * Tests {@link LispAddressUtil#addressFromMacAddress(MacAddress)} methods with null instead of address.
 492      */
 493     @Test
 494     public void addressFromMacAddress_null() {
 495         final Address address = LispAddressUtil.addressFromMacAddress(null);
 496         assertNull(address);
 497     }
 498
 499
 500     /**
 501      * Test {@link LispAddressUtil#addressFromServicePath(ServicePath)} method with concrete servicePath.
 502      */
 503     @Test
 504     public void addressFromServicePathTest_withServicePath() {
 505         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address
 506                 .address.service.path.ServicePathBuilder servicePathBuilder = new org.opendaylight.yang.gen.v1.urn.ietf
 507                 .params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address
 508                 .address.service.path.ServicePathBuilder();
 509         servicePathBuilder.setServiceIndex(SERVICE_INDEX_TEST);
 510         servicePathBuilder.setServicePathId(new ServicePathIdType(DUMMY_SERVICE_PATH_ID_TYPE));
 511
 512         ServicePath expectedAddress = servicePathBuilder.build();
 513         final Address testedAddress = LispAddressUtil.addressFromServicePath(expectedAddress);
 514         assertTrue(testedAddress instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address
 515                 .types.rev151105.lisp.address.address.ServicePath);
 516         assertEquals(expectedAddress, ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address
 517                 .types.rev151105.lisp.address.address.ServicePath) testedAddress).getServicePath());
 518     }
 519
 520     /**
 521      * Test {@link LispAddressUtil#addressFromServicePath(ServicePath)} method with null value.
 522      */
 523     @Test
 524     public void addressFromServicePathTest_withNull() {
 525         final Address testedAddress = LispAddressUtil.addressFromServicePath(null);
 526         assertNull(testedAddress);
 527     }
 528
 529     /**
 530      * Test {@link LispAddressUtil#addressFromDistinguishedName(DistinguishedNameType)} method with distinguished name.
 531      */
 532     @Test
 533     public void addressFromDistinguishedNameTest_withDistinguishedName() {
 534         final DistinguishedNameType distinguishedNameType = new DistinguishedNameType(
 535                 DISTINGUISHED_NAME_TYPE_VALUE_TEST);
 536         final Address testedAddress = LispAddressUtil.addressFromDistinguishedName(distinguishedNameType);
 537
 538         assertTrue(testedAddress instanceof DistinguishedName);
 539         assertEquals(distinguishedNameType, ((DistinguishedName) testedAddress).getDistinguishedName());
 540     }
 541
 542     /**
 543      * Test {@link LispAddressUtil#addressFromDistinguishedName(DistinguishedNameType)} method with null value.
 544      */
 545     @Test
 546     public void addressFromDistinguishedNameTest_withNull() {
 547         final Address testedAddress = LispAddressUtil.addressFromDistinguishedName(null);
 548         assertNull(testedAddress);
 549     }
 550
 551     /**
 552      * Test {@link LispAddressUtil#addressFromAsNumber(AsNumber)} method with as number value.
 553      */
 554     @Test
 555     public void addressFromAsNumberTest_withAdNumber() {
 556         final AsNumber expectedAddress = new AsNumber(AS_NUMBER_TEST);
 557         final Address testedAddress = LispAddressUtil.addressFromAsNumber(expectedAddress);
 558         assertTrue(testedAddress instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp
 559                 .address.types.rev151105.lisp.address.address.AsNumber);
 560         assertEquals(expectedAddress, ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp
 561                 .address.types.rev151105.lisp.address.address.AsNumber) testedAddress).getAsNumber());
 562     }
 563
 564     /**
 565      * Test {@link LispAddressUtil#addressFromAsNumber(AsNumber)} method with null instead of value.
 566      */
 567     @Test
 568     public void addressFromAsNumberTest_withNull() {
 569         final Address testedAddress = LispAddressUtil.addressFromAsNumber(null);
 570         assertNull(testedAddress);
 571     }
 572
 573
 574     /**
 575      * Tests:
 576      * - {@link LispAddressUtil#toRloc(InetAddress)}
 577      * - {@link LispAddressUtil#toRloc(Ipv4Address)}
 578      * - {@link LispAddressUtil#toRloc(Ipv6Address)}
 579      * - {@link LispAddressUtil#toRloc(SimpleAddress)}
 580      * methods.
 581      */
 582     @Test
 583     public void toRloc() throws UnknownHostException {
 584         InetAddress ipv4AddressInet = Inet4Address.getByAddress(IPV4_ADDRESS_BYTES_A_TEST);
 585         final Rloc rlocFromInetAddress = LispAddressUtil.toRloc(ipv4AddressInet);
 586         assertEquals(Ipv4BinaryAfi.class, rlocFromInetAddress.getAddressType());
 587         assertEquals(IPV4_ADDRESS_BINARY_TEST, ((Ipv4Binary) rlocFromInetAddress.getAddress()).getIpv4Binary());
 588
 589         final Rloc rlocFromIpv4Address = LispAddressUtil.toRloc(IPV4_ADDRESS_TEST);
 590         assertEquals(Ipv4Afi.class, rlocFromIpv4Address.getAddressType());
 591         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4) rlocFromIpv4Address.getAddress()).getIpv4().getValue());
 592
 593
 594         final Rloc rlocFromIpv6Address = LispAddressUtil.toRloc(IPV6_ADDRESS_TEST);
 595         assertEquals(Ipv6Afi.class, rlocFromIpv6Address.getAddressType());
 596         assertEquals(IPV6_ADDRESS_VALUE_TEST, ((Ipv6) rlocFromIpv6Address.getAddress()).getIpv6().getValue());
 597
 598         final Rloc rlocFromSimpleAddress = LispAddressUtil.toRloc(SIMPLE_ADDRESS_IPV4_TEST);
 599         assertEquals(Ipv4BinaryAfi.class, rlocFromSimpleAddress.getAddressType());
 600         assertEquals(IPV4_ADDRESS_BINARY_TEST, ((Ipv4Binary) rlocFromSimpleAddress.getAddress()).getIpv4Binary());
 601     }
 602
 603     /**
 604      * Test {@link LispAddressUtil#asIpv4Rloc(String)} method with ipv4 or ipv6.
 605      * Test {@link LispAddressUtil#asIpv6Rloc(String)} method with ipv4 or ipv6.
 606      */
 607     @Test
 608     public void asIpvRloc() {
 609         final Rloc rlocFromIpV4 = LispAddressUtil.asIpv4Rloc(IPV4_ADDRESS_VALUE_TEST);
 610         assertEquals(Ipv4BinaryAfi.class, rlocFromIpV4.getAddressType());
 611         assertEquals(IPV4_ADDRESS_BINARY_TEST, ((Ipv4Binary) rlocFromIpV4.getAddress()).getIpv4Binary());
 612
 613         final Rloc rlocFromIpV6 = LispAddressUtil.asIpv6Rloc(IPV6_ADDRESS_VALUE_TEST);
 614         assertEquals(Ipv6BinaryAfi.class, rlocFromIpV6.getAddressType());
 615         assertEquals(IPV6_ADDRESS_BINARY_TEST, ((Ipv6Binary) rlocFromIpV6.getAddress()).getIpv6Binary());
 616     }
 617
 618     /**
 619      * Test
 620      * - {@link LispAddressUtil#toEid(Ipv6Address, InstanceIdType)}
 621      * - {@link LispAddressUtil#asIpv6PrefixEid(String)}
 622      * - {@link LispAddressUtil#asIpv6PrefixEid(Eid, Inet6Address, short)}
 623      * - {@link LispAddressUtil#asIpv6PrefixEid(Ipv6Address, InstanceIdType)}
 624      * methods.
 625      */
 626     @Test
 627     public void toEid_ipv6Prefix() throws UnknownHostException {
 628         final Inet6Address inet6Address = (Inet6Address) Inet6Address.getByName(IPV6_ADDRESS_VALUE_TEST);
 629
 630         Eid eidFromIpv6Prefix = LispAddressUtil.toEid(IPV6_ADDRESS_PREFIX_TEST, INSTANCE_ID_TYPE_TEST);
 631         verifyToEidWithIpv6Prefix(eidFromIpv6Prefix, true, MASK_OK_TEST, Ipv6PrefixAfi.class);
 632
 633         eidFromIpv6Prefix = LispAddressUtil.asIpv6PrefixEid(IPV6_ADDRESS_PREFIX_VALUE_TEST);
 634         verifyToEidWithIpv6Prefix(eidFromIpv6Prefix, false, MASK_OK_TEST, Ipv6PrefixAfi.class);
 635
 636         eidFromIpv6Prefix = LispAddressUtil.asIpv6PrefixEid(IPV6_ADDRESS_PREFIX_BINARY_EID, inet6Address,
 637                 MASK_OK_DEFAULT_IPV6_TEST);
 638         verifyToEidWithIpv6Prefix(eidFromIpv6Prefix, true, MASK_OK_DEFAULT_IPV6_TEST, Ipv6PrefixAfi.class);
 639
 640         eidFromIpv6Prefix = LispAddressUtil.asIpv6PrefixEid(IPV6_ADDRESS_TEST, INSTANCE_ID_TYPE_TEST);
 641         verifyToEidWithIpv6Prefix(eidFromIpv6Prefix, true, MASK_OK_DEFAULT_IPV6_TEST, Ipv6PrefixAfi.class);
 642     }
 643
 644     /**
 645      * Test
 646      * - {@link LispAddressUtil#toEid(MacAddress, InstanceIdType)}
 647      * - {@link LispAddressUtil#asMacEid(String)}
 648      * - {@link LispAddressUtil#asMacEid(String, long)}
 649      * methods.
 650      */
 651     @Test
 652     public void toEid_mac() {
 653         Eid eidFromMac = LispAddressUtil.toEid(MAC_ADDRESS_TEST, INSTANCE_ID_TYPE_TEST);
 654         verifyToEidWithMacAddress(eidFromMac, true);
 655
 656         eidFromMac = LispAddressUtil.asMacEid(MAC_ADDRESS_VALUE_TEST);
 657         verifyToEidWithMacAddress(eidFromMac, false);
 658
 659         eidFromMac = LispAddressUtil.asMacEid(MAC_ADDRESS_VALUE_TEST, INSTANCE_ID_TYPE_VALUE_TEST);
 660         verifyToEidWithMacAddress(eidFromMac, true);
 661     }
 662
 663     /**
 664      * Test
 665      * - {@link LispAddressUtil#toEid(Ipv6Address, InstanceIdType)}
 666      * - {@link LispAddressUtil#toEid(Ipv6AddressBinary, InstanceIdType)}
 667      * - {@link LispAddressUtil#asIpv6Eid(String)}
 668      * - {@link LispAddressUtil#asIpv6Eid(String, long)}
 669      * methods.
 670      */
 671     @Test
 672     public void toEid_ipv6() {
 673         Eid eidFromIpv6 = LispAddressUtil.toEid(IPV6_ADDRESS_TEST, INSTANCE_ID_TYPE_TEST);
 674         verifyToEidWithIpv6(eidFromIpv6, true);
 675
 676         eidFromIpv6 = LispAddressUtil.toEid(IPV6_ADDRESS_BINARY_TEST, INSTANCE_ID_TYPE_TEST);
 677         verifyToEidWithIpv6Binary(eidFromIpv6, true);
 678
 679         eidFromIpv6 = LispAddressUtil.asIpv6Eid(IPV6_ADDRESS_VALUE_TEST);
 680         verifyToEidWithIpv6Binary(eidFromIpv6, false);
 681
 682         eidFromIpv6 = LispAddressUtil.asIpv6Eid(IPV6_ADDRESS_VALUE_TEST, INSTANCE_ID_TYPE_VALUE_TEST);
 683         verifyToEidWithIpv6Binary(eidFromIpv6, true);
 684     }
 685
 686     /**
 687      * Test
 688      * - {@link LispAddressUtil#toEid(Ipv4Prefix, InstanceIdType)}
 689      * - {@link LispAddressUtil#asIpv4PrefixEid(String)}
 690      * - {@link LispAddressUtil#asIpv4PrefixEid(Eid, Inet4Address, short)}
 691      * - {@link LispAddressUtil#asIpv4PrefixEid(Ipv4Address, InstanceIdType)}  }
 692      * methods.
 693      */
 694     @Test
 695     public void toEid_ipv4Prefix() throws UnknownHostException {
 696         final Inet4Address inet4Address = (Inet4Address) Inet4Address.getByName(IPV4_ADDRESS_VALUE_TEST);
 697
 698         Eid eidFromIpv4Prefix = LispAddressUtil.toEid(IPV4_ADDRESS_PREFIX_TEST, INSTANCE_ID_TYPE_TEST);
 699         verifyToEidWithIpv4Prefix(eidFromIpv4Prefix, true, MASK_OK_TEST, Ipv4PrefixAfi.class);
 700
 701         eidFromIpv4Prefix  = LispAddressUtil.asIpv4PrefixEid(IPV4_ADDRESS_PREFIX_VALUE_TEST);
 702         verifyToEidWithIpv4Prefix(eidFromIpv4Prefix, false, MASK_OK_TEST, Ipv4PrefixAfi.class);
 703
 704         eidFromIpv4Prefix = LispAddressUtil.asIpv4PrefixEid(IPV4_ADDRESS_PREFIX_BINARY_EID, inet4Address,
 705                 MASK_OK_DEFAULT_IPV4_TEST);
 706         verifyToEidWithIpv4Prefix(eidFromIpv4Prefix, true, MASK_OK_DEFAULT_IPV4_TEST, Ipv4PrefixAfi.class);
 707
 708         eidFromIpv4Prefix = LispAddressUtil.asIpv4PrefixEid(IPV4_ADDRESS_TEST, INSTANCE_ID_TYPE_TEST);
 709         verifyToEidWithIpv4Prefix(eidFromIpv4Prefix, true, MASK_OK_DEFAULT_IPV4_TEST, Ipv4PrefixAfi.class);
 710     }
 711
 712     /**
 713      * Test
 714      * - {@link LispAddressUtil#toEid(Ipv4PrefixBinary, InstanceIdType)}
 715      * - {@link LispAddressUtil#asIpv4PrefixBinaryEid(String)}
 716      * - {@link LispAddressUtil#asIpv4PrefixBinaryEid(String, InstanceIdType)}
 717      * - {@link LispAddressUtil#asIpv4PrefixBinaryEid(Eid, byte[], short)}
 718      * methods.
 719      */
 720     @Test
 721     public void toEid_ipv4PrefixBinary() {
 722         Eid eidFromIpv4PrefixBinary = LispAddressUtil.toEid(IPV4_ADDRESS_PREFIX_BINARY, INSTANCE_ID_TYPE_TEST);
 723         verifyToEidWithIpv4PrefixBinary(eidFromIpv4PrefixBinary, true, MASK_OK_TEST, Ipv4PrefixBinaryAfi.class);
 724
 725         eidFromIpv4PrefixBinary = LispAddressUtil.asIpv4PrefixBinaryEid(IPV4_ADDRESS_PREFIX_VALUE_TEST);
 726         verifyToEidWithIpv4PrefixBinary(eidFromIpv4PrefixBinary, false, MASK_OK_TEST, Ipv4PrefixBinaryAfi.class);
 727
 728         eidFromIpv4PrefixBinary = LispAddressUtil.asIpv4PrefixBinaryEid(IPV4_ADDRESS_PREFIX_VALUE_TEST,
 729                 INSTANCE_ID_TYPE_TEST);
 730         verifyToEidWithIpv4PrefixBinary(eidFromIpv4PrefixBinary, true, MASK_OK_TEST, Ipv4PrefixBinaryAfi.class);
 731
 732         eidFromIpv4PrefixBinary = LispAddressUtil.asIpv4PrefixBinaryEid(IPV4_ADDRESS_PREFIX_BINARY_EID,
 733                 IPV4_ADDRESS_BYTES_A_TEST, MASK_OK_TEST);
 734         verifyToEidWithIpv4PrefixBinary(eidFromIpv4PrefixBinary, true, MASK_OK_TEST, Ipv4PrefixBinaryAfi.class);
 735     }
 736
 737     /**
 738      * Test
 739      * - {@link LispAddressUtil#toEid(Ipv6PrefixBinary, InstanceIdType)}
 740      * - {@link LispAddressUtil#asIpv6PrefixBinaryEid(String)}
 741      * - {@link LispAddressUtil#asIpv6PrefixBinaryEid(String, InstanceIdType)}
 742      * - {@link LispAddressUtil#asIpv6PrefixBinaryEid(Eid, byte[], short)}
 743      * method.
 744      */
 745     @Test
 746     public void toEid_ipv6PrefixBinary() {
 747         Eid eidFromIpv6PrefixBinary = LispAddressUtil.toEid(IPV6_ADDRESS_PREFIX_BINARY, INSTANCE_ID_TYPE_TEST);
 748         verifyToEidWithIpv6PrefixBinary(eidFromIpv6PrefixBinary, true, MASK_OK_TEST, Ipv6PrefixBinaryAfi.class);
 749
 750         eidFromIpv6PrefixBinary = LispAddressUtil.asIpv6PrefixBinaryEid(IPV6_ADDRESS_PREFIX_VALUE_TEST);
 751         verifyToEidWithIpv6PrefixBinary(eidFromIpv6PrefixBinary, false, MASK_OK_TEST, Ipv6PrefixBinaryAfi.class);
 752
 753         eidFromIpv6PrefixBinary = LispAddressUtil.asIpv6PrefixBinaryEid(IPV6_ADDRESS_PREFIX_VALUE_TEST,
 754                 INSTANCE_ID_TYPE_TEST);
 755         verifyToEidWithIpv6PrefixBinary(eidFromIpv6PrefixBinary, true, MASK_OK_TEST, Ipv6PrefixBinaryAfi.class);
 756
 757         eidFromIpv6PrefixBinary = LispAddressUtil.asIpv6PrefixBinaryEid(IPV6_ADDRESS_PREFIX_BINARY_EID,
 758                 IPV6_ADDRESS_BYTES_A_TEST, MASK_OK_TEST);
 759         verifyToEidWithIpv6PrefixBinary(eidFromIpv6PrefixBinary, true, MASK_OK_TEST, Ipv6PrefixBinaryAfi.class);
 760     }
 761
 762     /**
 763      * Test
 764      * - {@link LispAddressUtil#toEid(Ipv4Address, InstanceIdType)}
 765      * - {@link LispAddressUtil#toEid(Ipv4AddressBinary, InstanceIdType)}
 766      * - {@link LispAddressUtil#asIpv4Eid(String)}
 767      * - {@link LispAddressUtil#asIpv4Eid(String, long)}
 768      * methods.
 769      */
 770     @Test
 771     public void toEid_ipv4() {
 772         Eid eidFromIpv4 = LispAddressUtil.toEid(IPV4_ADDRESS_TEST, INSTANCE_ID_TYPE_TEST);
 773         verifyToEidWithIpv4(eidFromIpv4, true);
 774
 775         eidFromIpv4 = LispAddressUtil.toEid(IPV4_ADDRESS_BINARY_TEST, INSTANCE_ID_TYPE_TEST);
 776         verifyToEidWithIpv4Binary(eidFromIpv4, true);
 777
 778         eidFromIpv4 = LispAddressUtil.asIpv4Eid(IPV4_ADDRESS_VALUE_TEST);
 779         verifyToEidWithIpv4Binary(eidFromIpv4, false);
 780
 781         eidFromIpv4 = LispAddressUtil.asIpv4Eid(IPV4_ADDRESS_VALUE_TEST, INSTANCE_ID_TYPE_VALUE_TEST);
 782         verifyToEidWithIpv4Binary(eidFromIpv4, true);
 783     }
 784
 785     /**
 786      * Test
 787      * - {@link LispAddressUtil#toEid(IpPrefix, InstanceIdType)}
 788      * method.
 789      */
 790     @Test
 791     public void toEid_ipPrefix() {
 792         final Eid eidFromIpPrefix = LispAddressUtil.toEid(IP_ADDRESS_PREFIX_WITH_IPV4_TEST, INSTANCE_ID_TYPE_TEST);
 793         verifyToEidWithIpv4Prefix(eidFromIpPrefix, true, MASK_OK_TEST, Ipv4PrefixAfi.class);
 794     }
 795
 796     /**
 797      * Test
 798      * - {@link LispAddressUtil#toEid(DistinguishedNameType, InstanceIdType)}
 799      * - {@link LispAddressUtil#asDistinguishedNameEid(String)}
 800      * - {@link LispAddressUtil#asDistinguishedNameEid(String, long)}
 801      * methods with various input.
 802      */
 803     @Test
 804     public void toEid_distinguishedName() {
 805         Eid eidFromDistinguishedName = LispAddressUtil.toEid(DISTINGUISHED_NAME_TYPE_TEST, INSTANCE_ID_TYPE_TEST);
 806         verifyToEidWithDistinguishedName(eidFromDistinguishedName, true);
 807
 808         eidFromDistinguishedName = LispAddressUtil.asDistinguishedNameEid(DISTINGUISHED_NAME_TYPE_VALUE_TEST);
 809         verifyToEidWithDistinguishedName(eidFromDistinguishedName, false);
 810
 811         eidFromDistinguishedName = LispAddressUtil.asDistinguishedNameEid(
 812                 DISTINGUISHED_NAME_TYPE_VALUE_WITH_MAC_TEST, INSTANCE_ID_TYPE_VALUE_TEST);
 813         verifyToEidWithMacAddress(eidFromDistinguishedName, true);
 814     }
 815
 816     private void verifyToEidWithIpv6Prefix(final Eid eidFromIpv6Prefix, final boolean isVniChecked, short
 817             expectedMask, final Class<? extends org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp
 818             .address.types.rev151105.LispAddressFamily> addressType) {
 819         assertEquals(addressType, eidFromIpv6Prefix.getAddressType());
 820         if (isVniChecked) {
 821             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv6Prefix.getVirtualNetworkId());
 822         }
 823         assertEquals(IPV6_ADDRESS_VALUE_TEST + "/" + expectedMask, ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml
 824                 .ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6Prefix) eidFromIpv6Prefix
 825                 .getAddress()).getIpv6Prefix().getValue());
 826     }
 827
 828     private void verifyToEidWithIpv6PrefixBinary(final Eid eidFromIpv6PrefixBinary, final boolean isVniChecked, short
 829             expectedMask, final Class<? extends org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp
 830             .address.types.rev151105.LispAddressFamily> addressType) {
 831         assertEquals(addressType, eidFromIpv6PrefixBinary.getAddressType());
 832         if (isVniChecked) {
 833             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv6PrefixBinary.getVirtualNetworkId());
 834         }
 835         assertArrayEquals(IPV6_ADDRESS_BYTES_A_TEST, ((Ipv6PrefixBinary) eidFromIpv6PrefixBinary
 836                 .getAddress()).getIpv6AddressBinary().getValue());
 837         assertEquals(expectedMask,
 838                 (short) ((Ipv6PrefixBinary) eidFromIpv6PrefixBinary.getAddress()).getIpv6MaskLength());
 839     }
 840
 841     private void verifyToEidWithIpv4(final Eid eidFromIpv4, final boolean isVniChecked) {
 842         assertEquals(Ipv4Afi.class, eidFromIpv4.getAddressType());
 843         if (isVniChecked) {
 844             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv4.getVirtualNetworkId());
 845         }
 846         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4) eidFromIpv4.getAddress()).getIpv4().getValue());
 847     }
 848
 849     private void verifyToRlocWithIpv4(final Rloc rlocFromIpv4, final boolean isVniChecked) {
 850         assertEquals(Ipv4Afi.class, rlocFromIpv4.getAddressType());
 851         if (isVniChecked) {
 852             assertEquals(INSTANCE_ID_TYPE_TEST, rlocFromIpv4.getVirtualNetworkId());
 853         }
 854         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4) rlocFromIpv4.getAddress()).getIpv4().getValue());
 855     }
 856
 857     private void verifyToEidWithIpv4Binary(final Eid eidFromIpv4, final boolean isVniChecked) {
 858         assertEquals(Ipv4BinaryAfi.class, eidFromIpv4.getAddressType());
 859         if (isVniChecked) {
 860             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv4.getVirtualNetworkId());
 861         }
 862         assertArrayEquals(IPV4_ADDRESS_BYTES_A_TEST,
 863                 ((Ipv4Binary) eidFromIpv4.getAddress()).getIpv4Binary().getValue());
 864     }
 865
 866     private void verifyToRlocWithIpv4Binary(final Rloc rlocFromIpv4, final boolean isVniChecked) {
 867         assertEquals(Ipv4BinaryAfi.class, rlocFromIpv4.getAddressType());
 868         if (isVniChecked) {
 869             assertEquals(INSTANCE_ID_TYPE_TEST, rlocFromIpv4.getVirtualNetworkId());
 870         }
 871         assertArrayEquals(IPV4_ADDRESS_BYTES_A_TEST,
 872                 ((Ipv4Binary) rlocFromIpv4.getAddress()).getIpv4Binary().getValue());
 873     }
 874
 875     private void verifyToEidWithIpv6(final Eid eidFromIpv6, final boolean isVniChecked) {
 876         assertEquals(Ipv6Afi.class, eidFromIpv6.getAddressType());
 877         if (isVniChecked) {
 878             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv6.getVirtualNetworkId());
 879         }
 880         assertEquals(IPV6_ADDRESS_VALUE_TEST, ((Ipv6) eidFromIpv6.getAddress()).getIpv6().getValue());
 881     }
 882
 883     private void verifyToEidWithIpv4Prefix(final Eid eidFromIpv4Prefix, final boolean isVniChecked, short
 884             expectedMask, Class<? extends org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address
 885             .types.rev151105.LispAddressFamily>  addressType) {
 886         assertEquals(addressType, eidFromIpv4Prefix.getAddressType());
 887         if (isVniChecked) {
 888             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv4Prefix.getVirtualNetworkId());
 889         }
 890         assertEquals(IPV4_ADDRESS_VALUE_TEST + "/" + expectedMask, ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns
 891                 .yang.ietf
 892                 .lisp.address.types.rev151105.lisp.address.address.Ipv4Prefix) eidFromIpv4Prefix.getAddress())
 893                 .getIpv4Prefix().getValue());
 894     }
 895
 896     private void verifyToEidWithIpv4PrefixBinary(final Eid eidFromIpv4PrefixBinary, final boolean isVniChecked, short
 897             expectedMask, Class<? extends org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address
 898             .types.rev151105.LispAddressFamily>  addressType) {
 899         assertEquals(addressType, eidFromIpv4PrefixBinary.getAddressType());
 900         if (isVniChecked) {
 901             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv4PrefixBinary.getVirtualNetworkId());
 902         }
 903         assertArrayEquals(IPV4_ADDRESS_BYTES_A_TEST,
 904                 ((Ipv4PrefixBinary) eidFromIpv4PrefixBinary.getAddress()).getIpv4AddressBinary().getValue());
 905         assertEquals(expectedMask,
 906                 (short) ((Ipv4PrefixBinary) eidFromIpv4PrefixBinary.getAddress()).getIpv4MaskLength());
 907     }
 908
 909     private void verifyToEidWithIpv6Binary(final Eid eidFromIpv6, final boolean isVniChecked) {
 910         assertEquals(Ipv6BinaryAfi.class, eidFromIpv6.getAddressType());
 911         if (isVniChecked) {
 912             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv6.getVirtualNetworkId());
 913         }
 914         assertArrayEquals(IPV6_ADDRESS_BYTES_A_TEST,
 915                 ((Ipv6Binary) eidFromIpv6.getAddress()).getIpv6Binary().getValue());
 916     }
 917
 918     private void verifyToEidWithDistinguishedName(final Eid eidFromDistinguishedName, final boolean isVniChecked) {
 919         assertEquals(DistinguishedNameAfi.class, eidFromDistinguishedName.getAddressType());
 920         if (isVniChecked) {
 921             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromDistinguishedName.getVirtualNetworkId());
 922         }
 923         assertEquals(DISTINGUISHED_NAME_TYPE_TEST, ((DistinguishedName) eidFromDistinguishedName.getAddress())
 924                 .getDistinguishedName());
 925     }
 926
 927     private void verifyToEidWithMacAddress(final Eid eidFromMac, final boolean isVniChecked) {
 928         assertEquals(MacAfi.class, eidFromMac.getAddressType());
 929         if (isVniChecked) {
 930             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromMac.getVirtualNetworkId());
 931         }
 932         assertEquals(MAC_ADDRESS_VALUE_TEST, ((Mac) eidFromMac.getAddress()).getMac().getValue());
 933     }
 934
 935     /**
 936      * Tests {@link LispAddressUtil#asIpPrefix(String, int)} with ipv4 address and correct mask.
 937      */
 938     @Test
 939     public void asIpPrefix_ipv4() {
 940         final IpPrefix ipPrefix = LispAddressUtil.asIpPrefix(IPV4_ADDRESS_VALUE_TEST, MASK_OK_TEST);
 941         assertNotNull(ipPrefix);
 942         final Ipv4Prefix ipv4Prefix = ipPrefix.getIpv4Prefix();
 943         assertNotNull(ipv4Prefix);
 944         assertEquals(IPV4_ADDRESS_PREFIX_TEST, ipv4Prefix);
 945     }
 946
 947     /**
 948      * Tests {@link LispAddressUtil#asIpPrefix(String, int)} with ipv6 address and correct mask.
 949      */
 950     @Test
 951     public void asIpPrefix_ipv6() {
 952         final IpPrefix ipPrefix = LispAddressUtil.asIpPrefix(IPV6_ADDRESS_VALUE_TEST, MASK_OK_TEST);
 953         assertNotNull(ipPrefix);
 954         final Ipv6Prefix ipv6Prefix = ipPrefix.getIpv6Prefix();
 955         assertNotNull(ipv6Prefix);
 956         assertEquals(IPV6_ADDRESS_PREFIX_TEST, ipv6Prefix);
 957     }
 958
 959     /**
 960      * Tests {@link LispAddressUtil#asIpPrefix(String, int)} with incorrect ip address and correct mask.
 961      */
 962     @Test
 963     public void asIpPrefix_other() {
 964         final IpPrefix ipPrefix = LispAddressUtil.asIpPrefix(INCORRECT_IP_ADDRESS_TEST, MASK_OK_TEST);
 965         assertNull(ipPrefix);
 966     }
 967
 968     /**
 969      * Tests {@link LispAddressUtil#asBinaryEid(SimpleAddress, InstanceIdType)} method with ipv4Prefix.
 970      */
 971     @Test
 972     public void asBinaryEidTest_ipv4Prefix() {
 973         final Eid result = LispAddressUtil.asBinaryEid(SIMPLE_ADDRESS_IPV4_PREFIX_TEST, INSTANCE_ID_TYPE_TEST);
 974         assertEquals(IPV4_ADDRESS_PREFIX_BINARY_EID, result);
 975     }
 976
 977     /**
 978      * Tests {@link LispAddressUtil#asBinaryEid(SimpleAddress, InstanceIdType)} method with ipv6Prefix.
 979      */
 980     @Test
 981     public void asBinaryEidTest_ipv6Prefix() {
 982         final Eid result = LispAddressUtil.asBinaryEid(SIMPLE_ADDRESS_IPV6_PREFIX_TEST, INSTANCE_ID_TYPE_TEST);
 983         assertEquals(IPV6_ADDRESS_PREFIX_BINARY_EID, result);
 984     }
 985
 986     /**
 987      * Tests {@link LispAddressUtil#asBinaryEid(SimpleAddress, InstanceIdType)} method with ipv4.
 988      */
 989     @Test
 990     public void asBinaryEidTest_ipv4() {
 991         final Eid result = LispAddressUtil.asBinaryEid(SIMPLE_ADDRESS_IPV4_TEST, INSTANCE_ID_TYPE_TEST);
 992         assertEquals(IPV4_ADDRESS_BINARY_EID, result);
 993     }
 994
 995     /**
 996      * Tests {@link LispAddressUtil#asBinaryEid(SimpleAddress, InstanceIdType)} method with ipv6.
 997      */
 998     @Test
 999     public void asBinaryEidTest_ipv6() {
1000         final Eid result = LispAddressUtil.asBinaryEid(SIMPLE_ADDRESS_IPV6_TEST, INSTANCE_ID_TYPE_TEST);
1001         assertEquals(IPV6_ADDRESS_BINARY_EID, result);
1002     }
1003
1004     /**
1005      * Tests {@link LispAddressUtil#asBinaryEid(SimpleAddress, InstanceIdType)} method with mac.
1006      */
1007     @Test
1008     public void asBinaryEidTest_mac() {
1009         final Eid result = LispAddressUtil.asBinaryEid(SIMPLE_ADDRESS_MAC_TEST, INSTANCE_ID_TYPE_TEST);
1010         assertEquals(MAC_ADDRESS_EID, result);
1011     }
1012
1013     /**
1014      * Tests {@link LispAddressUtil#ipVersionFromString(String)} with ipv4.
1015      */
1016     @Test
1017     public void ipVersionFromString_ipv4() {
1018         final int addressType = LispAddressUtil.ipVersionFromString(IPV4_ADDRESS_VALUE_TEST);
1019         assertEquals(4, addressType);
1020     }
1021
1022     /**
1023      * Tests {@link LispAddressUtil#ipVersionFromString(String)} with ipv6.
1024      */
1025     @Test
1026     public void ipVersionFromString_ipv6() {
1027         final int addressType = LispAddressUtil.ipVersionFromString(IPV6_ADDRESS_VALUE_TEST);
1028         assertEquals(6, addressType);
1029     }
1030
1031     /**
1032      * Tests {@link LispAddressUtil#ipVersionFromString(String)} with incorrect ip address format.
1033      */
1034     @Test
1035     public void ipVersionFromString_other() {
1036         final int addressType = LispAddressUtil.ipVersionFromString(INCORRECT_IP_ADDRESS_TEST);
1037         assertEquals(0, addressType);
1038
1039     }
1040
1041     /**
1042      * Tests {@link LispAddressUtil#asKeyValueAddressEid(SimpleAddress, SimpleAddress)} method.
1043      */
1044     @Test
1045     public void asKeyValueAddressEid() {
1046         final Eid eid = LispAddressUtil.asKeyValueAddressEid(SIMPLE_ADDRESS_IPV4_TEST, SIMPLE_ADDRESS_MAC_TEST);
1047         verifyKeyValueAddress(eid, SIMPLE_ADDRESS_IPV4_TEST);
1048     }
1049
1050     /**
1051      * Tests {@link LispAddressUtil#asKeyValueAddressRloc(SimpleAddress, SimpleAddress)} method.
1052      */
1053     @Test
1054     public void asKeyValueAddressRloc() {
1055         final Rloc rloc = LispAddressUtil.asKeyValueAddressRloc(SIMPLE_ADDRESS_IPV4_TEST, SIMPLE_ADDRESS_MAC_TEST);
1056         verifyKeyValueAddress(rloc, SIMPLE_ADDRESS_IPV4_TEST);
1057     }
1058
1059     /**
1060      * Tests {@link LispAddressUtil#asKeyValueAddress(String, SimpleAddress)} method.
1061      */
1062     @Test
1063     public void asKeyValueAddress() {
1064         final Rloc rloc = LispAddressUtil.asKeyValueAddress(DISTINGUISHED_NAME_TYPE_VALUE_TEST,
1065                 SIMPLE_ADDRESS_MAC_TEST);
1066         verifyKeyValueAddress(rloc, SIMPLE_ADDRESS_DISTINGUISHED_TEST);
1067     }
1068
1069     private void verifyKeyValueAddress(final LispAddress lispAddress, final SimpleAddress keyValue) {
1070         assertEquals(KeyValueAddressLcaf.class, lispAddress.getAddressType());
1071         assertNull(lispAddress.getVirtualNetworkId());
1072         final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
1073                 .lisp.address.address.key.value.address.KeyValueAddress keyValueAddress =
1074                 ((KeyValueAddress) lispAddress.getAddress()).getKeyValueAddress();
1075         assertNotNull(keyValueAddress);
1076         assertEquals(keyValue, keyValueAddress.getKey());
1077         assertEquals(SIMPLE_ADDRESS_MAC_TEST, keyValueAddress.getValue());
1078     }
1079
1080     /**
1081      * Tests {@link LispAddressUtil#asSrcDst(String, String, int, int)} method.
1082      */
1083     @Test
1084     public void asSrcDst() {
1085         final SourceDestKey sourceDestKey = LispAddressUtil.asSrcDst(IPV4_ADDRESS_VALUE_TEST,
1086                 IPV6_ADDRESS_VALUE_TEST, MASK_OK_TEST, MASK_OK_TEST);
1087         assertNotNull(sourceDestKey);
1088         assertEquals(SIMPLE_ADDRESS_IPV4_PREFIX_TEST, sourceDestKey.getSource());
1089         assertEquals(SIMPLE_ADDRESS_IPV6_PREFIX_TEST, sourceDestKey.getDest());
1090     }
1091
1092     /**
1093      * Tests {@link LispAddressUtil#asSrcDstEid(String, String, int, int, int)} method.
1094      */
1095     @Test
1096     public void asSrcDstEid_addressesAsString() {
1097         final Eid srcDstEid = LispAddressUtil.asSrcDstEid(IPV4_ADDRESS_VALUE_TEST,
1098                 IPV6_ADDRESS_VALUE_TEST, MASK_OK_TEST, MASK_OK_TEST, INSTANCE_ID_TYPE_VALUE_SHORT_TEST);
1099         assertNotNull(srcDstEid);
1100         assertEquals(SourceDestKeyLcaf.class, srcDstEid.getAddressType());
1101         final SourceDestKey sourceDestKey = ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns
1102                 .yang.ietf.lisp.address.types.rev151105.lisp.address.address.SourceDestKey) srcDstEid.getAddress())
1103                 .getSourceDestKey();
1104         assertNotNull(sourceDestKey);
1105         assertEquals(SIMPLE_ADDRESS_IPV4_PREFIX_TEST, sourceDestKey.getSource());
1106         assertEquals(SIMPLE_ADDRESS_IPV6_PREFIX_TEST, sourceDestKey.getDest());
1107     }
1108
1109     /**
1110      * Tests {@link LispAddressUtil#asSrcDstEid(SourceDestKey, InstanceIdType)}  method.
1111      */
1112     @Test
1113     public void asSrcDstEid_addressesAsSrcDstKey() {
1114         final SourceDestKey expectedSourceDestKey = new SourceDestKeyBuilder().setSource(
1115                 SIMPLE_ADDRESS_IPV4_PREFIX_TEST).setDest(SIMPLE_ADDRESS_IPV6_PREFIX_TEST).build();
1116         final Eid srcDstEid = LispAddressUtil.asSrcDstEid(expectedSourceDestKey, INSTANCE_ID_TYPE_TEST);
1117         assertNotNull(srcDstEid);
1118         assertEquals(SourceDestKeyLcaf.class, srcDstEid.getAddressType());
1119         final SourceDestKey testedSourceDestKey = ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns
1120                 .yang.ietf.lisp.address.types.rev151105.lisp.address.address.SourceDestKey) srcDstEid.getAddress())
1121                 .getSourceDestKey();
1122         assertNotNull(testedSourceDestKey);
1123         assertEquals(SIMPLE_ADDRESS_IPV4_PREFIX_TEST, testedSourceDestKey.getSource());
1124         assertEquals(SIMPLE_ADDRESS_IPV6_PREFIX_TEST, testedSourceDestKey.getDest());
1125     }
1126
1127     /**
1128      * Tests {@link LispAddressUtil#asSrcDstEid(SourceDestKey, InstanceIdType)}  method.
1129      */
1130     @Test
1131     public void asTeLcafRloc() {
1132         final List<IpAddress> ipAddresses = Arrays.asList(IP_ADDRESS_IPV4_TEST,
1133                 IP_ADDRESS_IPV6_TEST);
1134         final Rloc rloc = LispAddressUtil.asTeLcafRloc(ipAddresses);
1135         assertNotNull(rloc);
1136         assertEquals(ExplicitLocatorPathLcaf.class, rloc.getAddressType());
1137         final List<Hop> hops = ((ExplicitLocatorPath) rloc.getAddress()).getExplicitLocatorPath().getHop();
1138         assertEquals(hops.size(), ipAddresses.size());
1139
1140         for (IpAddress ipAddress : ipAddresses) {
1141             assertTrue("Ip address " + ipAddress + "should be part of hops list.", isIpAddressInHops(ipAddress, hops));
1142         }
1143
1144         for (Hop hop : hops) {
1145             final Hop.LrsBits lrsBits = hop.getLrsBits();
1146             assertFalse(lrsBits.isLookup());
1147             assertFalse(lrsBits.isRlocProbe());
1148             assertFalse(lrsBits.isStrict());
1149
1150             final IpAddress ipAddressFromHop = hop.getAddress().getIpAddress();
1151             assertNotNull(ipAddressFromHop);
1152         }
1153     }
1154
1155     private boolean isIpAddressInHops(final IpAddress ipAddress, final List<Hop> hops) {
1156         for (Hop hop : hops) {
1157             if (hop.getAddress().getIpAddress().equals(ipAddress)) {
1158                 return true;
1159             }
1160         }
1161         return false;
1162     }
1163
1164     /**
1165      * Tests {@link LispAddressUtil#asLocatorRecords(List)}  method.
1166      */
1167     @Test
1168     public void asLocatorRecords() {
1169         final List<Rloc> expectedRlocs = Arrays.asList(LispAddressUtil.toRloc(IPV4_ADDRESS_TEST),
1170                 LispAddressUtil.toRloc(IPV6_ADDRESS_TEST));
1171         final List<LocatorRecord> locatorRecords = LispAddressUtil.asLocatorRecords(expectedRlocs);
1172
1173         assertEquals(expectedRlocs.size(), locatorRecords.size());
1174
1175         for (Rloc rloc : expectedRlocs) {
1176             assertTrue("Rloc " + rloc + " should be part of "
1177                     + "locator records list list", isRlocInLocatorRecords(locatorRecords, rloc));
1178         }
1179
1180         for (LocatorRecord locatorRecord : locatorRecords) {
1181             assertFalse(locatorRecord.isLocalLocator());
1182             assertFalse(locatorRecord.isRlocProbed());
1183             assertTrue(locatorRecord.isRouted());
1184             assertTrue(1 == locatorRecord.getWeight());
1185             assertTrue(1 == locatorRecord.getPriority());
1186             assertTrue(1 == locatorRecord.getMulticastWeight());
1187             assertTrue(1 == locatorRecord.getMulticastPriority());
1188             assertEquals("SFC_LISP", locatorRecord.getLocatorId());
1189         }
1190     }
1191
1192     private boolean isRlocInLocatorRecords(final List<LocatorRecord> locatorRecords, final Rloc rloc) {
1193         for (LocatorRecord locatorRecord : locatorRecords) {
1194             if (locatorRecord.getRloc().equals(rloc)) {
1195                 return true;
1196             }
1197         }
1198         return false;
1199     }
1200
1201     /**
1202      * Tests {@link LispAddressUtil#getNoAddressEid()}  method.
1203      */
1204     @Test
1205     public void getNoAddressEid() {
1206         final Eid noAddressEid = LispAddressUtil.getNoAddressEid();
1207         assertEquals(NoAddressAfi.class, noAddressEid.getAddressType());
1208         assertNull(noAddressEid.getVirtualNetworkId());
1209         assertTrue(((NoAddress) noAddressEid.getAddress()).isNoAddress());
1210     }
1211
1212     /**
1213      * Tests {@link LispAddressUtil#ipAddressToByteArray(Address)} method with ipv4 value.
1214      */
1215     @Test
1216     public void ipAddressToByteArray_ipv4() {
1217         final Ipv4 expectedIpv4 = new Ipv4Builder().setIpv4(IPV4_ADDRESS_TEST).build();
1218         final byte[] testedAddress = LispAddressUtil.ipAddressToByteArray(expectedIpv4);
1219         assertArrayEquals(IPV4_ADDRESS_BYTES_A_TEST, testedAddress);
1220     }
1221
1222     /**
1223      * Tests {@link LispAddressUtil#ipAddressToByteArray(Address)} method with ipv6 value.
1224      */
1225     @Test
1226     public void ipAddressToByteArray_ipv6() {
1227         final Ipv6 expectedIpv6 = new Ipv6Builder().setIpv6(IPV6_ADDRESS_TEST).build();
1228         final byte[] testedAddress = LispAddressUtil.ipAddressToByteArray(expectedIpv6);
1229         assertArrayEquals(IPV6_ADDRESS_BYTES_A_TEST, testedAddress);
1230     }
1231
1232     /**
1233      * Tests {@link LispAddressUtil#ipAddressToByteArray(Address)} method with ipv4Binary value.
1234      */
1235     @Test
1236     public void ipAddressToByteArray_ipv4Binary() {
1237         final Ipv4Binary expectedIpv4 = new Ipv4BinaryBuilder().setIpv4Binary(IPV4_ADDRESS_BINARY_TEST).build();
1238         final byte[] testedAddress = LispAddressUtil.ipAddressToByteArray(expectedIpv4);
1239         assertArrayEquals(IPV4_ADDRESS_BYTES_A_TEST, testedAddress);
1240     }
1241
1242     /**
1243      * Tests {@link LispAddressUtil#ipAddressToByteArray(Address)} method with ipv6Binary value.
1244      */
1245     @Test
1246     public void ipAddressToByteArray_ipv6Binary() {
1247         final Ipv6Binary expectedIpv6 = new Ipv6BinaryBuilder().setIpv6Binary(IPV6_ADDRESS_BINARY_TEST).build();
1248         final byte[] testedAddress = LispAddressUtil.ipAddressToByteArray(expectedIpv6);
1249         assertArrayEquals(IPV6_ADDRESS_BYTES_A_TEST, testedAddress);
1250     }
1251
1252     /**
1253      * Tests {@link LispAddressUtil#ipAddressToByteArray(Address)} method with mac value.
1254      */
1255     @Test
1256     public void ipAddressToByteArray_other() {
1257         final byte[] testedAddress = LispAddressUtil.ipAddressToByteArray(new MacBuilder().build());
1258         assertNull(testedAddress);
1259     }
1260
1261     /**
1262      * Tests {@link LispAddressUtil#convertToBinary(Eid)} method with ipv4Prefix, ipv6Prefix, ipv4, ipv6.
1263      */
1264     @Test
1265     public void convertToBinaryTest_eid() {
1266
1267         final Eid ipv4PrefixEid = new EidBuilder().setAddress(IPV4_PREFIX).build();
1268         final Eid ipv6PrefixEid = new EidBuilder().setAddress(IPV6_PREFIX).build();
1269         final Eid ipv4 = new EidBuilder().setAddress(IPV4).build();
1270         final Eid ipv6 = new EidBuilder().setAddress(IPV6).build();
1271
1272         Eid resultIpv4PrefixBinary = LispAddressUtil.convertToBinary(ipv4PrefixEid);
1273         verifyToEidWithIpv4PrefixBinary(resultIpv4PrefixBinary, false, MASK_OK_TEST, Ipv4PrefixBinaryAfi.class);
1274
1275         Eid resultIpv6PrefixBinary = LispAddressUtil.convertToBinary(ipv6PrefixEid);
1276         verifyToEidWithIpv6PrefixBinary(resultIpv6PrefixBinary , false, MASK_OK_TEST, Ipv6PrefixBinaryAfi.class);
1277
1278         Eid resultIpv4Binary = LispAddressUtil.convertToBinary(ipv4);
1279         verifyToEidWithIpv4Binary(resultIpv4Binary , false);
1280
1281         Eid resultIpv6Binary = LispAddressUtil.convertToBinary(ipv6);
1282         verifyToEidWithIpv6Binary(resultIpv6Binary , false);
1283     }
1284
1285     /**
1286      * Tests {@link LispAddressUtil#convertToBinary(Eid)} method with ipv4Prefix, ipv6Prefix, ipv4, ipv6.
1287      */
1288     @Test
1289     public void convertFromBinaryTest_eid() {
1290         final Eid resultIpv4Prefix = LispAddressUtil.convertFromBinary(IPV4_ADDRESS_PREFIX_BINARY_EID);
1291         verifyToEidWithIpv4Prefix(resultIpv4Prefix, false, MASK_OK_TEST, Ipv4PrefixAfi.class);
1292
1293         final Eid resultIpv6Prefix = LispAddressUtil.convertFromBinary(IPV6_ADDRESS_PREFIX_BINARY_EID);
1294         verifyToEidWithIpv6Prefix(resultIpv6Prefix, false, MASK_OK_TEST, Ipv6PrefixAfi.class);
1295
1296         final Eid resultIpv4 = LispAddressUtil.convertFromBinary(IPV4_ADDRESS_BINARY_EID);
1297         verifyToEidWithIpv4(resultIpv4, false);
1298
1299         final Eid resultIpv6 = LispAddressUtil.convertFromBinary(IPV6_ADDRESS_BINARY_EID);
1300         verifyToEidWithIpv6(resultIpv6, false);
1301     }
1302
1303     /**
1304      * Tests {@link LispAddressUtil#convertFromBinary(Rloc)} method with ipv4.
1305      */
1306     @Test
1307     public void convertFromBinaryTest_rloc() {
1308         final Rloc resultIpv4 = LispAddressUtil.convertFromBinary(IPV4_BINARY_RLOC);
1309         verifyToRlocWithIpv4(resultIpv4, false);
1310     }
1311
1312     /**
1313      * Tests {@link LispAddressUtil#convertToBinary(Rloc)} method with ipv4.
1314      */
1315     @Test
1316     public void convertToBinaryTest_rloc() {
1317         final Rloc resultIpv4Binary = LispAddressUtil.convertToBinary(IPV4_RLOC);
1318         verifyToRlocWithIpv4Binary(resultIpv4Binary, false);
1319     }
1320
1321     /**
1322      * Tests {@link LispAddressUtil#addressNeedsConversionToBinary} method with ipv4, ipv6, ipv4Prefix, ipv6Prefix and
1323      * Ipv4Binary.
1324      */
1325     @Test
1326     public void addressNeedsConversionToBinaryTest() {
1327         assertTrue(LispAddressUtil.addressNeedsConversionToBinary(IPV4));
1328         assertTrue(LispAddressUtil.addressNeedsConversionToBinary(IPV6));
1329         assertTrue(LispAddressUtil.addressNeedsConversionToBinary(IPV4_PREFIX));
1330         assertTrue(LispAddressUtil.addressNeedsConversionToBinary(IPV6_PREFIX));
1331         assertFalse(LispAddressUtil.addressNeedsConversionToBinary(IPV4_BINARY));
1332     }
1333
1334     /**
1335      * Tests {@link LispAddressUtil#addressNeedsConversionToBinary} method with ipv4, ipv6, ipv4Prefix, ipv6Prefix and
1336      * Ipv4Binary.
1337      */
1338     @Test
1339     public void addressNeedsConversionFromBinaryTest() {
1340         assertTrue(LispAddressUtil.addressNeedsConversionFromBinary(IPV4_BINARY));
1341         assertTrue(LispAddressUtil.addressNeedsConversionFromBinary(IPV6_BINARY));
1342         assertTrue(LispAddressUtil.addressNeedsConversionFromBinary(IPV4_ADDRESS_PREFIX_BINARY));
1343         assertTrue(LispAddressUtil.addressNeedsConversionFromBinary(IPV6_ADDRESS_PREFIX_BINARY));
1344         assertFalse(LispAddressUtil.addressNeedsConversionFromBinary(IPV4));
1345     }
1346
1347     /**
1348      * Tests {@link LispAddressUtil#compareIpAddressByteArrays(byte[], byte[])} with all possible combination
1349      * of input parameters to reach 100 % coverage.
1350      */
1351     @Test
1352     public void compareIpAddressByteArrays() throws UnknownHostException {
1353         int comparisonResult = LispAddressUtil.compareIpAddressByteArrays(IPV4_ADDRESS_BYTES_A_TEST,
1354                 IPV6_ADDRESS_BYTES_A_TEST);
1355         assertEquals(-1, comparisonResult);
1356
1357         comparisonResult = LispAddressUtil.compareIpAddressByteArrays(IPV6_ADDRESS_BYTES_A_TEST,
1358                 IPV4_ADDRESS_BYTES_A_TEST);
1359         assertEquals(1, comparisonResult);
1360
1361         comparisonResult = LispAddressUtil.compareIpAddressByteArrays(IPV4_ADDRESS_BYTES_A_TEST,
1362                 IPV4_ADDRESS_BYTES_B_TEST);
1363         assertEquals(-1, comparisonResult);
1364
1365         comparisonResult = LispAddressUtil.compareIpAddressByteArrays(IPV4_ADDRESS_BYTES_B_TEST,
1366                 IPV4_ADDRESS_BYTES_A_TEST);
1367         assertEquals(1, comparisonResult);
1368
1369         comparisonResult = LispAddressUtil.compareIpAddressByteArrays(IPV4_ADDRESS_BYTES_B_TEST,
1370                 IPV4_ADDRESS_BYTES_B_TEST);
1371         assertEquals(0, comparisonResult);
1372
1373         comparisonResult = LispAddressUtil.compareIpAddressByteArrays(IPV6_ADDRESS_BYTES_A_TEST,
1374                 IPV6_ADDRESS_BYTES_B_TEST);
1375         assertEquals(-1, comparisonResult);
1376
1377         comparisonResult = LispAddressUtil.compareIpAddressByteArrays(IPV6_ADDRESS_BYTES_B_TEST,
1378                 IPV6_ADDRESS_BYTES_A_TEST);
1379         assertEquals(1, comparisonResult);
1380
1381         comparisonResult = LispAddressUtil.compareIpAddressByteArrays(IPV6_ADDRESS_BYTES_B_TEST,
1382                 IPV6_ADDRESS_BYTES_B_TEST);
1383         assertEquals(0, comparisonResult);
1384
1385         comparisonResult = LispAddressUtil.compareIpAddressByteArrays(new byte[]{1, 2, 3, 4, 5},
1386                 new byte[]{1, 2, 3, 4, 5});
1387         assertEquals(0, comparisonResult);
1388
1389     }
1390
1391     /**
1392      * Tests {@link LispAddressUtil#asServicePathEid(long, long, short)} method.
1393      */
1394     @Test
1395     public void asServicePathEid() {
1396         final Eid eid = LispAddressUtil.asServicePathEid(INSTANCE_ID_TYPE_VALUE_TEST, SERVICE_PATH_ID_TEST,
1397                 SERVICE_INDEX_TEST);
1398
1399         assertNotNull(eid);
1400         assertEquals(ServicePathLcaf.class, eid.getAddressType());
1401         assertEquals(INSTANCE_ID_TYPE_TEST, eid.getVirtualNetworkId());
1402         ServicePath servicePath = ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp
1403                 .address.types.rev151105.lisp.address.address.ServicePath) eid.getAddress()).getServicePath();
1404         assertNotNull(servicePath);
1405         assertEquals(SERVICE_INDEX_TEST, servicePath.getServiceIndex());
1406         assertEquals(SERVICE_PATH_ID_TEST, servicePath.getServicePathId().getValue());
1407     }
1408
1409     /**
1410      * Tests {@link LispAddressUtil#toIpPrefixEid(IpAddress, int)} method.
1411      */
1412     @Test
1413     public void toIpPrefixEid() throws UnknownHostException {
1414         final Eid eid = LispAddressUtil.toIpPrefixEid(IP_ADDRESS_IPV4_TEST,
1415                 INSTANCE_ID_TYPE_VALUE_SHORT_TEST);
1416         verifyEidContainsIpPrefix(eid, MASK_OK_DEFAULT_IPV4_TEST);
1417     }
1418
1419     /**
1420      * Tests {@link LispAddressUtil#toEidNoVni(IpPrefix)} method.
1421      */
1422     @Test
1423     public void toEidNoVni() {
1424         final Eid eid = LispAddressUtil.toEidNoVni(IP_ADDRESS_PREFIX_WITH_IPV4_TEST);
1425         verifyEidContainsIpPrefix(eid, MASK_OK_TEST);
1426     }
1427
1428     public void verifyEidContainsIpPrefix(final Eid eid, final short mask) {
1429         final Ipv4Prefix expectedPrefix = new Ipv4Prefix(IPV4_ADDRESS_VALUE_TEST + "/" + mask);
1430         assertNotNull(eid);
1431         assertTrue(eid.getAddress() instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp
1432                 .address.types.rev151105.lisp.address.address.Ipv4Prefix);
1433         final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address
1434                 .address.Ipv4Prefix address = (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp
1435                 .address.types.rev151105.lisp.address.address.Ipv4Prefix) eid.getAddress();
1436         assertEquals(expectedPrefix, address.getIpv4Prefix());
1437     }
1438
1439     /**
1440      * Tests {@link LispAddressUtil#asEid(SimpleAddress, InstanceIdType)} method.
1441      */
1442     @Test
1443     public void asEid() {
1444         final Eid eid = LispAddressUtil.asEid(SIMPLE_ADDRESS_IPV4_TEST, INSTANCE_ID_TYPE_TEST);
1445         assertNotNull(eid);
1446         assertEquals(Ipv4BinaryAfi.class, eid.getAddressType());
1447         final Ipv4Binary address = (Ipv4Binary) eid.getAddress();
1448         assertArrayEquals(InetAddresses.forString(SIMPLE_ADDRESS_IPV4_TEST.getIpAddress().getIpv4Address().getValue())
1449                 .getAddress(), address.getIpv4Binary().getValue());
1450         assertEquals(INSTANCE_ID_TYPE_TEST, eid.getVirtualNetworkId());
1451     }
1452
1453 }
1454