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

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