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

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