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