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