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