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.assertNotNull;
  13 import static org.junit.Assert.assertNull;
  14 import static org.junit.Assert.assertTrue;
  15
  16 import java.net.Inet4Address;
  17 import java.net.Inet6Address;
  18 import java.net.InetAddress;
  19 import java.net.UnknownHostException;
  20 import org.junit.Test;
  21 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.AsNumber;
  22 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  23 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
  24 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv6Address;
  27 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv6Prefix;
  28 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.AsNumberAfi;
  29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.DistinguishedNameAfi;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.DistinguishedNameType;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.InstanceIdType;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4Afi;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4PrefixAfi;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv6Afi;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv6PrefixAfi;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.LispAddressFamily;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.MacAfi;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.ServicePathIdType;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SimpleAddress;
  40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.Address;
  41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.DistinguishedName;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4;
  43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6;
  44 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Mac;
  45 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.service.path.ServicePath;
  46 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.EidBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
  50
  51 public class LispAddressUtilTest {
  52
  53
  54     private static final char[] DUMMY_CHARACTER_ARRAY_TEST = new char[]{'a', 'b', 'c', 'd'};
  55     private static final Long NUMBER_TEST = 5L;
  56
  57     private static final String MAC_ADDRESS_VALUE_TEST = "aa:bb:cc:dd:ee:ff";
  58     private static final MacAddress MAC_ADDRESS_TEST = new MacAddress("aa:bb:cc:dd:ee:ff");
  59
  60     private static final byte[] IPV4_ADDRESS_BYTES_TEST = new byte[]{(byte) 192, (byte) 168, 1, 1};
  61
  62     private static final short MASK_OK_TEST = 30;
  63     private static final short MASK_OK_DEFAULT_IPV4_TEST = 32;
  64     private static final short MASK_OK_DEFAULT_IPV6_TEST = 128;
  65
  66     private static final String IPV4_ADDRESS_VALUE_TEST = "192.168.1.1";
  67     private static final String IPV4_ADDRESS_PREFIX_VALUE_TEST = IPV4_ADDRESS_VALUE_TEST + "/" + MASK_OK_TEST;
  68     private static final Ipv4Address IPV4_ADDRESS_TEST = new Ipv4Address(IPV4_ADDRESS_VALUE_TEST);
  69     private static final IpAddress IP_ADDRESS_OBJECT_GENERAL_TEST = new IpAddress(IPV4_ADDRESS_TEST);
  70     private static final SimpleAddress SIMPLE_ADDRESS_TEST = new SimpleAddress(IP_ADDRESS_OBJECT_GENERAL_TEST);
  71     private static final Ipv4Prefix IPV4_ADDRESS_PREFIX_TEST = new Ipv4Prefix(IPV4_ADDRESS_PREFIX_VALUE_TEST);
  72     private static final IpPrefix IP_ADDRESS_PREFIX = new IpPrefix(IPV4_ADDRESS_PREFIX_TEST);
  73
  74     private static final byte[] IPV6_ADDRESS_BYTES_TEST = new byte[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
  75             15, 16};
  76     private static final String IPV6_ADDRESS_VALUE_TEST = "102:304:506:708:90a:b0c:d0e:f10";
  77     private static final String IPV6_ADDRESS_PREFIX_VALUE_TEST = IPV6_ADDRESS_VALUE_TEST + "/" + MASK_OK_TEST;
  78     private static final Ipv6Prefix IPV6_ADDRESS_PREFIX_TEST = new Ipv6Prefix(IPV6_ADDRESS_PREFIX_VALUE_TEST);
  79     private static final Ipv6Address IPV6_ADDRESS_TEST = new Ipv6Address(IPV6_ADDRESS_VALUE_TEST);
  80
  81     private static final Short DUMMY_SERVICE_INDEX = 45;
  82     private static final Long DUMMY_SERVICE_PATH_ID_TYPE = 46L;
  83     private static final String DISTINGUISHED_NAME_TYPE_VALUE_TEST = "dummy distinguished name type";
  84     private static final String DISTINGUISHED_NAME_TYPE_VALUE_WITH_MAC_TEST = MAC_ADDRESS_VALUE_TEST;
  85     private static final DistinguishedNameType DISTINGUISHED_NAME_TYPE_TEST = new DistinguishedNameType
  86             (DISTINGUISHED_NAME_TYPE_VALUE_TEST);
  87
  88     private static final Long AS_NUMBER_TEST = 100L;
  89     private static final Long INSTANCE_ID_TYPE_VALUE_TEST = 121L;
  90     private static final Short INSTANCE_ID_TYPE_VALUE_SHORT_TEST = 122;
  91     private static final InstanceIdType INSTANCE_ID_TYPE_TEST = new InstanceIdType(INSTANCE_ID_TYPE_VALUE_TEST);
  92     private static final String INCORRECT_IP_ADDRESS_TEST = "incorrect ip address";
  93
  94     /**
  95      * Tests {@link LispAddressUtil#addressTypeFromSimpleAddress} and {@link
  96      * LispAddressUtil#addressFromSimpleAddress} methods
  97      * with ipAddress
  98      */
  99     @Test
 100     public void addressFromSimpleAddressTest_asAnyIpAddress() {
 101         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromSimpleAddress
 102                 (SIMPLE_ADDRESS_TEST);
 103         assertEquals(Ipv4Afi.class, addressClass);
 104
 105         final Address address = LispAddressUtil.addressFromSimpleAddress(SIMPLE_ADDRESS_TEST);
 106         assertTrue(address instanceof Ipv4);
 107     }
 108
 109     /**
 110      * Tests {@link LispAddressUtil#addressTypeFromSimpleAddress} and {@link
 111      * LispAddressUtil#addressFromSimpleAddress} methods
 112      * with ipPrefix
 113      */
 114     @Test
 115     public void addressFromSimpleAddressTest_asIpPrefix() {
 116         final SimpleAddress simpleAddress = new SimpleAddress(new IpPrefix(new Ipv4Prefix(IPV4_ADDRESS_PREFIX_VALUE_TEST)));
 117         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromSimpleAddress
 118                 (simpleAddress);
 119         assertEquals(Ipv4PrefixAfi.class, addressClass);
 120
 121         final Address address = LispAddressUtil.addressFromSimpleAddress(simpleAddress);
 122         assertTrue(address instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address
 123                 .types.rev151105.lisp.address.address.Ipv4Prefix);
 124     }
 125
 126     /**
 127      * Tests {@link LispAddressUtil#addressTypeFromSimpleAddress} and {@link
 128      * LispAddressUtil#addressFromSimpleAddress} methods
 129      * with mac address
 130      */
 131     @Test
 132     public void addressFromSimpleAddressTest_asMacAddress() {
 133         final SimpleAddress simpleAddress = new SimpleAddress(new MacAddress(MAC_ADDRESS_VALUE_TEST));
 134         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromSimpleAddress
 135                 (simpleAddress);
 136         assertEquals(MacAfi.class, addressClass);
 137
 138         final Address address = LispAddressUtil.addressFromSimpleAddress(simpleAddress);
 139         assertTrue(address instanceof Mac);
 140     }
 141
 142     /**
 143      * Tests {@link LispAddressUtil#addressTypeFromSimpleAddress} and {@link
 144      * LispAddressUtil#addressFromSimpleAddress} methods
 145      * with general address
 146      */
 147     @Test
 148     public void addressFromSimpleAddressTest_asAddress() {
 149         final SimpleAddress simpleAddress = new SimpleAddress(DUMMY_CHARACTER_ARRAY_TEST);
 150         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromSimpleAddress
 151                 (simpleAddress);
 152         assertEquals(DistinguishedNameAfi.class, addressClass);
 153
 154         final Address address = LispAddressUtil.addressFromSimpleAddress(simpleAddress);
 155         assertTrue(address instanceof DistinguishedName);
 156     }
 157
 158     /**
 159      * Tests {@link LispAddressUtil#addressTypeFromSimpleAddress} and {@link
 160      * LispAddressUtil#addressFromSimpleAddress} methods
 161      * with address as number
 162      */
 163     @Test
 164     public void addressFromSimpleAddressTest_asNumber() {
 165         final SimpleAddress simpleAddress = new SimpleAddress(new AsNumber(NUMBER_TEST));
 166         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromSimpleAddress
 167                 (simpleAddress);
 168         assertEquals(AsNumberAfi.class, addressClass);
 169
 170         final Address address = LispAddressUtil.addressFromSimpleAddress(simpleAddress);
 171         assertTrue(address instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address
 172                 .types.rev151105.lisp.address.address.AsNumber);
 173     }
 174
 175     /**
 176      * Tests {@link LispAddressUtil#addressFromInet(InetAddress)} and {@link LispAddressUtil#addressTypeFromInet
 177      * (InetAddress)}
 178      * methods with ipv4 address
 179      *
 180      * @throws UnknownHostException
 181      */
 182     @Test
 183     public void addressFromInet_ipv4() throws UnknownHostException {
 184         final InetAddress ipv4InetAddress = Inet4Address.getByAddress(IPV4_ADDRESS_BYTES_TEST);
 185         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromInet(ipv4InetAddress);
 186         assertEquals(Ipv4Afi.class, addressClass);
 187
 188         final Address address = LispAddressUtil.addressFromInet(ipv4InetAddress);
 189         assertTrue(address instanceof Ipv4);
 190         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4) address).getIpv4().getValue());
 191     }
 192
 193     /**
 194      * Tests {@link LispAddressUtil#addressFromInet(InetAddress)} and {@link LispAddressUtil#addressTypeFromInet
 195      * (InetAddress)}
 196      * methods with ipv6 address
 197      *
 198      * @throws UnknownHostException
 199      */
 200     @Test
 201     public void addressFromInet_ipv6() throws UnknownHostException {
 202         final InetAddress ipv6InetAddress = Inet6Address.getByAddress(IPV6_ADDRESS_BYTES_TEST);
 203         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromInet(ipv6InetAddress);
 204         assertEquals(Ipv6Afi.class, addressClass);
 205
 206         final Address address = LispAddressUtil.addressFromInet(ipv6InetAddress);
 207         assertTrue(address instanceof Ipv6);
 208         assertEquals(IPV6_ADDRESS_VALUE_TEST, ((Ipv6) address).getIpv6().getValue());
 209     }
 210
 211     /**
 212      * Tests {@link LispAddressUtil#addressFromIpAddress(IpAddress)} and {@link
 213      * LispAddressUtil#addressTypeFromIpAddress(IpAddress)}
 214      * methods with ipv4 address
 215      */
 216     @Test
 217     public void addressFromIpAddress_ipv4() {
 218         final IpAddress ipv4Address = new IpAddress(IPV4_ADDRESS_TEST);
 219         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromIpAddress(ipv4Address);
 220         assertEquals(Ipv4Afi.class, addressClass);
 221
 222         final Address address = LispAddressUtil.addressFromIpAddress(ipv4Address);
 223         assertTrue(address instanceof Ipv4);
 224         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4) address).getIpv4().getValue());
 225     }
 226
 227     /**
 228      * Tests {@link LispAddressUtil#addressFromIpAddress(IpAddress)} and {@link
 229      * LispAddressUtil#addressTypeFromIpAddress(IpAddress)}
 230      * methods with ipv6 address
 231      */
 232     @Test
 233     public void addressFromIpAddress_ipv6() {
 234         final IpAddress ipv6Address = new IpAddress(new Ipv6Address(IPV6_ADDRESS_VALUE_TEST));
 235         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromIpAddress(ipv6Address);
 236         assertEquals(Ipv6Afi.class, addressClass);
 237
 238         final Address address = LispAddressUtil.addressFromIpAddress(ipv6Address);
 239         assertTrue(address instanceof Ipv6);
 240         assertEquals(IPV6_ADDRESS_VALUE_TEST, ((Ipv6) address).getIpv6().getValue());
 241     }
 242
 243     /**
 244      * Tests {@link LispAddressUtil#addressFromIpAddress(IpAddress)} and {@link
 245      * LispAddressUtil#addressTypeFromIpAddress(IpAddress)}
 246      * methods with null value instead off address.
 247      */
 248     @Test
 249     public void addressFromIpAddress_null() {
 250         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromIpAddress(null);
 251         assertNull(addressClass);
 252
 253         final Address address = LispAddressUtil.addressFromIpAddress(null);
 254         assertNull(address);
 255     }
 256
 257     /**
 258      * Tests {@link LispAddressUtil#addressFromIpPrefix(IpPrefix)} and {@link
 259      * LispAddressUtil#addressTypeFromIpPrefix(IpPrefix)}
 260      * methods with ipv4 address
 261      */
 262     @Test
 263     public void addressFromIpPrefix_ipv4() {
 264         IpPrefix ipv4Prefix = new IpPrefix(new Ipv4Prefix(IPV4_ADDRESS_PREFIX_VALUE_TEST));
 265         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromIpPrefix(ipv4Prefix);
 266         assertEquals(Ipv4PrefixAfi.class, addressClass);
 267
 268         final Address address = LispAddressUtil.addressFromIpPrefix(ipv4Prefix);
 269         assertTrue(address instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.
 270                 types.rev151105.lisp.address.address.Ipv4Prefix);
 271         assertEquals(IPV4_ADDRESS_PREFIX_VALUE_TEST, ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.
 272                 address.types.rev151105.lisp.address.address.Ipv4Prefix) address).getIpv4Prefix().getValue());
 273     }
 274
 275     /**
 276      * Tests {@link LispAddressUtil#addressFromIpPrefix(IpPrefix)} and {@link
 277      * LispAddressUtil#addressTypeFromIpPrefix(IpPrefix)}
 278      * methods with ipv6 address
 279      */
 280     @Test
 281     public void addressFromIpPrefix_ipv6() {
 282         IpPrefix ipv6Address = new IpPrefix(new Ipv6Prefix(IPV6_ADDRESS_PREFIX_VALUE_TEST));
 283         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromIpPrefix(ipv6Address);
 284         assertEquals(Ipv6PrefixAfi.class, addressClass);
 285
 286         final Address address = LispAddressUtil.addressFromIpPrefix(ipv6Address);
 287         assertTrue(address instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address
 288                 .types.rev151105.lisp.address.address.Ipv6Prefix);
 289         assertEquals(IPV6_ADDRESS_PREFIX_VALUE_TEST,
 290                 ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp
 291                         .address.address.Ipv6Prefix) address).getIpv6Prefix().getValue());
 292     }
 293
 294     /**
 295      * Tests {@link LispAddressUtil#addressFromIpPrefix(IpPrefix)} and {@link LispAddressUtil#addressTypeFromIpPrefix
 296      * (IpPrefix)}
 297      * methods with null value instead off address.
 298      */
 299     @Test
 300     public void addressFromIpPrefix_null() {
 301         final Class<? extends LispAddressFamily> addressClass = LispAddressUtil.addressTypeFromIpPrefix(null);
 302         assertNull(addressClass);
 303
 304         final Address address = LispAddressUtil.addressFromIpPrefix(null);
 305         assertNull(address);
 306     }
 307
 308     /**
 309      * Tests {@link LispAddressUtil#addressFromMacAddress(MacAddress)} methods with mac address.
 310      */
 311     @Test
 312     public void addressFromMacAddress_mac() {
 313         final Address address = LispAddressUtil.addressFromMacAddress(new MacAddress(MAC_ADDRESS_VALUE_TEST));
 314         assertTrue(address instanceof Mac);
 315         assertEquals(MAC_ADDRESS_VALUE_TEST, ((Mac) address).getMac().getValue());
 316     }
 317
 318     /**
 319      * Tests {@link LispAddressUtil#addressFromMacAddress(MacAddress)} methods with null instead of address.
 320      */
 321     @Test
 322     public void addressFromMacAddress_null() {
 323         final Address address = LispAddressUtil.addressFromMacAddress(null);
 324         assertNull(address);
 325     }
 326
 327
 328     /**
 329      * Test {@link LispAddressUtil#addressFromServicePath(ServicePath)} method with concrete servicePath
 330      */
 331     @Test
 332     public void addressFromServicePathTest_withServicePath() {
 333         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address
 334                 .address.service.path.ServicePathBuilder servicePathBuilder = new org.opendaylight.yang.gen.v1.urn.ietf
 335                 .params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address
 336                 .address.service.path.ServicePathBuilder();
 337         servicePathBuilder.setServiceIndex(DUMMY_SERVICE_INDEX);
 338         servicePathBuilder.setServicePathId(new ServicePathIdType(DUMMY_SERVICE_PATH_ID_TYPE));
 339
 340         ServicePath expectedAddress = servicePathBuilder.build();
 341         final Address testedAddress = LispAddressUtil.addressFromServicePath(expectedAddress);
 342         assertTrue(testedAddress instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address
 343                 .types.rev151105.lisp.address.address.ServicePath);
 344         assertEquals(expectedAddress, ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address
 345                 .types.rev151105.lisp.address.address.ServicePath) testedAddress).getServicePath());
 346     }
 347
 348     /**
 349      * Test {@link LispAddressUtil#addressFromServicePath(ServicePath)} method with null value
 350      */
 351     @Test
 352     public void addressFromServicePathTest_withNull() {
 353         final Address testedAddress = LispAddressUtil.addressFromServicePath(null);
 354         assertNull(testedAddress);
 355     }
 356
 357     /**
 358      * Test {@link LispAddressUtil#addressFromDistinguishedName(DistinguishedNameType)} method with distinguished name }
 359      */
 360     @Test
 361     public void addressFromDistinguishedNameTest_withDistinguishedName() {
 362         final DistinguishedNameType distinguishedNameType = new DistinguishedNameType(DISTINGUISHED_NAME_TYPE_VALUE_TEST);
 363         final Address testedAddress = LispAddressUtil.addressFromDistinguishedName(distinguishedNameType);
 364
 365         assertTrue(testedAddress instanceof DistinguishedName);
 366         assertEquals(distinguishedNameType, ((DistinguishedName) testedAddress).getDistinguishedName());
 367     }
 368
 369     /**
 370      * Test {@link LispAddressUtil#addressFromDistinguishedName(DistinguishedNameType)} method with null value }
 371      */
 372     @Test
 373     public void addressFromDistinguishedNameTest_withNull() {
 374         final Address testedAddress = LispAddressUtil.addressFromDistinguishedName(null);
 375         assertNull(testedAddress);
 376     }
 377
 378     /**
 379      * Test {@link LispAddressUtil#addressFromAsNumber(AsNumber)} method with as number value }
 380      */
 381     @Test
 382     public void addressFromAsNumberTest_withAdNumber() {
 383         final AsNumber expectedAddress = new AsNumber(AS_NUMBER_TEST);
 384         final Address testedAddress = LispAddressUtil.addressFromAsNumber(expectedAddress);
 385         assertTrue(testedAddress instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp
 386                 .address.types.rev151105.lisp.address.address.AsNumber);
 387         assertEquals(expectedAddress, ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp
 388                 .address.types.rev151105.lisp.address.address.AsNumber) testedAddress).getAsNumber());
 389     }
 390
 391     /**
 392      * Test {@link LispAddressUtil#addressFromAsNumber(AsNumber)} method with null instead of value }
 393      */
 394     @Test
 395     public void addressFromAsNumberTest_withNull() {
 396         final Address testedAddress = LispAddressUtil.addressFromAsNumber(null);
 397         assertNull(testedAddress);
 398     }
 399
 400
 401     /**
 402      * Tests:
 403      * - {@link LispAddressUtil#toRloc(InetAddress)}
 404      * - {@link LispAddressUtil#toRloc(Ipv4Address)}
 405      * - {@link LispAddressUtil#toRloc(Ipv6Address)}
 406      * - {@link LispAddressUtil#toRloc(SimpleAddress)}
 407      * methods.
 408      */
 409     @Test
 410     public void toRloc() throws UnknownHostException {
 411         InetAddress ipv4AddressInet = Inet4Address.getByAddress(IPV4_ADDRESS_BYTES_TEST);
 412         final Rloc rlocFromInetAddress = LispAddressUtil.toRloc(ipv4AddressInet);
 413         assertEquals(Ipv4Afi.class, rlocFromInetAddress.getAddressType());
 414         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4)rlocFromInetAddress.getAddress()).getIpv4().getValue());
 415
 416         final Rloc rlocFromIpv4Address = LispAddressUtil.toRloc(IPV4_ADDRESS_TEST);
 417         assertEquals(Ipv4Afi.class, rlocFromIpv4Address.getAddressType());
 418         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4) rlocFromIpv4Address.getAddress()).getIpv4().getValue());
 419
 420
 421         final Rloc rlocFromIpv6Address = LispAddressUtil.toRloc(IPV6_ADDRESS_TEST);
 422         assertEquals(Ipv6Afi.class, rlocFromIpv6Address.getAddressType());
 423         assertEquals(IPV6_ADDRESS_VALUE_TEST, ((Ipv6) rlocFromIpv6Address.getAddress()).getIpv6().getValue());
 424
 425         final Rloc rlocFromSimpleAddress = LispAddressUtil.toRloc(SIMPLE_ADDRESS_TEST);
 426         assertEquals(Ipv4Afi.class, rlocFromSimpleAddress.getAddressType());
 427         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4) rlocFromSimpleAddress.getAddress()).getIpv4().getValue());
 428     }
 429
 430     /**
 431      * Test {@link LispAddressUtil#asIpv4Rloc(String)} method with ipv4 or ipv6.
 432      * Test {@link LispAddressUtil#asIpv6Rloc(String)} method with ipv4 or ipv6.
 433      */
 434     @Test
 435     public void asIpvRloc() {
 436         final Rloc rlocFromIpV4 = LispAddressUtil.asIpv4Rloc(IPV4_ADDRESS_VALUE_TEST);
 437         assertEquals(Ipv4Afi.class, rlocFromIpV4.getAddressType());
 438         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4) rlocFromIpV4.getAddress()).getIpv4().getValue());
 439
 440         final Rloc rlocFromIpV6 = LispAddressUtil.asIpv6Rloc(IPV6_ADDRESS_VALUE_TEST);
 441         assertEquals(Ipv6Afi.class, rlocFromIpV6.getAddressType());
 442         assertEquals(IPV6_ADDRESS_VALUE_TEST, ((Ipv6) rlocFromIpV6.getAddress()).getIpv6().getValue());
 443     }
 444
 445     /**
 446      * Test
 447      * - {@link LispAddressUtil#toEid(Ipv6Address, InstanceIdType)}
 448      * - {@link LispAddressUtil#asIpv6PrefixEid(String)}
 449      * - {@link LispAddressUtil#asIpv6PrefixEid(Eid, Inet6Address, short)}
 450      * - {@link LispAddressUtil#asIpv6PrefixEid(Ipv6Address, InstanceIdType)}
 451      * methods.
 452      */
 453     @Test
 454     public void toEid_ipv6Prefix() throws UnknownHostException {
 455         Eid eidFromIpv6Prefix = LispAddressUtil.toEid(IPV6_ADDRESS_PREFIX_TEST, INSTANCE_ID_TYPE_TEST);
 456         verifyToEidWithIpv6Prefix(eidFromIpv6Prefix, true, MASK_OK_TEST, Ipv6PrefixAfi.class);
 457
 458         eidFromIpv6Prefix = LispAddressUtil.asIpv6PrefixEid(IPV6_ADDRESS_PREFIX_VALUE_TEST);
 459         verifyToEidWithIpv6Prefix(eidFromIpv6Prefix, false, MASK_OK_TEST, Ipv6PrefixAfi.class);
 460
 461         eidFromIpv6Prefix = LispAddressUtil.asIpv6PrefixEid(IPV6_ADDRESS_TEST, INSTANCE_ID_TYPE_TEST);
 462         verifyToEidWithIpv6Prefix(eidFromIpv6Prefix, true, MASK_OK_DEFAULT_IPV6_TEST, Ipv6PrefixAfi.class);
 463     }
 464
 465     /**
 466      * Test
 467      * - {@link LispAddressUtil#toEid(MacAddress, InstanceIdType)}
 468      * - {@link LispAddressUtil#asMacEid(String)}
 469      * - {@link LispAddressUtil#asMacEid(String, long)}
 470      * methods.
 471      */
 472     @Test
 473     public void toEid_mac() {
 474         Eid eidFromMac = LispAddressUtil.toEid(MAC_ADDRESS_TEST, INSTANCE_ID_TYPE_TEST);
 475         verifyToEidWithMacAddress(eidFromMac, true);
 476
 477         eidFromMac = LispAddressUtil.asMacEid(MAC_ADDRESS_VALUE_TEST);
 478         verifyToEidWithMacAddress(eidFromMac, false);
 479
 480         eidFromMac = LispAddressUtil.asMacEid(MAC_ADDRESS_VALUE_TEST, INSTANCE_ID_TYPE_VALUE_TEST);
 481         verifyToEidWithMacAddress(eidFromMac, true);
 482     }
 483
 484     /**
 485      * Test
 486      * - {@link LispAddressUtil#toEid(Ipv6Address, InstanceIdType)}
 487      * - {@link LispAddressUtil#asIpv6Eid(String)}
 488      * - {@link LispAddressUtil#asIpv6Eid(String, long)}
 489      * methods.
 490      */
 491     @Test
 492     public void toEid_ipv6() {
 493         Eid eidFromIpv6 = LispAddressUtil.toEid(IPV6_ADDRESS_TEST, INSTANCE_ID_TYPE_TEST);
 494         verifyToEidWithIpv6(eidFromIpv6, true);
 495
 496         eidFromIpv6 = LispAddressUtil.asIpv6Eid(IPV6_ADDRESS_VALUE_TEST);
 497         verifyToEidWithIpv6(eidFromIpv6, false);
 498
 499         eidFromIpv6 = LispAddressUtil.asIpv6Eid(IPV6_ADDRESS_VALUE_TEST, INSTANCE_ID_TYPE_VALUE_TEST);
 500         verifyToEidWithIpv6(eidFromIpv6, true);
 501     }
 502
 503     /**
 504      * Test
 505      * - {@link LispAddressUtil#toEid(Ipv4Prefix, InstanceIdType)}
 506      * - {@link LispAddressUtil#asIpv4PrefixEid(String)}
 507      * - {@link LispAddressUtil#asIpv4PrefixEid(Eid, Inet4Address, short)}
 508      * - {@link LispAddressUtil#asIpv4PrefixEid(Ipv4Address, InstanceIdType)}  }
 509      * methods.
 510      */
 511     @Test
 512     public void toEid_ipv4Prefix() throws UnknownHostException {
 513         Eid eidFromIpv4Prefix = LispAddressUtil.toEid(IPV4_ADDRESS_PREFIX_TEST, INSTANCE_ID_TYPE_TEST);
 514         verifyToEidWithIpv4Prefix(eidFromIpv4Prefix, true, MASK_OK_TEST, Ipv4PrefixAfi.class);
 515
 516         eidFromIpv4Prefix  = LispAddressUtil.asIpv4PrefixEid(IPV4_ADDRESS_PREFIX_VALUE_TEST);
 517         verifyToEidWithIpv4Prefix(eidFromIpv4Prefix, false, MASK_OK_TEST, Ipv4PrefixAfi.class);
 518
 519         eidFromIpv4Prefix  = LispAddressUtil.asIpv4PrefixEid(IPV4_ADDRESS_TEST, INSTANCE_ID_TYPE_TEST);
 520         verifyToEidWithIpv4Prefix(eidFromIpv4Prefix, false, (short)32, Ipv4PrefixAfi.class);
 521     }
 522
 523     public Eid provideDummyMacEid() {
 524         final EidBuilder eidBuilder = new EidBuilder();
 525         eidBuilder.setAddressType(MacAfi.class);
 526         eidBuilder.setVirtualNetworkId(INSTANCE_ID_TYPE_TEST);
 527         return eidBuilder.build();
 528     }
 529
 530     /**
 531      * Test
 532      * - {@link LispAddressUtil#toEid(Ipv4Address, InstanceIdType)}
 533      * - {@link LispAddressUtil#asIpv4Eid(String)}
 534      * - {@link LispAddressUtil#asIpv4Eid(String, long)}
 535      * methods.
 536      */
 537     @Test
 538     public void toEid_ipv4() {
 539         Eid eidFromIpv4 = LispAddressUtil.toEid(IPV4_ADDRESS_TEST, INSTANCE_ID_TYPE_TEST);
 540         verifyToEidWithIpv4(eidFromIpv4, true);
 541
 542         eidFromIpv4 = LispAddressUtil.asIpv4Eid(IPV4_ADDRESS_VALUE_TEST);
 543         verifyToEidWithIpv4(eidFromIpv4, false);
 544
 545         eidFromIpv4 = LispAddressUtil.asIpv4Eid(IPV4_ADDRESS_VALUE_TEST, INSTANCE_ID_TYPE_VALUE_TEST);
 546         verifyToEidWithIpv4(eidFromIpv4, true);
 547     }
 548
 549     /**
 550      * Test
 551      * - {@link LispAddressUtil#toEid(IpPrefix, InstanceIdType)}
 552      * method.
 553      */
 554     @Test
 555     public void toEid_ipPrefix() {
 556         final Eid eidFromIpPrefix = LispAddressUtil.toEid(IP_ADDRESS_PREFIX, INSTANCE_ID_TYPE_TEST);
 557         verifyToEidWithIpv4Prefix(eidFromIpPrefix, true, MASK_OK_TEST, Ipv4PrefixAfi.class);
 558     }
 559
 560     /**
 561      * Test
 562      * - {@link LispAddressUtil#toEid(DistinguishedNameType, InstanceIdType)}
 563      * - {@link LispAddressUtil#asDistinguishedNameEid(String)}
 564      * - {@link LispAddressUtil#asDistinguishedNameEid(String, long)}
 565      * methods with various input.
 566      */
 567     @Test
 568     public void toEid_distinguishedName() {
 569         Eid eidFromDistinguishedName = LispAddressUtil.toEid(DISTINGUISHED_NAME_TYPE_TEST, INSTANCE_ID_TYPE_TEST);
 570         verifyToEidWithDistinguishedName(eidFromDistinguishedName, true);
 571
 572         eidFromDistinguishedName = LispAddressUtil.asDistinguishedNameEid(DISTINGUISHED_NAME_TYPE_VALUE_TEST);
 573         verifyToEidWithDistinguishedName(eidFromDistinguishedName, false);
 574
 575         eidFromDistinguishedName = LispAddressUtil.asDistinguishedNameEid
 576                 (DISTINGUISHED_NAME_TYPE_VALUE_WITH_MAC_TEST, INSTANCE_ID_TYPE_VALUE_TEST);
 577         verifyToEidWithMacAddress(eidFromDistinguishedName, true);
 578     }
 579
 580     private void verifyToEidWithIpv6Prefix(final Eid eidFromIpv6Prefix, final boolean isVniChecked, short
 581             expectedMask, final Class<? extends org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp
 582             .address.types.rev151105.LispAddressFamily> addressType) {
 583         assertEquals(addressType, eidFromIpv6Prefix.getAddressType());
 584         if (isVniChecked) {
 585             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv6Prefix.getVirtualNetworkId());
 586         }
 587         assertEquals(IPV6_ADDRESS_VALUE_TEST + "/" + expectedMask, ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml
 588                 .ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6Prefix) eidFromIpv6Prefix
 589                 .getAddress()).getIpv6Prefix().getValue());
 590     }
 591
 592     private void verifyToEidWithIpv4(final Eid eidFromIpv4, final boolean isVniChecked) {
 593         assertEquals(Ipv4Afi.class, eidFromIpv4.getAddressType());
 594         if (isVniChecked) {
 595             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv4.getVirtualNetworkId());
 596         }
 597         assertEquals(IPV4_ADDRESS_VALUE_TEST, ((Ipv4) eidFromIpv4.getAddress()).getIpv4().getValue());
 598     }
 599
 600     private void verifyToEidWithIpv6(final Eid eidFromIpv6, final boolean isVniChecked) {
 601         assertEquals(Ipv6Afi.class, eidFromIpv6.getAddressType());
 602         if (isVniChecked) {
 603             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv6.getVirtualNetworkId());
 604         }
 605         assertEquals(IPV6_ADDRESS_VALUE_TEST, ((Ipv6)eidFromIpv6.getAddress()).getIpv6().getValue());
 606     }
 607
 608     private void verifyToEidWithIpv4Prefix(final Eid eidFromIpv4Prefix, final boolean isVniChecked, short
 609             expectedMask, Class<? extends org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address
 610             .types.rev151105.LispAddressFamily>  addressType) {
 611         assertEquals(addressType, eidFromIpv4Prefix.getAddressType());
 612         if (isVniChecked) {
 613             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromIpv4Prefix.getVirtualNetworkId());
 614         }
 615         assertEquals(IPV4_ADDRESS_VALUE_TEST +"/"+expectedMask, ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns
 616                 .yang.ietf
 617                 .lisp.address.types.rev151105.lisp.address.address.Ipv4Prefix)eidFromIpv4Prefix.getAddress())
 618                 .getIpv4Prefix().getValue());
 619     }
 620
 621     private void verifyToEidWithDistinguishedName(final Eid eidFromDistinguishedName, final boolean isVniChecked) {
 622         assertEquals(DistinguishedNameAfi.class, eidFromDistinguishedName.getAddressType());
 623         if (isVniChecked) {
 624             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromDistinguishedName.getVirtualNetworkId());
 625         }
 626         assertEquals(DISTINGUISHED_NAME_TYPE_TEST, ((DistinguishedName)eidFromDistinguishedName.getAddress())
 627                 .getDistinguishedName());
 628     }
 629
 630     private void verifyToEidWithMacAddress(final Eid eidFromMac, final boolean isVniChecked) {
 631         assertEquals(MacAfi.class, eidFromMac.getAddressType());
 632         if (isVniChecked) {
 633             assertEquals(INSTANCE_ID_TYPE_TEST, eidFromMac.getVirtualNetworkId());
 634         }
 635         assertEquals(MAC_ADDRESS_VALUE_TEST, ((Mac)eidFromMac.getAddress()).getMac().getValue());
 636     }
 637
 638     /**
 639      * Tests {@link LispAddressUtil#asIpPrefix(String, int)} with ipv4 address and correct mask
 640      */
 641     @Test
 642     public void asIpPrefix_ipv4() {
 643         final IpPrefix ipPrefix = LispAddressUtil.asIpPrefix(IPV4_ADDRESS_VALUE_TEST, MASK_OK_TEST);
 644         assertNotNull(ipPrefix);
 645         final Ipv4Prefix ipv4Prefix = ipPrefix.getIpv4Prefix();
 646         assertNotNull(ipv4Prefix);
 647         assertEquals(IPV4_ADDRESS_PREFIX_TEST, ipv4Prefix);
 648     }
 649
 650     /**
 651      * Tests {@link LispAddressUtil#asIpPrefix(String, int)} with ipv6 address and correct mask
 652      */
 653     @Test
 654     public void asIpPrefix_ipv6() {
 655         final IpPrefix ipPrefix = LispAddressUtil.asIpPrefix(IPV6_ADDRESS_VALUE_TEST, MASK_OK_TEST);
 656         assertNotNull(ipPrefix);
 657         final Ipv6Prefix ipv6Prefix = ipPrefix.getIpv6Prefix();
 658         assertNotNull(ipv6Prefix);
 659         assertEquals(IPV6_ADDRESS_PREFIX_TEST, ipv6Prefix);
 660     }
 661
 662     /**
 663      * Tests {@link LispAddressUtil#asIpPrefix(String, int)} with incorrect ip address and correct mask
 664      */
 665     @Test
 666     public void asIpPrefix_other() {
 667         final IpPrefix ipPrefix = LispAddressUtil.asIpPrefix(INCORRECT_IP_ADDRESS_TEST, MASK_OK_TEST);
 668         assertNull(ipPrefix);
 669     }
 670
 671     /**
 672      * Tests {@link LispAddressUtil#ipVersionFromString(String)} with ipv4
 673      */
 674     @Test
 675     public void ipVersionFromString_ipv4() {
 676         final int addressType = LispAddressUtil.ipVersionFromString(IPV4_ADDRESS_VALUE_TEST);
 677         assertEquals(4, addressType);
 678     }
 679     /**
 680      * Tests {@link LispAddressUtil#ipVersionFromString(String)} with ipv6
 681      */
 682     @Test
 683     public void ipVersionFromString_ipv6() {
 684         final int addressType = LispAddressUtil.ipVersionFromString(IPV6_ADDRESS_VALUE_TEST);
 685         assertEquals(6, addressType);
 686     }
 687     /**
 688      * Tests {@link LispAddressUtil#ipVersionFromString(String)} with incorrect ip address format
 689      */
 690     @Test
 691     public void ipVersionFromString_other() {
 692         final int addressType = LispAddressUtil.ipVersionFromString(INCORRECT_IP_ADDRESS_TEST);
 693         assertEquals(0, addressType);
 694
 695     }
 696 }
 697