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.rev100924.AsNumber;
  27 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  28 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
  29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv6Address;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv6Prefix;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.AsNumberAfi;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.DistinguishedNameAfi;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.DistinguishedNameType;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.ExplicitLocatorPathLcaf;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.InstanceIdType;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4Afi;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4PrefixAfi;
  40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv6Afi;
  41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv6PrefixAfi;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.KeyValueAddressLcaf;
  43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.LispAddress;
  44 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.LispAddressFamily;
  45 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.MacAfi;
  46 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.NoAddressAfi;
  47 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.ServicePathIdType;
  48 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.ServicePathLcaf;
  49 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SimpleAddress;
  50 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SourceDestKeyLcaf;
  51 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.Address;
  52 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.DistinguishedName;
  53 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ExplicitLocatorPath;
  54 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4;
  55 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4Builder;
  56 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.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.KeyValueAddress;
  59 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Mac;
  60 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.MacBuilder;
  61 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.NoAddress;
  62 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;
  63 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.service.path.ServicePath;
  64 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.source.dest.key.SourceDestKey;
  65 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.source.dest.key.SourceDestKeyBuilder;
  66 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv4AddressBinary;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv6AddressBinary;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.Ipv4BinaryAfi;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.Ipv6BinaryAfi;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.augmented.lisp.address.address.Ipv4Binary;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.augmented.lisp.address.address.Ipv6Binary;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.EidBuilder;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecord;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
  77
  78 import com.google.common.net.InetAddresses;
  79
  80 public class LispAddressUtilTest {
  81
  82
  83     private static final char[] DUMMY_CHARACTER_ARRAY_TEST = new char[]{'a', 'b', 'c', 'd'};
  84     private static final Long NUMBER_TEST = 5L;
  85
  86     private static final String MAC_ADDRESS_VALUE_TEST = "aa:bb:cc:dd:ee:ff";
  87     private static final MacAddress MAC_ADDRESS_TEST = new MacAddress("aa:bb:cc:dd:ee:ff");
  88
  89     private static final byte[] IPV4_ADDRESS_BYTES_A_TEST = new byte[]{(byte) 192, (byte) 168, 1, 1};
  90     private static final byte[] IPV4_ADDRESS_BYTES_B_TEST = new byte[]{(byte) 192, (byte) 168, 1, 2};
  91
  92     private static final short MASK_OK_TEST = 30;
  93     private static final short MASK_OK_DEFAULT_IPV4_TEST = 32;
  94     private static final short MASK_OK_DEFAULT_IPV6_TEST = 128;
  95
  96     private static final String IPV4_ADDRESS_VALUE_TEST = "192.168.1.1";
  97     private static final String IPV4_ADDRESS_PREFIX_VALUE_TEST = IPV4_ADDRESS_VALUE_TEST + "/" + MASK_OK_TEST;
  98     private static final Ipv4Address IPV4_ADDRESS_TEST = new Ipv4Address(IPV4_ADDRESS_VALUE_TEST);
  99     private static final Ipv4AddressBinary IPV4_ADDRESS_BINARY_TEST = new Ipv4AddressBinary(IPV4_ADDRESS_BYTES_A_TEST);
 100     private static final IpAddress IP_ADDRESS_OBJECT_WITH_IPV4_TEST = new IpAddress(IPV4_ADDRESS_TEST);
 101     private static final Ipv4Prefix IPV4_ADDRESS_PREFIX_TEST = new Ipv4Prefix(IPV4_ADDRESS_PREFIX_VALUE_TEST);
 102     private static final IpPrefix IP_ADDRESS_PREFIX_WITH_IPV4_TEST = new IpPrefix(IPV4_ADDRESS_PREFIX_TEST);
 103
 104
 105     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,
 106             15, 16};
 107     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,
 108             15, 17};
 109     private static final String IPV6_ADDRESS_VALUE_TEST = "102:304:506:708:90a:b0c:d0e:f10";
 110     private static final String IPV6_ADDRESS_PREFIX_VALUE_TEST = IPV6_ADDRESS_VALUE_TEST + "/" + MASK_OK_TEST;
 111     private static final Ipv6Prefix IPV6_ADDRESS_PREFIX_TEST = new Ipv6Prefix(IPV6_ADDRESS_PREFIX_VALUE_TEST);
 112     private static final Ipv6Address IPV6_ADDRESS_TEST = new Ipv6Address(IPV6_ADDRESS_VALUE_TEST);
 113     private static final Ipv6AddressBinary IPV6_ADDRESS_BINARY_TEST = new Ipv6AddressBinary(IPV6_ADDRESS_BYTES_A_TEST);
 114     private static final IpPrefix IP_ADDRESS_PREFIX_WITH_IPV6_TEST = new IpPrefix(IPV6_ADDRESS_PREFIX_TEST);
 115     private static final IpAddress IP_ADDRESS_OBJECT_WITH_IPV6_TEST = new IpAddress(IPV6_ADDRESS_TEST);
 116
 117     private static final Short SERVICE_INDEX_TEST = 45;
 118     private static final Long DUMMY_SERVICE_PATH_ID_TYPE = 46L;
 119     private static final String DISTINGUISHED_NAME_TYPE_VALUE_TEST = "dummy distinguished name type";
 120     private static final String DISTINGUISHED_NAME_TYPE_VALUE_WITH_MAC_TEST = MAC_ADDRESS_VALUE_TEST;
 121     private static final DistinguishedNameType DISTINGUISHED_NAME_TYPE_TEST = new DistinguishedNameType
 122             (DISTINGUISHED_NAME_TYPE_VALUE_TEST);
 123
 124     private static final Long AS_NUMBER_TEST = 100L;
 125     private static final Long INSTANCE_ID_TYPE_VALUE_TEST = 121L;
 126     private static final Short INSTANCE_ID_TYPE_VALUE_SHORT_TEST = 122;
 127     private static final InstanceIdType INSTANCE_ID_TYPE_TEST = new InstanceIdType(INSTANCE_ID_TYPE_VALUE_TEST);
 128     private static final String INCORRECT_IP_ADDRESS_TEST = "incorrect ip address";
 129
 130     private static final SimpleAddress SIMPLE_ADDRESS_A_TEST = new SimpleAddress(IP_ADDRESS_OBJECT_WITH_IPV4_TEST);
 131     private static final SimpleAddress SIMPLE_ADDRESS_B_TEST = new SimpleAddress(MAC_ADDRESS_TEST);
 132     private static final String SIMPLE_ADDRESS_DISTINGUISHED_VALUE_TEST = DISTINGUISHED_NAME_TYPE_VALUE_TEST;
 133     private static final SimpleAddress SIMPLE_ADDRESS_DISTINGUISHED_TEST = new SimpleAddress(new DistinguishedNameType
 134             (SIMPLE_ADDRESS_DISTINGUISHED_VALUE_TEST));
 135     private static final SimpleAddress SIMPLE_ADDRESS_WITH_IP_PREFIX_IPV4_TEST = new SimpleAddress
 136             (IP_ADDRESS_PREFIX_WITH_IPV4_TEST);
 137     private static final SimpleAddress SIMPLE_ADDRESS_WITH_IP_PREFIX_IPV6_TEST = new SimpleAddress
 138             (IP_ADDRESS_PREFIX_WITH_IPV6_TEST);
 139     private static final Long SERVICE_PATH_ID_TEST = 2121L;
 140
 141     /**
 142      * Tests {@link LispAddressUtil#addressTypeFromSimpleAddress} and {@link
 143      * LispAddressUtil#addressFromSimpleAddress} methods
 144      * with ipAddress
 145      */
 146     @Test
 147     public void addressFromSimpleAddressTest_asAnyIpAddress() {
 148         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromSimpleAddress
 149                 (SIMPLE_ADDRESS_A_TEST);
 150         assertEquals(Ipv4BinaryAfi.class, addressClass);
 151
 152         final Address address = LispAddressUtil.addressFromSimpleAddress(SIMPLE_ADDRESS_A_TEST);
 153         assertTrue(address instanceof Ipv4Binary);
 154     }
 155
 156     /**
 157      * Tests {@link LispAddressUtil#addressTypeFromSimpleAddress} and {@link
 158      * LispAddressUtil#addressFromSimpleAddress} methods
 159      * with ipPrefix
 160      */
 161     @Test
 162     public void addressFromSimpleAddressTest_asIpPrefix() {
 163         final SimpleAddress simpleAddress = new SimpleAddress(new IpPrefix(new Ipv4Prefix(
 164                 IPV4_ADDRESS_PREFIX_VALUE_TEST)));
 165         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromSimpleAddress
 166                 (simpleAddress);
 167         assertEquals(Ipv4PrefixAfi.class, addressClass);
 168
 169         final Address address = LispAddressUtil.addressFromSimpleAddress(simpleAddress);
 170         assertTrue(address instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address
 171                 .types.rev151105.lisp.address.address.Ipv4Prefix);
 172     }
 173
 174     /**
 175      * Tests {@link LispAddressUtil#addressTypeFromSimpleAddress} and {@link
 176      * LispAddressUtil#addressFromSimpleAddress} methods
 177      * with mac address
 178      */
 179     @Test
 180     public void addressFromSimpleAddressTest_asMacAddress() {
 181         final SimpleAddress simpleAddress = new SimpleAddress(new MacAddress(MAC_ADDRESS_VALUE_TEST));
 182         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromSimpleAddress
 183                 (simpleAddress);
 184         assertEquals(MacAfi.class, addressClass);
 185
 186         final Address address = LispAddressUtil.addressFromSimpleAddress(simpleAddress);
 187         assertTrue(address instanceof Mac);
 188     }
 189
 190     /**
 191      * Tests {@link LispAddressUtil#addressTypeFromSimpleAddress} and {@link
 192      * LispAddressUtil#addressFromSimpleAddress} methods
 193      * with general address
 194      */
 195     @Test
 196     public void addressFromSimpleAddressTest_asAddress() {
 197         final SimpleAddress simpleAddress = new SimpleAddress(DUMMY_CHARACTER_ARRAY_TEST);
 198         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromSimpleAddress
 199                 (simpleAddress);
 200         assertEquals(DistinguishedNameAfi.class, addressClass);
 201
 202         final Address address = LispAddressUtil.addressFromSimpleAddress(simpleAddress);
 203         assertTrue(address instanceof DistinguishedName);
 204     }
 205
 206     /**
 207      * Tests {@link LispAddressUtil#addressTypeFromSimpleAddress} and {@link
 208      * LispAddressUtil#addressFromSimpleAddress} methods
 209      * with address as number
 210      */
 211     @Test
 212     public void addressFromSimpleAddressTest_asNumber() {
 213         final SimpleAddress simpleAddress = new SimpleAddress(new AsNumber(NUMBER_TEST));
 214         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromSimpleAddress
 215                 (simpleAddress);
 216         assertEquals(AsNumberAfi.class, addressClass);
 217
 218         final Address address = LispAddressUtil.addressFromSimpleAddress(simpleAddress);
 219         assertTrue(address instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address
 220                 .types.rev151105.lisp.address.address.AsNumber);
 221     }
 222
 223     /**
 224      * Tests {@link LispAddressUtil#addressFromInet(InetAddress)} and {@link LispAddressUtil#addressTypeFromInet
 225      * (InetAddress)}
 226      * methods with ipv4 address
 227      *
 228      * @throws UnknownHostException
 229      */
 230     @Test
 231     public void addressFromInet_ipv4() throws UnknownHostException {
 232         final InetAddress ipv4InetAddress = Inet4Address.getByAddress(IPV4_ADDRESS_BYTES_A_TEST);
 233         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromInet(ipv4InetAddress);
 234         assertEquals(Ipv4Afi.class, addressClass);
 235
 236         final Address address = LispAddressUtil.addressFromInet(ipv4InetAddress);
 237         assertTrue(address instanceof Ipv4);
 238         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4) address).getIpv4().getValue());
 239     }
 240
 241     /**
 242      * Tests {@link LispAddressUtil#addressFromInet(InetAddress)} and {@link LispAddressUtil#addressTypeFromInet
 243      * (InetAddress)}
 244      * methods with ipv6 address
 245      *
 246      * @throws UnknownHostException
 247      */
 248     @Test
 249     public void addressFromInet_ipv6() throws UnknownHostException {
 250         final InetAddress ipv6InetAddress = Inet6Address.getByAddress(IPV6_ADDRESS_BYTES_A_TEST);
 251         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromInet(ipv6InetAddress);
 252         assertEquals(Ipv6Afi.class, addressClass);
 253
 254         final Address address = LispAddressUtil.addressFromInet(ipv6InetAddress);
 255         assertTrue(address instanceof Ipv6);
 256         assertEquals(IPV6_ADDRESS_VALUE_TEST, ((Ipv6) address).getIpv6().getValue());
 257     }
 258
 259     /**
 260      * Tests {@link LispAddressUtil#addressFromIpAddress(IpAddress)} and {@link
 261      * LispAddressUtil#addressTypeFromIpAddress(IpAddress)}
 262      * methods with ipv4 address
 263      */
 264     @Test
 265     public void addressFromIpAddress_ipv4() {
 266         final IpAddress ipv4Address = new IpAddress(IPV4_ADDRESS_TEST);
 267         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromIpAddress(ipv4Address);
 268         assertEquals(Ipv4Afi.class, addressClass);
 269
 270         final Address address = LispAddressUtil.addressFromIpAddress(ipv4Address);
 271         assertTrue(address instanceof Ipv4);
 272         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4) address).getIpv4().getValue());
 273     }
 274
 275     /**
 276      * Tests {@link LispAddressUtil#addressFromIpAddress(IpAddress)} and {@link
 277      * LispAddressUtil#addressTypeFromIpAddress(IpAddress)}
 278      * methods with ipv6 address
 279      */
 280     @Test
 281     public void addressFromIpAddress_ipv6() {
 282         final IpAddress ipv6Address = new IpAddress(new Ipv6Address(IPV6_ADDRESS_VALUE_TEST));
 283         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromIpAddress(ipv6Address);
 284         assertEquals(Ipv6Afi.class, addressClass);
 285
 286         final Address address = LispAddressUtil.addressFromIpAddress(ipv6Address);
 287         assertTrue(address instanceof Ipv6);
 288         assertEquals(IPV6_ADDRESS_VALUE_TEST, ((Ipv6) address).getIpv6().getValue());
 289     }
 290
 291     /**
 292      * Tests {@link LispAddressUtil#addressFromIpAddress(IpAddress)} and {@link
 293      * LispAddressUtil#addressTypeFromIpAddress(IpAddress)}
 294      * methods with null value instead off address.
 295      */
 296     @Test
 297     public void addressFromIpAddress_null() {
 298         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromIpAddress(null);
 299         assertNull(addressClass);
 300
 301         final Address address = LispAddressUtil.addressFromIpAddress(null);
 302         assertNull(address);
 303     }
 304
 305     /**
 306      * Tests {@link LispAddressUtil#addressFromIpPrefix(IpPrefix)} and {@link
 307      * LispAddressUtil#addressTypeFromIpPrefix(IpPrefix)}
 308      * methods with ipv4 address
 309      */
 310     @Test
 311     public void addressFromIpPrefix_ipv4() {
 312         IpPrefix ipv4Prefix = new IpPrefix(new Ipv4Prefix(IPV4_ADDRESS_PREFIX_VALUE_TEST));
 313         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromIpPrefix(ipv4Prefix);
 314         assertEquals(Ipv4PrefixAfi.class, addressClass);
 315
 316         final Address address = LispAddressUtil.addressFromIpPrefix(ipv4Prefix);
 317         assertTrue(address instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.
 318                 types.rev151105.lisp.address.address.Ipv4Prefix);
 319         assertEquals(IPV4_ADDRESS_PREFIX_VALUE_TEST, ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.
 320                 lisp.address.types.rev151105.lisp.address.address.Ipv4Prefix) address).getIpv4Prefix().getValue());
 321     }
 322
 323     /**
 324      * Tests {@link LispAddressUtil#addressFromIpPrefix(IpPrefix)} and {@link
 325      * LispAddressUtil#addressTypeFromIpPrefix(IpPrefix)}
 326      * methods with ipv6 address
 327      */
 328     @Test
 329     public void addressFromIpPrefix_ipv6() {
 330         IpPrefix ipv6Address = new IpPrefix(new Ipv6Prefix(IPV6_ADDRESS_PREFIX_VALUE_TEST));
 331         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromIpPrefix(ipv6Address);
 332         assertEquals(Ipv6PrefixAfi.class, addressClass);
 333
 334         final Address address = LispAddressUtil.addressFromIpPrefix(ipv6Address);
 335         assertTrue(address instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address
 336                 .types.rev151105.lisp.address.address.Ipv6Prefix);
 337         assertEquals(IPV6_ADDRESS_PREFIX_VALUE_TEST,
 338                 ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp
 339                         .address.address.Ipv6Prefix) address).getIpv6Prefix().getValue());
 340     }
 341
 342     /**
 343      * Tests {@link LispAddressUtil#addressFromIpPrefix(IpPrefix)} and {@link LispAddressUtil#addressTypeFromIpPrefix
 344      * (IpPrefix)}
 345      * methods with null value instead off address.
 346      */
 347     @Test
 348     public void addressFromIpPrefix_null() {
 349         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromIpPrefix(null);
 350         assertNull(addressClass);
 351
 352         final Address address = LispAddressUtil.addressFromIpPrefix(null);
 353         assertNull(address);
 354     }
 355
 356     /**
 357      * Tests {@link LispAddressUtil#addressFromMacAddress(MacAddress)} methods with mac address.
 358      */
 359     @Test
 360     public void addressFromMacAddress_mac() {
 361         final Address address = LispAddressUtil.addressFromMacAddress(new MacAddress(MAC_ADDRESS_VALUE_TEST));
 362         assertTrue(address instanceof Mac);
 363         assertEquals(MAC_ADDRESS_VALUE_TEST, ((Mac) address).getMac().getValue());
 364     }
 365
 366     /**
 367      * Tests {@link LispAddressUtil#addressFromMacAddress(MacAddress)} methods with null instead of address.
 368      */
 369     @Test
 370     public void addressFromMacAddress_null() {
 371         final Address address = LispAddressUtil.addressFromMacAddress(null);
 372         assertNull(address);
 373     }
 374
 375
 376     /**
 377      * Test {@link LispAddressUtil#addressFromServicePath(ServicePath)} method with concrete servicePath
 378      */
 379     @Test
 380     public void addressFromServicePathTest_withServicePath() {
 381         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address
 382                 .address.service.path.ServicePathBuilder servicePathBuilder = new org.opendaylight.yang.gen.v1.urn.ietf
 383                 .params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address
 384                 .address.service.path.ServicePathBuilder();
 385         servicePathBuilder.setServiceIndex(SERVICE_INDEX_TEST);
 386         servicePathBuilder.setServicePathId(new ServicePathIdType(DUMMY_SERVICE_PATH_ID_TYPE));
 387
 388         ServicePath expectedAddress = servicePathBuilder.build();
 389         final Address testedAddress = LispAddressUtil.addressFromServicePath(expectedAddress);
 390         assertTrue(testedAddress instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address
 391                 .types.rev151105.lisp.address.address.ServicePath);
 392         assertEquals(expectedAddress, ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address
 393                 .types.rev151105.lisp.address.address.ServicePath) testedAddress).getServicePath());
 394     }
 395
 396     /**
 397      * Test {@link LispAddressUtil#addressFromServicePath(ServicePath)} method with null value
 398      */
 399     @Test
 400     public void addressFromServicePathTest_withNull() {
 401         final Address testedAddress = LispAddressUtil.addressFromServicePath(null);
 402         assertNull(testedAddress);
 403     }
 404
 405     /**
 406      * Test {@link LispAddressUtil#addressFromDistinguishedName(DistinguishedNameType)} method with distinguished name }
 407      */
 408     @Test
 409     public void addressFromDistinguishedNameTest_withDistinguishedName() {
 410         final DistinguishedNameType distinguishedNameType = new DistinguishedNameType(
 411                 DISTINGUISHED_NAME_TYPE_VALUE_TEST);
 412         final Address testedAddress = LispAddressUtil.addressFromDistinguishedName(distinguishedNameType);
 413
 414         assertTrue(testedAddress instanceof DistinguishedName);
 415         assertEquals(distinguishedNameType, ((DistinguishedName) testedAddress).getDistinguishedName());
 416     }
 417
 418     /**
 419      * Test {@link LispAddressUtil#addressFromDistinguishedName(DistinguishedNameType)} method with null value }
 420      */
 421     @Test
 422     public void addressFromDistinguishedNameTest_withNull() {
 423         final Address testedAddress = LispAddressUtil.addressFromDistinguishedName(null);
 424         assertNull(testedAddress);
 425     }
 426
 427     /**
 428      * Test {@link LispAddressUtil#addressFromAsNumber(AsNumber)} method with as number value }
 429      */
 430     @Test
 431     public void addressFromAsNumberTest_withAdNumber() {
 432         final AsNumber expectedAddress = new AsNumber(AS_NUMBER_TEST);
 433         final Address testedAddress = LispAddressUtil.addressFromAsNumber(expectedAddress);
 434         assertTrue(testedAddress instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp
 435                 .address.types.rev151105.lisp.address.address.AsNumber);
 436         assertEquals(expectedAddress, ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp
 437                 .address.types.rev151105.lisp.address.address.AsNumber) testedAddress).getAsNumber());
 438     }
 439
 440     /**
 441      * Test {@link LispAddressUtil#addressFromAsNumber(AsNumber)} method with null instead of value }
 442      */
 443     @Test
 444     public void addressFromAsNumberTest_withNull() {
 445         final Address testedAddress = LispAddressUtil.addressFromAsNumber(null);
 446         assertNull(testedAddress);
 447     }
 448
 449
 450     /**
 451      * Tests:
 452      * - {@link LispAddressUtil#toRloc(InetAddress)}
 453      * - {@link LispAddressUtil#toRloc(Ipv4Address)}
 454      * - {@link LispAddressUtil#toRloc(Ipv6Address)}
 455      * - {@link LispAddressUtil#toRloc(SimpleAddress)}
 456      * methods.
 457      */
 458     @Test
 459     public void toRloc() throws UnknownHostException {
 460         InetAddress ipv4AddressInet = Inet4Address.getByAddress(IPV4_ADDRESS_BYTES_A_TEST);
 461         final Rloc rlocFromInetAddress = LispAddressUtil.toRloc(ipv4AddressInet);
 462         assertEquals(Ipv4Afi.class, rlocFromInetAddress.getAddressType());
 463         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4)rlocFromInetAddress.getAddress()).getIpv4().getValue());
 464
 465         final Rloc rlocFromIpv4Address = LispAddressUtil.toRloc(IPV4_ADDRESS_TEST);
 466         assertEquals(Ipv4Afi.class, rlocFromIpv4Address.getAddressType());
 467         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4) rlocFromIpv4Address.getAddress()).getIpv4().getValue());
 468
 469
 470         final Rloc rlocFromIpv6Address = LispAddressUtil.toRloc(IPV6_ADDRESS_TEST);
 471         assertEquals(Ipv6Afi.class, rlocFromIpv6Address.getAddressType());
 472         assertEquals(IPV6_ADDRESS_VALUE_TEST, ((Ipv6) rlocFromIpv6Address.getAddress()).getIpv6().getValue());
 473
 474         final Rloc rlocFromSimpleAddress = LispAddressUtil.toRloc(SIMPLE_ADDRESS_A_TEST);
 475         assertEquals(Ipv4BinaryAfi.class, rlocFromSimpleAddress.getAddressType());
 476         assertEquals(IPV4_ADDRESS_BINARY_TEST, ((Ipv4Binary) rlocFromSimpleAddress.getAddress()).getIpv4Binary());
 477     }
 478
 479     /**
 480      * Test {@link LispAddressUtil#asIpv4Rloc(String)} method with ipv4 or ipv6.
 481      * Test {@link LispAddressUtil#asIpv6Rloc(String)} method with ipv4 or ipv6.
 482      */
 483     @Test
 484     public void asIpvRloc() {
 485         final Rloc rlocFromIpV4 = LispAddressUtil.asIpv4Rloc(IPV4_ADDRESS_VALUE_TEST);
 486         assertEquals(Ipv4BinaryAfi.class, rlocFromIpV4.getAddressType());
 487         assertEquals(IPV4_ADDRESS_BINARY_TEST, ((Ipv4Binary) rlocFromIpV4.getAddress()).getIpv4Binary());
 488
 489         final Rloc rlocFromIpV6 = LispAddressUtil.asIpv6Rloc(IPV6_ADDRESS_VALUE_TEST);
 490         assertEquals(Ipv6BinaryAfi.class, rlocFromIpV6.getAddressType());
 491         assertEquals(IPV6_ADDRESS_BINARY_TEST, ((Ipv6Binary) rlocFromIpV6.getAddress()).getIpv6Binary());
 492     }
 493
 494     /**
 495      * Test
 496      * - {@link LispAddressUtil#toEid(Ipv6Address, InstanceIdType)}
 497      * - {@link LispAddressUtil#asIpv6PrefixEid(String)}
 498      * - {@link LispAddressUtil#asIpv6PrefixEid(Eid, Inet6Address, short)}
 499      * - {@link LispAddressUtil#asIpv6PrefixEid(Ipv6Address, InstanceIdType)}
 500      * methods.
 501      */
 502     @Test
 503     public void toEid_ipv6Prefix() throws UnknownHostException {
 504         Eid eidFromIpv6Prefix = LispAddressUtil.toEid(IPV6_ADDRESS_PREFIX_TEST, INSTANCE_ID_TYPE_TEST);
 505         verifyToEidWithIpv6Prefix(eidFromIpv6Prefix, true, MASK_OK_TEST, Ipv6PrefixAfi.class);
 506
 507         eidFromIpv6Prefix = LispAddressUtil.asIpv6PrefixEid(IPV6_ADDRESS_PREFIX_VALUE_TEST);
 508         verifyToEidWithIpv6Prefix(eidFromIpv6Prefix, false, MASK_OK_TEST, Ipv6PrefixAfi.class);
 509
 510         eidFromIpv6Prefix = LispAddressUtil.asIpv6PrefixEid(IPV6_ADDRESS_TEST, INSTANCE_ID_TYPE_TEST);
 511         verifyToEidWithIpv6Prefix(eidFromIpv6Prefix, true, MASK_OK_DEFAULT_IPV6_TEST, Ipv6PrefixAfi.class);
 512
 513     }
 514
 515     /**
 516      * Test
 517      * - {@link LispAddressUtil#toEid(MacAddress, InstanceIdType)}
 518      * - {@link LispAddressUtil#asMacEid(String)}
 519      * - {@link LispAddressUtil#asMacEid(String, long)}
 520      * methods.
 521      */
 522     @Test
 523     public void toEid_mac() {
 524         Eid eidFromMac = LispAddressUtil.toEid(MAC_ADDRESS_TEST, INSTANCE_ID_TYPE_TEST);
 525         verifyToEidWithMacAddress(eidFromMac, true);
 526
 527         eidFromMac = LispAddressUtil.asMacEid(MAC_ADDRESS_VALUE_TEST);
 528         verifyToEidWithMacAddress(eidFromMac, false);
 529
 530         eidFromMac = LispAddressUtil.asMacEid(MAC_ADDRESS_VALUE_TEST, INSTANCE_ID_TYPE_VALUE_TEST);
 531         verifyToEidWithMacAddress(eidFromMac, true);
 532     }
 533
 534     /**
 535      * Test
 536      * - {@link LispAddressUtil#toEid(Ipv6Address, InstanceIdType)}
 537      * - {@link LispAddressUtil#toEid(Ipv6AddressBinary, InstanceIdType)}
 538      * - {@link LispAddressUtil#asIpv6Eid(String)}
 539      * - {@link LispAddressUtil#asIpv6Eid(String, long)}
 540      * methods.
 541      */
 542     @Test
 543     public void toEid_ipv6() {
 544         Eid eidFromIpv6 = LispAddressUtil.toEid(IPV6_ADDRESS_TEST, INSTANCE_ID_TYPE_TEST);
 545         verifyToEidWithIpv6(eidFromIpv6, true);
 546
 547         eidFromIpv6 = LispAddressUtil.toEid(IPV6_ADDRESS_BINARY_TEST, INSTANCE_ID_TYPE_TEST);
 548         verifyToEidWithIpv6Binary(eidFromIpv6, true);
 549
 550         eidFromIpv6 = LispAddressUtil.asIpv6Eid(IPV6_ADDRESS_VALUE_TEST);
 551         verifyToEidWithIpv6Binary(eidFromIpv6, false);
 552
 553         eidFromIpv6 = LispAddressUtil.asIpv6Eid(IPV6_ADDRESS_VALUE_TEST, INSTANCE_ID_TYPE_VALUE_TEST);
 554         verifyToEidWithIpv6Binary(eidFromIpv6, true);
 555     }
 556
 557     /**
 558      * Test
 559      * - {@link LispAddressUtil#toEid(Ipv4Prefix, InstanceIdType)}
 560      * - {@link LispAddressUtil#asIpv4PrefixEid(String)}
 561      * - {@link LispAddressUtil#asIpv4PrefixEid(Eid, Inet4Address, short)}
 562      * - {@link LispAddressUtil#asIpv4PrefixEid(Ipv4Address, InstanceIdType)}  }
 563      * methods.
 564      */
 565     @Test
 566     public void toEid_ipv4Prefix() throws UnknownHostException {
 567         Eid eidFromIpv4Prefix = LispAddressUtil.toEid(IPV4_ADDRESS_PREFIX_TEST, INSTANCE_ID_TYPE_TEST);
 568         verifyToEidWithIpv4Prefix(eidFromIpv4Prefix, true, MASK_OK_TEST, Ipv4PrefixAfi.class);
 569
 570         eidFromIpv4Prefix  = LispAddressUtil.asIpv4PrefixEid(IPV4_ADDRESS_PREFIX_VALUE_TEST);
 571         verifyToEidWithIpv4Prefix(eidFromIpv4Prefix, false, MASK_OK_TEST, Ipv4PrefixAfi.class);
 572
 573         eidFromIpv4Prefix  = LispAddressUtil.asIpv4PrefixEid(IPV4_ADDRESS_TEST, INSTANCE_ID_TYPE_TEST);
 574     }
 575
 576     public Eid provideDummyMacEid() {
 577         final EidBuilder eidBuilder = new EidBuilder();
 578         eidBuilder.setAddressType(MacAfi.class);
 579         eidBuilder.setVirtualNetworkId(INSTANCE_ID_TYPE_TEST);
 580         return eidBuilder.build();
 581     }
 582
 583     /**
 584      * Test
 585      * - {@link LispAddressUtil#toEid(Ipv4Address, InstanceIdType)}
 586      * - {@link LispAddressUtil#toEid(Ipv4AddressBinary, InstanceIdType)}
 587      * - {@link LispAddressUtil#asIpv4Eid(String)}
 588      * - {@link LispAddressUtil#asIpv4Eid(String, long)}
 589      * methods.
 590      */
 591     @Test
 592     public void toEid_ipv4() {
 593         Eid eidFromIpv4 = LispAddressUtil.toEid(IPV4_ADDRESS_TEST, INSTANCE_ID_TYPE_TEST);
 594         verifyToEidWithIpv4(eidFromIpv4, true);
 595
 596         eidFromIpv4 = LispAddressUtil.toEid(IPV4_ADDRESS_BINARY_TEST, INSTANCE_ID_TYPE_TEST);
 597         verifyToEidWithIpv4Binary(eidFromIpv4, true);
 598
 599         eidFromIpv4 = LispAddressUtil.asIpv4Eid(IPV4_ADDRESS_VALUE_TEST);
 600         verifyToEidWithIpv4Binary(eidFromIpv4, false);
 601
 602         eidFromIpv4 = LispAddressUtil.asIpv4Eid(IPV4_ADDRESS_VALUE_TEST, INSTANCE_ID_TYPE_VALUE_TEST);
 603         verifyToEidWithIpv4Binary(eidFromIpv4, true);
 604     }
 605
 606     /**
 607      * Test
 608      * - {@link LispAddressUtil#toEid(IpPrefix, InstanceIdType)}
 609      * method.
 610      */
 611     @Test
 612     public void toEid_ipPrefix() {
 613         final Eid eidFromIpPrefix = LispAddressUtil.toEid(IP_ADDRESS_PREFIX_WITH_IPV4_TEST, INSTANCE_ID_TYPE_TEST);
 614         verifyToEidWithIpv4Prefix(eidFromIpPrefix, true, MASK_OK_TEST, Ipv4PrefixAfi.class);
 615     }
 616
 617     /**
 618      * Test
 619      * - {@link LispAddressUtil#toEid(DistinguishedNameType, InstanceIdType)}
 620      * - {@link LispAddressUtil#asDistinguishedNameEid(String)}
 621      * - {@link LispAddressUtil#asDistinguishedNameEid(String, long)}
 622      * methods with various input.
 623      */
 624     @Test
 625     public void toEid_distinguishedName() {
 626         Eid eidFromDistinguishedName = LispAddressUtil.toEid(DISTINGUISHED_NAME_TYPE_TEST, INSTANCE_ID_TYPE_TEST);
 627         verifyToEidWithDistinguishedName(eidFromDistinguishedName, true);
 628
 629         eidFromDistinguishedName = LispAddressUtil.asDistinguishedNameEid(DISTINGUISHED_NAME_TYPE_VALUE_TEST);
 630         verifyToEidWithDistinguishedName(eidFromDistinguishedName, false);
 631
 632         eidFromDistinguishedName = LispAddressUtil.asDistinguishedNameEid
 633                 (DISTINGUISHED_NAME_TYPE_VALUE_WITH_MAC_TEST, INSTANCE_ID_TYPE_VALUE_TEST);
 634         verifyToEidWithMacAddress(eidFromDistinguishedName, true);
 635     }
 636
 637     private void verifyToEidWithIpv6Prefix(final Eid eidFromIpv6Prefix, final boolean isVniChecked, short
 638             expectedMask, final Class<? extends org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp
 639             .address.types.rev151105.LispAddressFamily> addressType) {
 640         assertEquals(addressType, eidFromIpv6Prefix.getAddressType());
 641         if (isVniChecked) {
 642             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv6Prefix.getVirtualNetworkId());
 643         }
 644         assertEquals(IPV6_ADDRESS_VALUE_TEST + "/" + expectedMask, ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml
 645                 .ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6Prefix) eidFromIpv6Prefix
 646                 .getAddress()).getIpv6Prefix().getValue());
 647     }
 648
 649     private void verifyToEidWithIpv4(final Eid eidFromIpv4, final boolean isVniChecked) {
 650         assertEquals(Ipv4Afi.class, eidFromIpv4.getAddressType());
 651         if (isVniChecked) {
 652             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv4.getVirtualNetworkId());
 653         }
 654         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4) eidFromIpv4.getAddress()).getIpv4().getValue());
 655     }
 656
 657     private void verifyToEidWithIpv4Binary(final Eid eidFromIpv4, final boolean isVniChecked) {
 658         assertEquals(Ipv4BinaryAfi.class, eidFromIpv4.getAddressType());
 659         if (isVniChecked) {
 660             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv4.getVirtualNetworkId());
 661         }
 662         assertArrayEquals(IPV4_ADDRESS_BYTES_A_TEST,
 663                 ((Ipv4Binary) eidFromIpv4.getAddress()).getIpv4Binary().getValue());
 664     }
 665
 666     private void verifyToEidWithIpv6(final Eid eidFromIpv6, final boolean isVniChecked) {
 667         assertEquals(Ipv6Afi.class, eidFromIpv6.getAddressType());
 668         if (isVniChecked) {
 669             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv6.getVirtualNetworkId());
 670         }
 671         assertEquals(IPV6_ADDRESS_VALUE_TEST, ((Ipv6) eidFromIpv6.getAddress()).getIpv6().getValue());
 672     }
 673
 674     private void verifyToEidWithIpv4Prefix(final Eid eidFromIpv4Prefix, final boolean isVniChecked, short
 675             expectedMask, Class<? extends org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address
 676             .types.rev151105.LispAddressFamily>  addressType) {
 677         assertEquals(addressType, eidFromIpv4Prefix.getAddressType());
 678         if (isVniChecked) {
 679             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv4Prefix.getVirtualNetworkId());
 680         }
 681         assertEquals(IPV4_ADDRESS_VALUE_TEST + "/" + expectedMask, ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns
 682                 .yang.ietf
 683                 .lisp.address.types.rev151105.lisp.address.address.Ipv4Prefix) eidFromIpv4Prefix.getAddress())
 684                 .getIpv4Prefix().getValue());
 685     }
 686
 687     private void verifyToEidWithIpv6Binary(final Eid eidFromIpv6, final boolean isVniChecked) {
 688         assertEquals(Ipv6BinaryAfi.class, eidFromIpv6.getAddressType());
 689         if (isVniChecked) {
 690             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv6.getVirtualNetworkId());
 691         }
 692         assertArrayEquals(IPV6_ADDRESS_BYTES_A_TEST,
 693                 ((Ipv6Binary) eidFromIpv6.getAddress()).getIpv6Binary().getValue());
 694     }
 695
 696     private void verifyToEidWithDistinguishedName(final Eid eidFromDistinguishedName, final boolean isVniChecked) {
 697         assertEquals(DistinguishedNameAfi.class, eidFromDistinguishedName.getAddressType());
 698         if (isVniChecked) {
 699             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromDistinguishedName.getVirtualNetworkId());
 700         }
 701         assertEquals(DISTINGUISHED_NAME_TYPE_TEST, ((DistinguishedName) eidFromDistinguishedName.getAddress())
 702                 .getDistinguishedName());
 703     }
 704
 705     private void verifyToEidWithMacAddress(final Eid eidFromMac, final boolean isVniChecked) {
 706         assertEquals(MacAfi.class, eidFromMac.getAddressType());
 707         if (isVniChecked) {
 708             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromMac.getVirtualNetworkId());
 709         }
 710         assertEquals(MAC_ADDRESS_VALUE_TEST, ((Mac) eidFromMac.getAddress()).getMac().getValue());
 711     }
 712
 713     /**
 714      * Tests {@link LispAddressUtil#asIpPrefix(String, int)} with ipv4 address and correct mask
 715      */
 716     @Test
 717     public void asIpPrefix_ipv4() {
 718         final IpPrefix ipPrefix = LispAddressUtil.asIpPrefix(IPV4_ADDRESS_VALUE_TEST, MASK_OK_TEST);
 719         assertNotNull(ipPrefix);
 720         final Ipv4Prefix ipv4Prefix = ipPrefix.getIpv4Prefix();
 721         assertNotNull(ipv4Prefix);
 722         assertEquals(IPV4_ADDRESS_PREFIX_TEST, ipv4Prefix);
 723     }
 724
 725     /**
 726      * Tests {@link LispAddressUtil#asIpPrefix(String, int)} with ipv6 address and correct mask
 727      */
 728     @Test
 729     public void asIpPrefix_ipv6() {
 730         final IpPrefix ipPrefix = LispAddressUtil.asIpPrefix(IPV6_ADDRESS_VALUE_TEST, MASK_OK_TEST);
 731         assertNotNull(ipPrefix);
 732         final Ipv6Prefix ipv6Prefix = ipPrefix.getIpv6Prefix();
 733         assertNotNull(ipv6Prefix);
 734         assertEquals(IPV6_ADDRESS_PREFIX_TEST, ipv6Prefix);
 735     }
 736
 737     /**
 738      * Tests {@link LispAddressUtil#asIpPrefix(String, int)} with incorrect ip address and correct mask
 739      */
 740     @Test
 741     public void asIpPrefix_other() {
 742         final IpPrefix ipPrefix = LispAddressUtil.asIpPrefix(INCORRECT_IP_ADDRESS_TEST, MASK_OK_TEST);
 743         assertNull(ipPrefix);
 744     }
 745
 746     /**
 747      * Tests {@link LispAddressUtil#ipVersionFromString(String)} with ipv4
 748      */
 749     @Test
 750     public void ipVersionFromString_ipv4() {
 751         final int addressType = LispAddressUtil.ipVersionFromString(IPV4_ADDRESS_VALUE_TEST);
 752         assertEquals(4, addressType);
 753     }
 754
 755     /**
 756      * Tests {@link LispAddressUtil#ipVersionFromString(String)} with ipv6
 757      */
 758     @Test
 759     public void ipVersionFromString_ipv6() {
 760         final int addressType = LispAddressUtil.ipVersionFromString(IPV6_ADDRESS_VALUE_TEST);
 761         assertEquals(6, addressType);
 762     }
 763
 764     /**
 765      * Tests {@link LispAddressUtil#ipVersionFromString(String)} with incorrect ip address format
 766      */
 767     @Test
 768     public void ipVersionFromString_other() {
 769         final int addressType = LispAddressUtil.ipVersionFromString(INCORRECT_IP_ADDRESS_TEST);
 770         assertEquals(0, addressType);
 771
 772     }
 773
 774     /**
 775      * Tests {@link LispAddressUtil#asKeyValueAddressEid(SimpleAddress, SimpleAddress)} method.
 776      */
 777     @Test
 778     public void asKeyValueAddressEid() {
 779         final Eid eid = LispAddressUtil.asKeyValueAddressEid(SIMPLE_ADDRESS_A_TEST, SIMPLE_ADDRESS_B_TEST);
 780         verifyKeyValueAddress(eid, SIMPLE_ADDRESS_A_TEST);
 781     }
 782
 783     /**
 784      * Tests {@link LispAddressUtil#asKeyValueAddressRloc(SimpleAddress, SimpleAddress)} method.
 785      */
 786     @Test
 787     public void asKeyValueAddressRloc() {
 788         final Rloc rloc = LispAddressUtil.asKeyValueAddressRloc(SIMPLE_ADDRESS_A_TEST, SIMPLE_ADDRESS_B_TEST);
 789         verifyKeyValueAddress(rloc, SIMPLE_ADDRESS_A_TEST);
 790     }
 791
 792     /**
 793      * Tests {@link LispAddressUtil#asKeyValueAddress(String, SimpleAddress)} method.
 794      */
 795     @Test
 796     public void asKeyValueAddress() {
 797         final Rloc rloc = LispAddressUtil.asKeyValueAddress(SIMPLE_ADDRESS_DISTINGUISHED_VALUE_TEST,
 798                 SIMPLE_ADDRESS_B_TEST);
 799         verifyKeyValueAddress(rloc, SIMPLE_ADDRESS_DISTINGUISHED_TEST);
 800     }
 801
 802     private void verifyKeyValueAddress(final LispAddress lispAddress, final SimpleAddress keyValue) {
 803         assertEquals(KeyValueAddressLcaf.class, lispAddress.getAddressType());
 804         assertNull(lispAddress.getVirtualNetworkId());
 805         final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
 806                 .lisp.address.address.key.value.address.KeyValueAddress keyValueAddress =
 807                 ((KeyValueAddress) lispAddress.getAddress()).getKeyValueAddress();
 808         assertNotNull(keyValueAddress);
 809         assertEquals(keyValue, keyValueAddress.getKey());
 810         assertEquals(SIMPLE_ADDRESS_B_TEST, keyValueAddress.getValue());
 811     }
 812
 813     /**
 814      * Tests {@link LispAddressUtil#asSrcDst(String, String, int, int)} method.
 815      */
 816     @Test
 817     public void asSrcDst() {
 818         final SourceDestKey sourceDestKey = LispAddressUtil.asSrcDst(IPV4_ADDRESS_VALUE_TEST,
 819                 IPV6_ADDRESS_VALUE_TEST, MASK_OK_TEST, MASK_OK_TEST);
 820         assertNotNull(sourceDestKey);
 821         assertEquals(SIMPLE_ADDRESS_WITH_IP_PREFIX_IPV4_TEST, sourceDestKey.getSource());
 822         assertEquals(SIMPLE_ADDRESS_WITH_IP_PREFIX_IPV6_TEST, sourceDestKey.getDest());
 823     }
 824
 825     /**
 826      * Tests {@link LispAddressUtil#asSrcDstEid(String, String, int, int, int)} method.
 827      */
 828     @Test
 829     public void asSrcDstEid_addressesAsString() {
 830         final Eid srcDstEid = LispAddressUtil.asSrcDstEid(IPV4_ADDRESS_VALUE_TEST,
 831                 IPV6_ADDRESS_VALUE_TEST, MASK_OK_TEST, MASK_OK_TEST, INSTANCE_ID_TYPE_VALUE_SHORT_TEST);
 832         assertNotNull(srcDstEid);
 833         assertEquals(SourceDestKeyLcaf.class, srcDstEid.getAddressType());
 834         final SourceDestKey sourceDestKey = ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns
 835                 .yang.ietf.lisp.address.types.rev151105.lisp.address.address.SourceDestKey) srcDstEid.getAddress())
 836                 .getSourceDestKey();
 837         assertNotNull(sourceDestKey);
 838         assertEquals(SIMPLE_ADDRESS_WITH_IP_PREFIX_IPV4_TEST, sourceDestKey.getSource());
 839         assertEquals(SIMPLE_ADDRESS_WITH_IP_PREFIX_IPV6_TEST, sourceDestKey.getDest());
 840     }
 841
 842     /**
 843      * Tests {@link LispAddressUtil#asSrcDstEid(SourceDestKey, InstanceIdType)}  method.
 844      */
 845     @Test
 846     public void asSrcDstEid_addressesAsSrcDstKey() {
 847         final SourceDestKey expectedSourceDestKey = new SourceDestKeyBuilder().setSource
 848                 (SIMPLE_ADDRESS_WITH_IP_PREFIX_IPV4_TEST).setDest(SIMPLE_ADDRESS_WITH_IP_PREFIX_IPV6_TEST).build();
 849         final Eid srcDstEid = LispAddressUtil.asSrcDstEid(expectedSourceDestKey, INSTANCE_ID_TYPE_TEST);
 850         assertNotNull(srcDstEid);
 851         assertEquals(SourceDestKeyLcaf.class, srcDstEid.getAddressType());
 852         final SourceDestKey testedSourceDestKey = ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns
 853                 .yang.ietf.lisp.address.types.rev151105.lisp.address.address.SourceDestKey) srcDstEid.getAddress())
 854                 .getSourceDestKey();
 855         assertNotNull(testedSourceDestKey);
 856         assertEquals(SIMPLE_ADDRESS_WITH_IP_PREFIX_IPV4_TEST, testedSourceDestKey.getSource());
 857         assertEquals(SIMPLE_ADDRESS_WITH_IP_PREFIX_IPV6_TEST, testedSourceDestKey.getDest());
 858     }
 859
 860     /**
 861      * Tests {@link LispAddressUtil#asSrcDstEid(SourceDestKey, InstanceIdType)}  method.
 862      */
 863     @Test
 864     public void asTeLcafRloc() {
 865         final List<IpAddress> ipAddresses = Arrays.asList(IP_ADDRESS_OBJECT_WITH_IPV4_TEST,
 866                 IP_ADDRESS_OBJECT_WITH_IPV6_TEST);
 867         final Rloc rloc = LispAddressUtil.asTeLcafRloc(ipAddresses);
 868         assertNotNull(rloc);
 869         assertEquals(ExplicitLocatorPathLcaf.class, rloc.getAddressType());
 870         final List<Hop> hops = ((ExplicitLocatorPath) rloc.getAddress()).getExplicitLocatorPath().getHop();
 871         assertEquals(hops.size(), ipAddresses.size());
 872
 873         for(IpAddress ipAddress : ipAddresses) {
 874             assertTrue("Ip address "+ipAddress+"should be part of hops list.",isIpAddressInHops(ipAddress, hops));
 875         }
 876
 877         for(Hop hop : hops) {
 878             final Hop.LrsBits lrsBits = hop.getLrsBits();
 879             assertFalse(lrsBits.isLookup());
 880             assertFalse(lrsBits.isRlocProbe());
 881             assertFalse(lrsBits.isStrict());
 882
 883             final IpAddress ipAddressFromHop = hop.getAddress().getIpAddress();
 884             assertNotNull(ipAddressFromHop);
 885         }
 886     }
 887
 888     private boolean isIpAddressInHops(final IpAddress ipAddress, final List<Hop> hops) {
 889         for (Hop hop : hops) {
 890             if (hop.getAddress().getIpAddress().equals(ipAddress)) {
 891                 return true;
 892             }
 893         }
 894         return false;
 895     }
 896
 897     /**
 898      * Tests {@link LispAddressUtil#asLocatorRecords(List)}  method.
 899      */
 900     @Test
 901     public void asLocatorRecords() {
 902         final List<Rloc> expectedRlocs = Arrays.asList(LispAddressUtil.toRloc(IPV4_ADDRESS_TEST), LispAddressUtil.toRloc
 903                 (IPV6_ADDRESS_TEST));
 904         final List<LocatorRecord> locatorRecords = LispAddressUtil.asLocatorRecords(expectedRlocs);
 905
 906         assertEquals(expectedRlocs.size(), locatorRecords.size());
 907
 908         for (Rloc rloc : expectedRlocs) {
 909             assertTrue("Rloc " + rloc + " should be part of " +
 910                     "locator records list list", isRlocInLocatorRecords(locatorRecords, rloc));
 911         }
 912
 913         for (LocatorRecord locatorRecord : locatorRecords) {
 914             assertFalse(locatorRecord.isLocalLocator());
 915             assertFalse(locatorRecord.isRlocProbed());
 916             assertTrue(locatorRecord.isRouted());
 917             assertTrue(1 == locatorRecord.getWeight());
 918             assertTrue(1 == locatorRecord.getPriority());
 919             assertTrue(1 == locatorRecord.getMulticastWeight());
 920             assertTrue(1 == locatorRecord.getMulticastPriority());
 921             assertEquals("SFC_LISP", locatorRecord.getLocatorId());
 922         }
 923     }
 924
 925     private boolean isRlocInLocatorRecords(final List<LocatorRecord> locatorRecords, final Rloc rloc) {
 926         for (LocatorRecord locatorRecord : locatorRecords) {
 927             if (locatorRecord.getRloc().equals(rloc)) {
 928                 return true;
 929             }
 930         }
 931         return false;
 932     }
 933
 934     /**
 935      * Tests {@link LispAddressUtil#getNoAddressEid()}  method.
 936      */
 937     @Test
 938     public void getNoAddressEid() {
 939         final Eid noAddressEid = LispAddressUtil.getNoAddressEid();
 940         assertEquals(NoAddressAfi.class, noAddressEid.getAddressType());
 941         assertNull(noAddressEid.getVirtualNetworkId());
 942         assertTrue(((NoAddress) noAddressEid.getAddress()).isNoAddress());
 943     }
 944
 945     /**
 946      * Tests {@link LispAddressUtil#ipAddressToByteArray(Address)} method with ipv4 value.
 947      */
 948     @Test
 949     public void ipAddressToByteArray_ipv4() {
 950         final Ipv4 expectedIpv4 = new Ipv4Builder().setIpv4(IPV4_ADDRESS_TEST).build();
 951         final byte[] testedAddress = LispAddressUtil.ipAddressToByteArray(expectedIpv4);
 952         assertArrayEquals(IPV4_ADDRESS_BYTES_A_TEST, testedAddress);
 953     }
 954
 955     /**
 956      * Tests {@link LispAddressUtil#ipAddressToByteArray(Address)} method with ipv6 value.
 957      */
 958     @Test
 959     public void ipAddressToByteArray_ipv6() {
 960         final Ipv6 expectedIpv6 = new Ipv6Builder().setIpv6(IPV6_ADDRESS_TEST).build();
 961         final byte[] testedAddress = LispAddressUtil.ipAddressToByteArray(expectedIpv6);
 962         assertArrayEquals(IPV6_ADDRESS_BYTES_A_TEST, testedAddress);
 963     }
 964
 965     /**
 966      * Tests {@link LispAddressUtil#ipAddressToByteArray(Address)} method with mac value.
 967      */
 968     @Test
 969     public void ipAddressToByteArray_other() {
 970         final byte[] testedAddress = LispAddressUtil.ipAddressToByteArray(new MacBuilder().build());
 971         assertNull(testedAddress);
 972     }
 973
 974     /**
 975      * Tests {@link LispAddressUtil#compareIpAddressByteArrays(byte[], byte[])} with all possible combination
 976      * of input parameters to reach 100 % coverage.
 977      */
 978     @Test
 979     public void compareIpAddressByteArrays() throws UnknownHostException {
 980         int comparisonResult = LispAddressUtil.compareIpAddressByteArrays(IPV4_ADDRESS_BYTES_A_TEST,
 981                 IPV6_ADDRESS_BYTES_A_TEST);
 982         assertEquals(-1, comparisonResult);
 983
 984         comparisonResult = LispAddressUtil.compareIpAddressByteArrays(IPV6_ADDRESS_BYTES_A_TEST,
 985                 IPV4_ADDRESS_BYTES_A_TEST);
 986         assertEquals(1, comparisonResult);
 987
 988         comparisonResult = LispAddressUtil.compareIpAddressByteArrays(IPV4_ADDRESS_BYTES_A_TEST,
 989                 IPV4_ADDRESS_BYTES_B_TEST);
 990         assertEquals(-1, comparisonResult);
 991
 992         comparisonResult = LispAddressUtil.compareIpAddressByteArrays(IPV4_ADDRESS_BYTES_B_TEST,
 993                 IPV4_ADDRESS_BYTES_A_TEST);
 994         assertEquals(1, comparisonResult);
 995
 996         comparisonResult = LispAddressUtil.compareIpAddressByteArrays(IPV4_ADDRESS_BYTES_B_TEST,
 997                 IPV4_ADDRESS_BYTES_B_TEST);
 998         assertEquals(0, comparisonResult);
 999
1000         comparisonResult = LispAddressUtil.compareIpAddressByteArrays(IPV6_ADDRESS_BYTES_A_TEST,
1001                 IPV6_ADDRESS_BYTES_B_TEST);
1002         assertEquals(-1, comparisonResult);
1003
1004         comparisonResult = LispAddressUtil.compareIpAddressByteArrays(IPV6_ADDRESS_BYTES_B_TEST,
1005                 IPV6_ADDRESS_BYTES_A_TEST);
1006         assertEquals(1, comparisonResult);
1007
1008         comparisonResult = LispAddressUtil.compareIpAddressByteArrays(IPV6_ADDRESS_BYTES_B_TEST,
1009                 IPV6_ADDRESS_BYTES_B_TEST);
1010         assertEquals(0, comparisonResult);
1011
1012     }
1013
1014     /**
1015      * Tests {@link LispAddressUtil#asServicePathEid(long, long, short)} method.
1016      */
1017     @Test
1018     public void asServicePathEid() {
1019         final Eid eid = LispAddressUtil.asServicePathEid(INSTANCE_ID_TYPE_VALUE_TEST, SERVICE_PATH_ID_TEST,
1020                 SERVICE_INDEX_TEST);
1021
1022         assertNotNull(eid);
1023         assertEquals(ServicePathLcaf.class, eid.getAddressType());
1024         assertEquals(INSTANCE_ID_TYPE_TEST, eid.getVirtualNetworkId());
1025         ServicePath servicePath = ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.
1026                 address.types.rev151105.lisp.address.address.ServicePath) eid.getAddress()).getServicePath();
1027         assertNotNull(servicePath);
1028         assertEquals(SERVICE_INDEX_TEST, servicePath.getServiceIndex());
1029         assertEquals(SERVICE_PATH_ID_TEST, servicePath.getServicePathId().getValue());
1030     }
1031
1032     /**
1033      * Tests {@link LispAddressUtil#toIpPrefixEid(IpAddress, int)} method.
1034      */
1035     @Test
1036     public void toIpPrefixEid() throws UnknownHostException {
1037         final Eid eid = LispAddressUtil.toIpPrefixEid(IP_ADDRESS_OBJECT_WITH_IPV4_TEST,
1038                 INSTANCE_ID_TYPE_VALUE_SHORT_TEST);
1039         verifyEidContainsIpPrefix(eid, MASK_OK_DEFAULT_IPV4_TEST);
1040     }
1041
1042     /**
1043      * Tests {@link LispAddressUtil#toEidNoVni(IpPrefix)} method.
1044      */
1045     @Test
1046     public void toEidNoVni() {
1047         final Eid eid = LispAddressUtil.toEidNoVni(IP_ADDRESS_PREFIX_WITH_IPV4_TEST);
1048         verifyEidContainsIpPrefix(eid, MASK_OK_TEST);
1049     }
1050
1051     public void verifyEidContainsIpPrefix(final Eid eid, final short mask) {
1052         final Ipv4Prefix expectedPrefix = new Ipv4Prefix(IPV4_ADDRESS_VALUE_TEST + "/" + mask);
1053         assertNotNull(eid);
1054         assertTrue(eid.getAddress() instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp
1055                 .address.types.rev151105.lisp.address.address.Ipv4Prefix);
1056         final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address
1057                 .address.Ipv4Prefix address = (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp
1058                 .address.types.rev151105.lisp.address.address.Ipv4Prefix) eid.getAddress();
1059         assertEquals(expectedPrefix, address.getIpv4Prefix());
1060     }
1061
1062     /**
1063      * Tests {@link LispAddressUtil#asEid(SimpleAddress, InstanceIdType)} method.
1064      */
1065     @Test
1066     public void asEid() {
1067         final Eid eid = LispAddressUtil.asEid(SIMPLE_ADDRESS_A_TEST, INSTANCE_ID_TYPE_TEST);
1068         assertNotNull(eid);
1069         assertEquals(Ipv4BinaryAfi.class, eid.getAddressType());
1070         final Ipv4Binary address = (Ipv4Binary) eid.getAddress();
1071         assertArrayEquals(InetAddresses.forString(SIMPLE_ADDRESS_A_TEST.getIpAddress().getIpv4Address().getValue())
1072                 .getAddress(), address.getIpv4Binary().getValue());
1073         assertEquals(INSTANCE_ID_TYPE_TEST, eid.getVirtualNetworkId());
1074     }
1075
1076 }
1077