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