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.Test;
  24 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.AsNumber;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
  27 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
  28 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
  29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv6Address;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv6Prefix;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.AsNumberAfi;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.DistinguishedNameAfi;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.DistinguishedNameType;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.ExplicitLocatorPathLcaf;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.InstanceIdType;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4Afi;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4PrefixAfi;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv6Afi;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv6PrefixAfi;
  40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.KeyValueAddressLcaf;
  41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.LispAddress;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.LispAddressFamily;
  43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.MacAfi;
  44 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.NoAddressAfi;
  45 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.ServicePathIdType;
  46 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.ServicePathLcaf;
  47 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SimpleAddress;
  48 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SourceDestKeyLcaf;
  49 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.Address;
  50 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.DistinguishedName;
  51 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.ExplicitLocatorPath;
  52 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4;
  53 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4Builder;
  54 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6;
  55 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6Builder;
  56 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.KeyValueAddress;
  57 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Mac;
  58 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.MacBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.NoAddress;
  60 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;
  61 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.service.path.ServicePath;
  62 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.source.dest.key.SourceDestKey;
  63 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.source.dest.key.SourceDestKeyBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.EidBuilder;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecord;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
  69
  70 public class LispAddressUtilTest {
  71
  72
  73     private static final char[] DUMMY_CHARACTER_ARRAY_TEST = new char[]{'a', 'b', 'c', 'd'};
  74     private static final Long NUMBER_TEST = 5L;
  75
  76     private static final String MAC_ADDRESS_VALUE_TEST = "aa:bb:cc:dd:ee:ff";
  77     private static final MacAddress MAC_ADDRESS_TEST = new MacAddress("aa:bb:cc:dd:ee:ff");
  78
  79     private static final byte[] IPV4_ADDRESS_BYTES_A_TEST = new byte[]{(byte) 192, (byte) 168, 1, 1};
  80     private static final byte[] IPV4_ADDRESS_BYTES_B_TEST = new byte[]{(byte) 192, (byte) 168, 1, 2};
  81
  82     private static final short MASK_OK_TEST = 30;
  83     private static final short MASK_OK_DEFAULT_IPV4_TEST = 32;
  84     private static final short MASK_OK_DEFAULT_IPV6_TEST = 128;
  85
  86     private static final String IPV4_ADDRESS_VALUE_TEST = "192.168.1.1";
  87     private static final String IPV4_ADDRESS_PREFIX_VALUE_TEST = IPV4_ADDRESS_VALUE_TEST + "/" + MASK_OK_TEST;
  88     private static final Ipv4Address IPV4_ADDRESS_TEST = new Ipv4Address(IPV4_ADDRESS_VALUE_TEST);
  89     private static final IpAddress IP_ADDRESS_OBJECT_WITH_IPV4_TEST = new IpAddress(IPV4_ADDRESS_TEST);
  90     private static final Ipv4Prefix IPV4_ADDRESS_PREFIX_TEST = new Ipv4Prefix(IPV4_ADDRESS_PREFIX_VALUE_TEST);
  91     private static final IpPrefix IP_ADDRESS_PREFIX_WITH_IPV4_TEST = new IpPrefix(IPV4_ADDRESS_PREFIX_TEST);
  92
  93
  94     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,
  95             15, 16};
  96     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,
  97             15, 17};
  98     private static final String IPV6_ADDRESS_VALUE_TEST = "102:304:506:708:90a:b0c:d0e:f10";
  99     private static final String IPV6_ADDRESS_PREFIX_VALUE_TEST = IPV6_ADDRESS_VALUE_TEST + "/" + MASK_OK_TEST;
 100     private static final Ipv6Prefix IPV6_ADDRESS_PREFIX_TEST = new Ipv6Prefix(IPV6_ADDRESS_PREFIX_VALUE_TEST);
 101     private static final Ipv6Address IPV6_ADDRESS_TEST = new Ipv6Address(IPV6_ADDRESS_VALUE_TEST);
 102     private static final IpPrefix IP_ADDRESS_PREFIX_WITH_IPV6_TEST = new IpPrefix(IPV6_ADDRESS_PREFIX_TEST);
 103     private static final IpAddress IP_ADDRESS_OBJECT_WITH_IPV6_TEST = new IpAddress(IPV6_ADDRESS_TEST);
 104
 105     private static final Short SERVICE_INDEX_TEST = 45;
 106     private static final Long DUMMY_SERVICE_PATH_ID_TYPE = 46L;
 107     private static final String DISTINGUISHED_NAME_TYPE_VALUE_TEST = "dummy distinguished name type";
 108     private static final String DISTINGUISHED_NAME_TYPE_VALUE_WITH_MAC_TEST = MAC_ADDRESS_VALUE_TEST;
 109     private static final DistinguishedNameType DISTINGUISHED_NAME_TYPE_TEST = new DistinguishedNameType
 110             (DISTINGUISHED_NAME_TYPE_VALUE_TEST);
 111
 112     private static final Long AS_NUMBER_TEST = 100L;
 113     private static final Long INSTANCE_ID_TYPE_VALUE_TEST = 121L;
 114     private static final Short INSTANCE_ID_TYPE_VALUE_SHORT_TEST = 122;
 115     private static final InstanceIdType INSTANCE_ID_TYPE_TEST = new InstanceIdType(INSTANCE_ID_TYPE_VALUE_TEST);
 116     private static final String INCORRECT_IP_ADDRESS_TEST = "incorrect ip address";
 117
 118     private static final SimpleAddress SIMPLE_ADDRESS_A_TEST = new SimpleAddress(IP_ADDRESS_OBJECT_WITH_IPV4_TEST);
 119     private static final SimpleAddress SIMPLE_ADDRESS_B_TEST = new SimpleAddress(MAC_ADDRESS_TEST);
 120     private static final String SIMPLE_ADDRESS_DISTINGUISHED_VALUE_TEST = DISTINGUISHED_NAME_TYPE_VALUE_TEST;
 121     private static final SimpleAddress SIMPLE_ADDRESS_DISTINGUISHED_TEST = new SimpleAddress(new DistinguishedNameType
 122             (SIMPLE_ADDRESS_DISTINGUISHED_VALUE_TEST));
 123     private static final SimpleAddress SIMPLE_ADDRESS_WITH_IP_PREFIX_IPV4_TEST = new SimpleAddress
 124             (IP_ADDRESS_PREFIX_WITH_IPV4_TEST);
 125     private static final SimpleAddress SIMPLE_ADDRESS_WITH_IP_PREFIX_IPV6_TEST = new SimpleAddress
 126             (IP_ADDRESS_PREFIX_WITH_IPV6_TEST);
 127     private static final Long SERVICE_PATH_ID_TEST = 2121L;
 128
 129     /**
 130      * Tests {@link LispAddressUtil#addressTypeFromSimpleAddress} and {@link
 131      * LispAddressUtil#addressFromSimpleAddress} methods
 132      * with ipAddress
 133      */
 134     @Test
 135     public void addressFromSimpleAddressTest_asAnyIpAddress() {
 136         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromSimpleAddress
 137                 (SIMPLE_ADDRESS_A_TEST);
 138         assertEquals(Ipv4Afi.class, addressClass);
 139
 140         final Address address = LispAddressUtil.addressFromSimpleAddress(SIMPLE_ADDRESS_A_TEST);
 141         assertTrue(address instanceof Ipv4);
 142     }
 143
 144     /**
 145      * Tests {@link LispAddressUtil#addressTypeFromSimpleAddress} and {@link
 146      * LispAddressUtil#addressFromSimpleAddress} methods
 147      * with ipPrefix
 148      */
 149     @Test
 150     public void addressFromSimpleAddressTest_asIpPrefix() {
 151         final SimpleAddress simpleAddress = new SimpleAddress(new IpPrefix(new Ipv4Prefix(
 152                 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.
 308                 lisp.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(
 399                 DISTINGUISHED_NAME_TYPE_VALUE_TEST);
 400         final Address testedAddress = LispAddressUtil.addressFromDistinguishedName(distinguishedNameType);
 401
 402         assertTrue(testedAddress instanceof DistinguishedName);
 403         assertEquals(distinguishedNameType, ((DistinguishedName) testedAddress).getDistinguishedName());
 404     }
 405
 406     /**
 407      * Test {@link LispAddressUtil#addressFromDistinguishedName(DistinguishedNameType)} method with null value }
 408      */
 409     @Test
 410     public void addressFromDistinguishedNameTest_withNull() {
 411         final Address testedAddress = LispAddressUtil.addressFromDistinguishedName(null);
 412         assertNull(testedAddress);
 413     }
 414
 415     /**
 416      * Test {@link LispAddressUtil#addressFromAsNumber(AsNumber)} method with as number value }
 417      */
 418     @Test
 419     public void addressFromAsNumberTest_withAdNumber() {
 420         final AsNumber expectedAddress = new AsNumber(AS_NUMBER_TEST);
 421         final Address testedAddress = LispAddressUtil.addressFromAsNumber(expectedAddress);
 422         assertTrue(testedAddress instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp
 423                 .address.types.rev151105.lisp.address.address.AsNumber);
 424         assertEquals(expectedAddress, ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp
 425                 .address.types.rev151105.lisp.address.address.AsNumber) testedAddress).getAsNumber());
 426     }
 427
 428     /**
 429      * Test {@link LispAddressUtil#addressFromAsNumber(AsNumber)} method with null instead of value }
 430      */
 431     @Test
 432     public void addressFromAsNumberTest_withNull() {
 433         final Address testedAddress = LispAddressUtil.addressFromAsNumber(null);
 434         assertNull(testedAddress);
 435     }
 436
 437
 438     /**
 439      * Tests:
 440      * - {@link LispAddressUtil#toRloc(InetAddress)}
 441      * - {@link LispAddressUtil#toRloc(Ipv4Address)}
 442      * - {@link LispAddressUtil#toRloc(Ipv6Address)}
 443      * - {@link LispAddressUtil#toRloc(SimpleAddress)}
 444      * methods.
 445      */
 446     @Test
 447     public void toRloc() throws UnknownHostException {
 448         InetAddress ipv4AddressInet = Inet4Address.getByAddress(IPV4_ADDRESS_BYTES_A_TEST);
 449         final Rloc rlocFromInetAddress = LispAddressUtil.toRloc(ipv4AddressInet);
 450         assertEquals(Ipv4Afi.class, rlocFromInetAddress.getAddressType());
 451         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4)rlocFromInetAddress.getAddress()).getIpv4().getValue());
 452
 453         final Rloc rlocFromIpv4Address = LispAddressUtil.toRloc(IPV4_ADDRESS_TEST);
 454         assertEquals(Ipv4Afi.class, rlocFromIpv4Address.getAddressType());
 455         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4) rlocFromIpv4Address.getAddress()).getIpv4().getValue());
 456
 457
 458         final Rloc rlocFromIpv6Address = LispAddressUtil.toRloc(IPV6_ADDRESS_TEST);
 459         assertEquals(Ipv6Afi.class, rlocFromIpv6Address.getAddressType());
 460         assertEquals(IPV6_ADDRESS_VALUE_TEST, ((Ipv6) rlocFromIpv6Address.getAddress()).getIpv6().getValue());
 461
 462         final Rloc rlocFromSimpleAddress = LispAddressUtil.toRloc(SIMPLE_ADDRESS_A_TEST);
 463         assertEquals(Ipv4Afi.class, rlocFromSimpleAddress.getAddressType());
 464         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4) rlocFromSimpleAddress.getAddress()).getIpv4().getValue());
 465     }
 466
 467     /**
 468      * Test {@link LispAddressUtil#asIpv4Rloc(String)} method with ipv4 or ipv6.
 469      * Test {@link LispAddressUtil#asIpv6Rloc(String)} method with ipv4 or ipv6.
 470      */
 471     @Test
 472     public void asIpvRloc() {
 473         final Rloc rlocFromIpV4 = LispAddressUtil.asIpv4Rloc(IPV4_ADDRESS_VALUE_TEST);
 474         assertEquals(Ipv4Afi.class, rlocFromIpV4.getAddressType());
 475         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4) rlocFromIpV4.getAddress()).getIpv4().getValue());
 476
 477         final Rloc rlocFromIpV6 = LispAddressUtil.asIpv6Rloc(IPV6_ADDRESS_VALUE_TEST);
 478         assertEquals(Ipv6Afi.class, rlocFromIpV6.getAddressType());
 479         assertEquals(IPV6_ADDRESS_VALUE_TEST, ((Ipv6) rlocFromIpV6.getAddress()).getIpv6().getValue());
 480     }
 481
 482     /**
 483      * Test
 484      * - {@link LispAddressUtil#toEid(Ipv6Address, InstanceIdType)}
 485      * - {@link LispAddressUtil#asIpv6PrefixEid(String)}
 486      * - {@link LispAddressUtil#asIpv6PrefixEid(Eid, Inet6Address, short)}
 487      * - {@link LispAddressUtil#asIpv6PrefixEid(Ipv6Address, InstanceIdType)}
 488      * methods.
 489      */
 490     @Test
 491     public void toEid_ipv6Prefix() throws UnknownHostException {
 492         Eid eidFromIpv6Prefix = LispAddressUtil.toEid(IPV6_ADDRESS_PREFIX_TEST, INSTANCE_ID_TYPE_TEST);
 493         verifyToEidWithIpv6Prefix(eidFromIpv6Prefix, true, MASK_OK_TEST, Ipv6PrefixAfi.class);
 494
 495         eidFromIpv6Prefix = LispAddressUtil.asIpv6PrefixEid(IPV6_ADDRESS_PREFIX_VALUE_TEST);
 496         verifyToEidWithIpv6Prefix(eidFromIpv6Prefix, false, MASK_OK_TEST, Ipv6PrefixAfi.class);
 497
 498         eidFromIpv6Prefix = LispAddressUtil.asIpv6PrefixEid(IPV6_ADDRESS_TEST, INSTANCE_ID_TYPE_TEST);
 499         verifyToEidWithIpv6Prefix(eidFromIpv6Prefix, true, MASK_OK_DEFAULT_IPV6_TEST, Ipv6PrefixAfi.class);
 500
 501     }
 502
 503     /**
 504      * Test
 505      * - {@link LispAddressUtil#toEid(MacAddress, InstanceIdType)}
 506      * - {@link LispAddressUtil#asMacEid(String)}
 507      * - {@link LispAddressUtil#asMacEid(String, long)}
 508      * methods.
 509      */
 510     @Test
 511     public void toEid_mac() {
 512         Eid eidFromMac = LispAddressUtil.toEid(MAC_ADDRESS_TEST, INSTANCE_ID_TYPE_TEST);
 513         verifyToEidWithMacAddress(eidFromMac, true);
 514
 515         eidFromMac = LispAddressUtil.asMacEid(MAC_ADDRESS_VALUE_TEST);
 516         verifyToEidWithMacAddress(eidFromMac, false);
 517
 518         eidFromMac = LispAddressUtil.asMacEid(MAC_ADDRESS_VALUE_TEST, INSTANCE_ID_TYPE_VALUE_TEST);
 519         verifyToEidWithMacAddress(eidFromMac, true);
 520     }
 521
 522     /**
 523      * Test
 524      * - {@link LispAddressUtil#toEid(Ipv6Address, InstanceIdType)}
 525      * - {@link LispAddressUtil#asIpv6Eid(String)}
 526      * - {@link LispAddressUtil#asIpv6Eid(String, long)}
 527      * methods.
 528      */
 529     @Test
 530     public void toEid_ipv6() {
 531         Eid eidFromIpv6 = LispAddressUtil.toEid(IPV6_ADDRESS_TEST, INSTANCE_ID_TYPE_TEST);
 532         verifyToEidWithIpv6(eidFromIpv6, true);
 533
 534         eidFromIpv6 = LispAddressUtil.asIpv6Eid(IPV6_ADDRESS_VALUE_TEST);
 535         verifyToEidWithIpv6(eidFromIpv6, false);
 536
 537         eidFromIpv6 = LispAddressUtil.asIpv6Eid(IPV6_ADDRESS_VALUE_TEST, INSTANCE_ID_TYPE_VALUE_TEST);
 538         verifyToEidWithIpv6(eidFromIpv6, true);
 539     }
 540
 541     /**
 542      * Test
 543      * - {@link LispAddressUtil#toEid(Ipv4Prefix, InstanceIdType)}
 544      * - {@link LispAddressUtil#asIpv4PrefixEid(String)}
 545      * - {@link LispAddressUtil#asIpv4PrefixEid(Eid, Inet4Address, short)}
 546      * - {@link LispAddressUtil#asIpv4PrefixEid(Ipv4Address, InstanceIdType)}  }
 547      * methods.
 548      */
 549     @Test
 550     public void toEid_ipv4Prefix() throws UnknownHostException {
 551         Eid eidFromIpv4Prefix = LispAddressUtil.toEid(IPV4_ADDRESS_PREFIX_TEST, INSTANCE_ID_TYPE_TEST);
 552         verifyToEidWithIpv4Prefix(eidFromIpv4Prefix, true, MASK_OK_TEST, Ipv4PrefixAfi.class);
 553
 554         eidFromIpv4Prefix  = LispAddressUtil.asIpv4PrefixEid(IPV4_ADDRESS_PREFIX_VALUE_TEST);
 555         verifyToEidWithIpv4Prefix(eidFromIpv4Prefix, false, MASK_OK_TEST, Ipv4PrefixAfi.class);
 556
 557         eidFromIpv4Prefix  = LispAddressUtil.asIpv4PrefixEid(IPV4_ADDRESS_TEST, INSTANCE_ID_TYPE_TEST);
 558     }
 559
 560     public Eid provideDummyMacEid() {
 561         final EidBuilder eidBuilder = new EidBuilder();
 562         eidBuilder.setAddressType(MacAfi.class);
 563         eidBuilder.setVirtualNetworkId(INSTANCE_ID_TYPE_TEST);
 564         return eidBuilder.build();
 565     }
 566
 567     /**
 568      * Test
 569      * - {@link LispAddressUtil#toEid(Ipv4Address, InstanceIdType)}
 570      * - {@link LispAddressUtil#asIpv4Eid(String)}
 571      * - {@link LispAddressUtil#asIpv4Eid(String, long)}
 572      * methods.
 573      */
 574     @Test
 575     public void toEid_ipv4() {
 576         Eid eidFromIpv4 = LispAddressUtil.toEid(IPV4_ADDRESS_TEST, INSTANCE_ID_TYPE_TEST);
 577         verifyToEidWithIpv4(eidFromIpv4, true);
 578
 579         eidFromIpv4 = LispAddressUtil.asIpv4Eid(IPV4_ADDRESS_VALUE_TEST);
 580         verifyToEidWithIpv4(eidFromIpv4, false);
 581
 582         eidFromIpv4 = LispAddressUtil.asIpv4Eid(IPV4_ADDRESS_VALUE_TEST, INSTANCE_ID_TYPE_VALUE_TEST);
 583         verifyToEidWithIpv4(eidFromIpv4, true);
 584     }
 585
 586     /**
 587      * Test
 588      * - {@link LispAddressUtil#toEid(IpPrefix, InstanceIdType)}
 589      * method.
 590      */
 591     @Test
 592     public void toEid_ipPrefix() {
 593         final Eid eidFromIpPrefix = LispAddressUtil.toEid(IP_ADDRESS_PREFIX_WITH_IPV4_TEST, INSTANCE_ID_TYPE_TEST);
 594         verifyToEidWithIpv4Prefix(eidFromIpPrefix, true, MASK_OK_TEST, Ipv4PrefixAfi.class);
 595     }
 596
 597     /**
 598      * Test
 599      * - {@link LispAddressUtil#toEid(DistinguishedNameType, InstanceIdType)}
 600      * - {@link LispAddressUtil#asDistinguishedNameEid(String)}
 601      * - {@link LispAddressUtil#asDistinguishedNameEid(String, long)}
 602      * methods with various input.
 603      */
 604     @Test
 605     public void toEid_distinguishedName() {
 606         Eid eidFromDistinguishedName = LispAddressUtil.toEid(DISTINGUISHED_NAME_TYPE_TEST, INSTANCE_ID_TYPE_TEST);
 607         verifyToEidWithDistinguishedName(eidFromDistinguishedName, true);
 608
 609         eidFromDistinguishedName = LispAddressUtil.asDistinguishedNameEid(DISTINGUISHED_NAME_TYPE_VALUE_TEST);
 610         verifyToEidWithDistinguishedName(eidFromDistinguishedName, false);
 611
 612         eidFromDistinguishedName = LispAddressUtil.asDistinguishedNameEid
 613                 (DISTINGUISHED_NAME_TYPE_VALUE_WITH_MAC_TEST, INSTANCE_ID_TYPE_VALUE_TEST);
 614         verifyToEidWithMacAddress(eidFromDistinguishedName, true);
 615     }
 616
 617     private void verifyToEidWithIpv6Prefix(final Eid eidFromIpv6Prefix, final boolean isVniChecked, short
 618             expectedMask, final Class<? extends org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp
 619             .address.types.rev151105.LispAddressFamily> addressType) {
 620         assertEquals(addressType, eidFromIpv6Prefix.getAddressType());
 621         if (isVniChecked) {
 622             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv6Prefix.getVirtualNetworkId());
 623         }
 624         assertEquals(IPV6_ADDRESS_VALUE_TEST + "/" + expectedMask, ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml
 625                 .ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6Prefix) eidFromIpv6Prefix
 626                 .getAddress()).getIpv6Prefix().getValue());
 627     }
 628
 629     private void verifyToEidWithIpv4(final Eid eidFromIpv4, final boolean isVniChecked) {
 630         assertEquals(Ipv4Afi.class, eidFromIpv4.getAddressType());
 631         if (isVniChecked) {
 632             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv4.getVirtualNetworkId());
 633         }
 634         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4) eidFromIpv4.getAddress()).getIpv4().getValue());
 635     }
 636
 637     private void verifyToEidWithIpv6(final Eid eidFromIpv6, final boolean isVniChecked) {
 638         assertEquals(Ipv6Afi.class, eidFromIpv6.getAddressType());
 639         if (isVniChecked) {
 640             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv6.getVirtualNetworkId());
 641         }
 642         assertEquals(IPV6_ADDRESS_VALUE_TEST, ((Ipv6) eidFromIpv6.getAddress()).getIpv6().getValue());
 643     }
 644
 645     private void verifyToEidWithIpv4Prefix(final Eid eidFromIpv4Prefix, final boolean isVniChecked, short
 646             expectedMask, Class<? extends org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address
 647             .types.rev151105.LispAddressFamily>  addressType) {
 648         assertEquals(addressType, eidFromIpv4Prefix.getAddressType());
 649         if (isVniChecked) {
 650             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv4Prefix.getVirtualNetworkId());
 651         }
 652         assertEquals(IPV4_ADDRESS_VALUE_TEST + "/" + expectedMask, ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns
 653                 .yang.ietf
 654                 .lisp.address.types.rev151105.lisp.address.address.Ipv4Prefix) eidFromIpv4Prefix.getAddress())
 655                 .getIpv4Prefix().getValue());
 656     }
 657
 658     private void verifyToEidWithDistinguishedName(final Eid eidFromDistinguishedName, final boolean isVniChecked) {
 659         assertEquals(DistinguishedNameAfi.class, eidFromDistinguishedName.getAddressType());
 660         if (isVniChecked) {
 661             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromDistinguishedName.getVirtualNetworkId());
 662         }
 663         assertEquals(DISTINGUISHED_NAME_TYPE_TEST, ((DistinguishedName) eidFromDistinguishedName.getAddress())
 664                 .getDistinguishedName());
 665     }
 666
 667     private void verifyToEidWithMacAddress(final Eid eidFromMac, final boolean isVniChecked) {
 668         assertEquals(MacAfi.class, eidFromMac.getAddressType());
 669         if (isVniChecked) {
 670             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromMac.getVirtualNetworkId());
 671         }
 672         assertEquals(MAC_ADDRESS_VALUE_TEST, ((Mac) eidFromMac.getAddress()).getMac().getValue());
 673     }
 674
 675     /**
 676      * Tests {@link LispAddressUtil#asIpPrefix(String, int)} with ipv4 address and correct mask
 677      */
 678     @Test
 679     public void asIpPrefix_ipv4() {
 680         final IpPrefix ipPrefix = LispAddressUtil.asIpPrefix(IPV4_ADDRESS_VALUE_TEST, MASK_OK_TEST);
 681         assertNotNull(ipPrefix);
 682         final Ipv4Prefix ipv4Prefix = ipPrefix.getIpv4Prefix();
 683         assertNotNull(ipv4Prefix);
 684         assertEquals(IPV4_ADDRESS_PREFIX_TEST, ipv4Prefix);
 685     }
 686
 687     /**
 688      * Tests {@link LispAddressUtil#asIpPrefix(String, int)} with ipv6 address and correct mask
 689      */
 690     @Test
 691     public void asIpPrefix_ipv6() {
 692         final IpPrefix ipPrefix = LispAddressUtil.asIpPrefix(IPV6_ADDRESS_VALUE_TEST, MASK_OK_TEST);
 693         assertNotNull(ipPrefix);
 694         final Ipv6Prefix ipv6Prefix = ipPrefix.getIpv6Prefix();
 695         assertNotNull(ipv6Prefix);
 696         assertEquals(IPV6_ADDRESS_PREFIX_TEST, ipv6Prefix);
 697     }
 698
 699     /**
 700      * Tests {@link LispAddressUtil#asIpPrefix(String, int)} with incorrect ip address and correct mask
 701      */
 702     @Test
 703     public void asIpPrefix_other() {
 704         final IpPrefix ipPrefix = LispAddressUtil.asIpPrefix(INCORRECT_IP_ADDRESS_TEST, MASK_OK_TEST);
 705         assertNull(ipPrefix);
 706     }
 707
 708     /**
 709      * Tests {@link LispAddressUtil#ipVersionFromString(String)} with ipv4
 710      */
 711     @Test
 712     public void ipVersionFromString_ipv4() {
 713         final int addressType = LispAddressUtil.ipVersionFromString(IPV4_ADDRESS_VALUE_TEST);
 714         assertEquals(4, addressType);
 715     }
 716
 717     /**
 718      * Tests {@link LispAddressUtil#ipVersionFromString(String)} with ipv6
 719      */
 720     @Test
 721     public void ipVersionFromString_ipv6() {
 722         final int addressType = LispAddressUtil.ipVersionFromString(IPV6_ADDRESS_VALUE_TEST);
 723         assertEquals(6, addressType);
 724     }
 725
 726     /**
 727      * Tests {@link LispAddressUtil#ipVersionFromString(String)} with incorrect ip address format
 728      */
 729     @Test
 730     public void ipVersionFromString_other() {
 731         final int addressType = LispAddressUtil.ipVersionFromString(INCORRECT_IP_ADDRESS_TEST);
 732         assertEquals(0, addressType);
 733
 734     }
 735
 736     /**
 737      * Tests {@link LispAddressUtil#asKeyValueAddressEid(SimpleAddress, SimpleAddress)} method.
 738      */
 739     @Test
 740     public void asKeyValueAddressEid() {
 741         final Eid eid = LispAddressUtil.asKeyValueAddressEid(SIMPLE_ADDRESS_A_TEST, SIMPLE_ADDRESS_B_TEST);
 742         verifyKeyValueAddress(eid, SIMPLE_ADDRESS_A_TEST);
 743     }
 744
 745     /**
 746      * Tests {@link LispAddressUtil#asKeyValueAddressRloc(SimpleAddress, SimpleAddress)} method.
 747      */
 748     @Test
 749     public void asKeyValueAddressRloc() {
 750         final Rloc rloc = LispAddressUtil.asKeyValueAddressRloc(SIMPLE_ADDRESS_A_TEST, SIMPLE_ADDRESS_B_TEST);
 751         verifyKeyValueAddress(rloc, SIMPLE_ADDRESS_A_TEST);
 752     }
 753
 754     /**
 755      * Tests {@link LispAddressUtil#asKeyValueAddress(String, SimpleAddress)} method.
 756      */
 757     @Test
 758     public void asKeyValueAddress() {
 759         final Rloc rloc = LispAddressUtil.asKeyValueAddress(SIMPLE_ADDRESS_DISTINGUISHED_VALUE_TEST,
 760                 SIMPLE_ADDRESS_B_TEST);
 761         verifyKeyValueAddress(rloc, SIMPLE_ADDRESS_DISTINGUISHED_TEST);
 762     }
 763
 764     private void verifyKeyValueAddress(final LispAddress lispAddress, final SimpleAddress keyValue) {
 765         assertEquals(KeyValueAddressLcaf.class, lispAddress.getAddressType());
 766         assertNull(lispAddress.getVirtualNetworkId());
 767         final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105
 768                 .lisp.address.address.key.value.address.KeyValueAddress keyValueAddress =
 769                 ((KeyValueAddress) lispAddress.getAddress()).getKeyValueAddress();
 770         assertNotNull(keyValueAddress);
 771         assertEquals(keyValue, keyValueAddress.getKey());
 772         assertEquals(SIMPLE_ADDRESS_B_TEST, keyValueAddress.getValue());
 773     }
 774
 775     /**
 776      * Tests {@link LispAddressUtil#asSrcDst(String, String, int, int)} method.
 777      */
 778     @Test
 779     public void asSrcDst() {
 780         final SourceDestKey sourceDestKey = LispAddressUtil.asSrcDst(IPV4_ADDRESS_VALUE_TEST,
 781                 IPV6_ADDRESS_VALUE_TEST, MASK_OK_TEST, MASK_OK_TEST);
 782         assertNotNull(sourceDestKey);
 783         assertEquals(SIMPLE_ADDRESS_WITH_IP_PREFIX_IPV4_TEST, sourceDestKey.getSource());
 784         assertEquals(SIMPLE_ADDRESS_WITH_IP_PREFIX_IPV6_TEST, sourceDestKey.getDest());
 785     }
 786
 787     /**
 788      * Tests {@link LispAddressUtil#asSrcDstEid(String, String, int, int, int)} method.
 789      */
 790     @Test
 791     public void asSrcDstEid_addressesAsString() {
 792         final Eid srcDstEid = LispAddressUtil.asSrcDstEid(IPV4_ADDRESS_VALUE_TEST,
 793                 IPV6_ADDRESS_VALUE_TEST, MASK_OK_TEST, MASK_OK_TEST, INSTANCE_ID_TYPE_VALUE_SHORT_TEST);
 794         assertNotNull(srcDstEid);
 795         assertEquals(SourceDestKeyLcaf.class, srcDstEid.getAddressType());
 796         final SourceDestKey sourceDestKey = ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns
 797                 .yang.ietf.lisp.address.types.rev151105.lisp.address.address.SourceDestKey) srcDstEid.getAddress())
 798                 .getSourceDestKey();
 799         assertNotNull(sourceDestKey);
 800         assertEquals(SIMPLE_ADDRESS_WITH_IP_PREFIX_IPV4_TEST, sourceDestKey.getSource());
 801         assertEquals(SIMPLE_ADDRESS_WITH_IP_PREFIX_IPV6_TEST, sourceDestKey.getDest());
 802     }
 803
 804     /**
 805      * Tests {@link LispAddressUtil#asSrcDstEid(SourceDestKey, InstanceIdType)}  method.
 806      */
 807     @Test
 808     public void asSrcDstEid_addressesAsSrcDstKey() {
 809         final SourceDestKey expectedSourceDestKey = new SourceDestKeyBuilder().setSource
 810                 (SIMPLE_ADDRESS_WITH_IP_PREFIX_IPV4_TEST).setDest(SIMPLE_ADDRESS_WITH_IP_PREFIX_IPV6_TEST).build();
 811         final Eid srcDstEid = LispAddressUtil.asSrcDstEid(expectedSourceDestKey, INSTANCE_ID_TYPE_TEST);
 812         assertNotNull(srcDstEid);
 813         assertEquals(SourceDestKeyLcaf.class, srcDstEid.getAddressType());
 814         final SourceDestKey testedSourceDestKey = ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns
 815                 .yang.ietf.lisp.address.types.rev151105.lisp.address.address.SourceDestKey) srcDstEid.getAddress())
 816                 .getSourceDestKey();
 817         assertNotNull(testedSourceDestKey);
 818         assertEquals(SIMPLE_ADDRESS_WITH_IP_PREFIX_IPV4_TEST, testedSourceDestKey.getSource());
 819         assertEquals(SIMPLE_ADDRESS_WITH_IP_PREFIX_IPV6_TEST, testedSourceDestKey.getDest());
 820     }
 821
 822     /**
 823      * Tests {@link LispAddressUtil#asSrcDstEid(SourceDestKey, InstanceIdType)}  method.
 824      */
 825     @Test
 826     public void asTeLcafRloc() {
 827         final List<IpAddress> ipAddresses = Arrays.asList(IP_ADDRESS_OBJECT_WITH_IPV4_TEST,
 828                 IP_ADDRESS_OBJECT_WITH_IPV6_TEST);
 829         final Rloc rloc = LispAddressUtil.asTeLcafRloc(ipAddresses);
 830         assertNotNull(rloc);
 831         assertEquals(ExplicitLocatorPathLcaf.class, rloc.getAddressType());
 832         final List<Hop> hops = ((ExplicitLocatorPath) rloc.getAddress()).getExplicitLocatorPath().getHop();
 833         assertEquals(hops.size(), ipAddresses.size());
 834
 835         for(IpAddress ipAddress : ipAddresses) {
 836             assertTrue("Ip address "+ipAddress+"should be part of hops list.",isIpAddressInHops(ipAddress, hops));
 837         }
 838
 839         for(Hop hop : hops) {
 840             final Hop.LrsBits lrsBits = hop.getLrsBits();
 841             assertFalse(lrsBits.isLookup());
 842             assertFalse(lrsBits.isRlocProbe());
 843             assertFalse(lrsBits.isStrict());
 844
 845             final IpAddress ipAddressFromHop = hop.getAddress().getIpAddress();
 846             assertNotNull(ipAddressFromHop);
 847         }
 848     }
 849
 850     private boolean isIpAddressInHops(final IpAddress ipAddress, final List<Hop> hops) {
 851         for (Hop hop : hops) {
 852             if (hop.getAddress().getIpAddress().equals(ipAddress)) {
 853                 return true;
 854             }
 855         }
 856         return false;
 857     }
 858
 859     /**
 860      * Tests {@link LispAddressUtil#asLocatorRecords(List)}  method.
 861      */
 862     @Test
 863     public void asLocatorRecords() {
 864         final List<Rloc> expectedRlocs = Arrays.asList(LispAddressUtil.toRloc(IPV4_ADDRESS_TEST), LispAddressUtil.toRloc
 865                 (IPV6_ADDRESS_TEST));
 866         final List<LocatorRecord> locatorRecords = LispAddressUtil.asLocatorRecords(expectedRlocs);
 867
 868         assertEquals(expectedRlocs.size(), locatorRecords.size());
 869
 870         for (Rloc rloc : expectedRlocs) {
 871             assertTrue("Rloc " + rloc + " should be part of " +
 872                     "locator records list list", isRlocInLocatorRecords(locatorRecords, rloc));
 873         }
 874
 875         for (LocatorRecord locatorRecord : locatorRecords) {
 876             assertFalse(locatorRecord.isLocalLocator());
 877             assertFalse(locatorRecord.isRlocProbed());
 878             assertTrue(locatorRecord.isRouted());
 879             assertTrue(1 == locatorRecord.getWeight());
 880             assertTrue(1 == locatorRecord.getPriority());
 881             assertTrue(1 == locatorRecord.getMulticastWeight());
 882             assertTrue(1 == locatorRecord.getMulticastPriority());
 883             assertEquals("SFC_LISP", locatorRecord.getLocatorId());
 884         }
 885     }
 886
 887     private boolean isRlocInLocatorRecords(final List<LocatorRecord> locatorRecords, final Rloc rloc) {
 888         for (LocatorRecord locatorRecord : locatorRecords) {
 889             if (locatorRecord.getRloc().equals(rloc)) {
 890                 return true;
 891             }
 892         }
 893         return false;
 894     }
 895
 896     /**
 897      * Tests {@link LispAddressUtil#getNoAddressEid()}  method.
 898      */
 899     @Test
 900     public void getNoAddressEid() {
 901         final Eid noAddressEid = LispAddressUtil.getNoAddressEid();
 902         assertEquals(NoAddressAfi.class, noAddressEid.getAddressType());
 903         assertNull(noAddressEid.getVirtualNetworkId());
 904         assertTrue(((NoAddress) noAddressEid.getAddress()).isNoAddress());
 905     }
 906
 907     /**
 908      * Tests {@link LispAddressUtil#ipAddressToInet(Address)} method with ipv4 value.
 909      */
 910     @Test
 911     public void ipAddressToInet_ipv4() {
 912         final Ipv4 expectedIpv4 = new Ipv4Builder().setIpv4(IPV4_ADDRESS_TEST).build();
 913         final InetAddress testedAddress = LispAddressUtil.ipAddressToInet(expectedIpv4);
 914         assertEquals(IPV4_ADDRESS_TEST.getValue(), testedAddress.getHostAddress());
 915     }
 916
 917     /**
 918      * Tests {@link LispAddressUtil#ipAddressToInet(Address)} method with ipv6 value.
 919      */
 920     @Test
 921     public void ipAddressToInet_ipv6() {
 922         final Ipv6 expectedIpv6 = new Ipv6Builder().setIpv6(IPV6_ADDRESS_TEST).build();
 923         final InetAddress testedAddress = LispAddressUtil.ipAddressToInet(expectedIpv6);
 924         assertEquals(IPV6_ADDRESS_TEST.getValue(), testedAddress.getHostAddress());
 925     }
 926
 927     /**
 928      * Tests {@link LispAddressUtil#ipAddressToInet(Address)} method with mac value.
 929      */
 930     @Test
 931     public void ipAddressToInet_other() {
 932         final InetAddress testedAddress = LispAddressUtil.ipAddressToInet(new MacBuilder().build());
 933         assertNull(testedAddress);
 934     }
 935
 936     /**
 937      * Tests {@link LispAddressUtil#compareInetAddresses(InetAddress, InetAddress)} with all possible combination
 938      * of input parameters to reach 100 % coverage.
 939      */
 940     @Test
 941     public void compareInetAddresses() throws UnknownHostException {
 942         final InetAddress inetIpv4A = Inet4Address.getByAddress(IPV4_ADDRESS_BYTES_A_TEST);
 943         final InetAddress inetIpv6A = Inet6Address.getByAddress(IPV6_ADDRESS_BYTES_A_TEST);
 944         final InetAddress inetIpv4B = Inet4Address.getByAddress(IPV4_ADDRESS_BYTES_B_TEST);
 945         final InetAddress inetIpv6B = Inet6Address.getByAddress(IPV6_ADDRESS_BYTES_B_TEST);
 946
 947         int comparisonResult = LispAddressUtil.compareInetAddresses(inetIpv4A, inetIpv6A);
 948         assertEquals(-1, comparisonResult);
 949
 950         comparisonResult = LispAddressUtil.compareInetAddresses(inetIpv6A, inetIpv4A);
 951         assertEquals(1, comparisonResult);
 952
 953         comparisonResult = LispAddressUtil.compareInetAddresses(inetIpv4A, inetIpv4B);
 954         assertEquals(-1, comparisonResult);
 955
 956         comparisonResult = LispAddressUtil.compareInetAddresses(inetIpv4B, inetIpv4A);
 957         assertEquals(1, comparisonResult);
 958
 959         comparisonResult = LispAddressUtil.compareInetAddresses(inetIpv4B, inetIpv4B);
 960         assertEquals(0, comparisonResult);
 961
 962         comparisonResult = LispAddressUtil.compareInetAddresses(inetIpv6A, inetIpv6B);
 963         assertEquals(-1, comparisonResult);
 964
 965         comparisonResult = LispAddressUtil.compareInetAddresses(inetIpv6B, inetIpv6A);
 966         assertEquals(1, comparisonResult);
 967
 968         comparisonResult = LispAddressUtil.compareInetAddresses(inetIpv6B, inetIpv6B);
 969         assertEquals(0, comparisonResult);
 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     @Test
 995     public void toIpPrefixEid() throws UnknownHostException {
 996         final Eid eid = LispAddressUtil.toIpPrefixEid(IP_ADDRESS_OBJECT_WITH_IPV4_TEST,
 997                 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