openflowplugin/src/test/java/org/opendaylight/openflowplugin/openflow/md/core/sal/convertor/common/IpConversionUtilTest.java

   1 /*\r
   2  * Copyright (c) 2014 Brocade Communications Systems Inc and others. All rights reserved.\r
   3  *\r
   4  * This program and the accompanying materials are made available under the\r
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html\r
   7  */\r
   8 package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.common;\r
   9 \r
  10 import java.math.BigInteger;\r
  11 import java.util.Arrays;\r
  12 import org.junit.Assert;\r
  13 import org.junit.Test;\r
  14 import org.opendaylight.openflowjava.util.ByteBufUtils;\r
  15 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;\r
  16 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;\r
  17 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;\r
  18 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;\r
  19 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.DottedQuad;\r
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.opendaylight.ipv6.arbitrary.bitmask.fields.rev160224.Ipv6ArbitraryMask;\r
  21 import org.slf4j.Logger;\r
  22 import org.slf4j.LoggerFactory;\r
  23 \r
  24 public class IpConversionUtilTest {\r
  25     private static Logger LOG = LoggerFactory.getLogger(IpConversionUtilTest.class);\r
  26 \r
  27     @Test\r
  28     public void canonicalBinaryV6AddressTest() {\r
  29 \r
  30         byte [] ipv6binary = IpConversionUtil.canonicalBinaryV6Address(new Ipv6Address("0000:0000:0000:0000:0000:0000:0000:0001"));\r
  31         byte [] expected = {0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,1};\r
  32 \r
  33         Assert.assertTrue("Incorrect canonicalization - binary", Arrays.equals(ipv6binary, expected));\r
  34         try {\r
  35             Assert.assertEquals("Incorrect canonicalization - string", "::1", IpConversionUtil.byteArrayV6AddressToString(ipv6binary));\r
  36         } catch (java.net.UnknownHostException e) {\r
  37             Assert.assertTrue("Incorrect canonicalization - wrong length of byte[]", false);\r
  38         }\r
  39     }\r
  40 \r
  41     @Test\r
  42     public void canonicalBinaryV6AddressPrefixTest() {\r
  43 \r
  44         byte [] ipv6binary = IpConversionUtil.canonicalBinaryV6Prefix(new Ipv6Prefix("0000:0000:0000:0000:0000:0000:0000:0001/64"));\r
  45         byte [] expected = {0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 64};\r
  46 \r
  47         Assert.assertTrue("Incorrect canonicalization - binary", Arrays.equals(ipv6binary, expected));\r
  48         try {\r
  49             Assert.assertEquals("Incorrect canonicalization - string", "::/64", IpConversionUtil.byteArrayV6PrefixToString(ipv6binary));\r
  50         } catch (java.net.UnknownHostException e){\r
  51             Assert.assertTrue("Incorrect canonicalization - wrong length of byte[]", false);\r
  52         }\r
  53     }\r
  54 \r
  55     @Test\r
  56     public void testCountBitsAsCIDRReplacement() throws Exception {\r
  57         BigInteger maskSeed = new BigInteger("1ffffffffffffffffffffffffffffffff", 16);\r
  58         byte[] maskArray = new byte[16];\r
  59         LOG.debug("maskSeed= {}", ByteBufUtils.bytesToHexString(maskSeed.toByteArray()));\r
  60 \r
  61         for (int i = 0; i <= 128; i++) {\r
  62             System.arraycopy(maskSeed.toByteArray(), 1, maskArray, 0, 16);\r
  63             LOG.debug("maskHex[{}] = {}", i, ByteBufUtils.bytesToHexString(maskArray));\r
  64             int cidr = IpConversionUtil.countBits(maskArray);\r
  65             LOG.debug("cidr = {}", cidr);\r
  66             Assert.assertEquals(128 - i, cidr);\r
  67 \r
  68             maskSeed = maskSeed.clearBit(i);\r
  69         }\r
  70     }\r
  71 \r
  72     @Test\r
  73     public void testcountBitsAsGetIpv4Mask() {\r
  74         byte[][] maskInputs = new byte[][]{\r
  75                 {(byte) 255, (byte) 255, (byte) 255, (byte) 255},\r
  76                 {(byte) 255, (byte) 255, (byte) 254, 0},\r
  77                 {(byte) 128, 0, 0, 0},\r
  78                 {0, 0, 0, 0},\r
  79         };\r
  80 \r
  81         int[] maskOutputs = new int[]{\r
  82                 32, 23, 1, 0\r
  83         };\r
  84 \r
  85         for (int i = 0; i < maskInputs.length; i++) {\r
  86             int mask = IpConversionUtil.countBits(maskInputs[i]);\r
  87             Assert.assertEquals(maskOutputs[i], mask);\r
  88         }\r
  89     }\r
  90 \r
  91     @Test\r
  92     public void convertArbitraryMaskToByteArrayTest() {\r
  93         int value = 0xffffffff;\r
  94         byte[] bytes = new byte[]{\r
  95                 (byte)(value >>> 24), (byte)(value >> 16 & 0xff), (byte)(value >> 8 & 0xff), (byte)(value & 0xff) };\r
  96         byte[] maskBytes;\r
  97         maskBytes = IpConversionUtil.convertArbitraryMaskToByteArray(new DottedQuad("255.255.255.255"));\r
  98         for (int i=0; i<bytes.length;i++) {\r
  99             int mask = maskBytes[i];\r
 100             Assert.assertEquals(bytes[i],mask);\r
 101         }\r
 102     }\r
 103 \r
 104     @Test\r
 105     public void isArbitraryBitMaskTest() {\r
 106         boolean arbitraryBitMask;\r
 107         arbitraryBitMask = IpConversionUtil.isArbitraryBitMask(new byte[] {1,1,1,1});\r
 108         Assert.assertEquals(arbitraryBitMask,true);\r
 109         arbitraryBitMask = IpConversionUtil.isArbitraryBitMask(new byte[] {-1,-1,-1,-1});\r
 110         Assert.assertEquals(arbitraryBitMask,false);\r
 111         arbitraryBitMask = IpConversionUtil.isArbitraryBitMask(new byte[] {-1,-1,0,-1});\r
 112         Assert.assertEquals(arbitraryBitMask,true);\r
 113         arbitraryBitMask = IpConversionUtil.isArbitraryBitMask(null);\r
 114         Assert.assertEquals(arbitraryBitMask,false);\r
 115     }\r
 116 \r
 117     @Test\r
 118     public void extractIpv4AddressTest() {\r
 119         Ipv4Address ipv4Address;\r
 120         ipv4Address = IpConversionUtil.extractIpv4Address(new Ipv4Prefix("1.0.1.0/16"));\r
 121         Assert.assertEquals(ipv4Address.getValue(),"1.0.1.0");\r
 122     }\r
 123 \r
 124     @Test\r
 125     public void extractIpv4AddressMaskTest() {\r
 126         DottedQuad dottedQuad;\r
 127         dottedQuad = IpConversionUtil.extractIpv4AddressMask(new Ipv4Prefix("1.1.1.1/24"));\r
 128         Assert.assertEquals(dottedQuad.getValue(),"255.255.255.0");\r
 129     }\r
 130 \r
 131     @Test\r
 132     public void convertipv6ArbitraryMaskToByteArrayTest() {\r
 133         byte[] bytes = {-5,-96,-1,-74,-1,-16,-1,-16, -1,-16,-1,-16,-1,-16,-91,85};\r
 134         byte[] maskBytes = IpConversionUtil.convertIpv6ArbitraryMaskToByteArray(new Ipv6ArbitraryMask("fbA0:FFB6:FFF0:FFF0:FFF0:FFF0:FFF0:A555"));\r
 135         for(int i=0; i<bytes.length;i++){\r
 136             int mask = maskBytes[i];\r
 137             Assert.assertEquals(bytes[i],mask);\r
 138         }\r
 139     }\r
 140 \r
 141     @Test\r
 142     public void createArbitraryBitMaskTest() {\r
 143         byte[] bytes = {-1,-1,-1,0};\r
 144         DottedQuad dottedQuad;\r
 145         dottedQuad = IpConversionUtil.createArbitraryBitMask(bytes);\r
 146         Assert.assertEquals(dottedQuad.getValue(),"255.255.255.0");\r
 147         DottedQuad dottedQuadNull;\r
 148         dottedQuadNull = IpConversionUtil.createArbitraryBitMask(null);\r
 149         Assert.assertEquals(dottedQuadNull.getValue(),"255.255.255.255");\r
 150     }\r
 151 \r
 152     @Test\r
 153     public void createIpv6ArbitraryBitMaskTest() {\r
 154         byte[] bytes = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};\r
 155         Ipv6ArbitraryMask ipv6ArbitraryMask;\r
 156         ipv6ArbitraryMask = IpConversionUtil.createIpv6ArbitraryBitMask(bytes);\r
 157         Assert.assertEquals(ipv6ArbitraryMask.getValue(),"ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");\r
 158         Ipv6ArbitraryMask ipv6ArbitraryMaskNull;\r
 159         ipv6ArbitraryMaskNull = IpConversionUtil.createIpv6ArbitraryBitMask(null);\r
 160         Assert.assertEquals(ipv6ArbitraryMaskNull.getValue(),"ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");\r
 161     }\r
 162 \r
 163     @Test\r
 164     public void extractIpv6AddressMaskTest() {\r
 165         Ipv6ArbitraryMask ipv6IpAddressMask;\r
 166         Ipv6Prefix ipv6Prefix = new Ipv6Prefix("1:2:3:4:5:6:7:8/16");\r
 167         ipv6IpAddressMask = IpConversionUtil.extractIpv6AddressMask(ipv6Prefix);\r
 168         Assert.assertEquals(ipv6IpAddressMask.getValue(),"ffff:0:0:0:0:0:0:0");\r
 169     }\r
 170 \r
 171     @Test\r
 172     public void isIpv6ArbitraryBitMaskTest() {\r
 173         byte[] bytes = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};\r
 174         boolean falseCase =  false;\r
 175         boolean trueCase =  true;\r
 176         Assert.assertEquals(falseCase,IpConversionUtil.isIpv6ArbitraryBitMask(bytes));\r
 177         byte[] bytesArbitraryMask = {-1,-1,-1,-1,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};\r
 178         Assert.assertEquals(trueCase,IpConversionUtil.isIpv6ArbitraryBitMask(bytesArbitraryMask));\r
 179         Assert.assertEquals(falseCase,IpConversionUtil.isIpv6ArbitraryBitMask(null));\r
 180         byte[] bytesMask = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,0};\r
 181         Assert.assertEquals(falseCase,IpConversionUtil.isIpv6ArbitraryBitMask(bytesMask));\r
 182         byte[] bytesArbMask = {0,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};\r
 183         Assert.assertEquals(trueCase,IpConversionUtil.isIpv6ArbitraryBitMask(bytesArbMask));\r
 184     }\r
 185 \r
 186     @Test\r
 187     public void extractIpv6AddressTest() {\r
 188         Ipv6Address ipv6Address;\r
 189         ipv6Address = IpConversionUtil.extractIpv6Address(new Ipv6Prefix("1:2:3:4:5:6:7:8/16"));\r
 190         Assert.assertEquals(ipv6Address.getValue(),"1:2:3:4:5:6:7:8");\r
 191     }\r
 192 \r
 193     @Test\r
 194     public void extractIpv6PrefixTest() {\r
 195         int ipv6Address;\r
 196         ipv6Address = IpConversionUtil.extractIpv6Prefix(new Ipv6Prefix("1:2:3:4:5:6:7:8/16"));\r
 197         Assert.assertEquals(ipv6Address,16);\r
 198     }\r
 199 \r
 200     @Test\r
 201     public void compressedIpv6MaskFormatTest() {\r
 202         Ipv6ArbitraryMask compressedIpv6Mask;\r
 203         Ipv6ArbitraryMask ipv6IpAddressMask;\r
 204         // zero compression\r
 205         ipv6IpAddressMask = new Ipv6ArbitraryMask("FFFF:0000:0000:0:0:0:1001:1000");\r
 206         compressedIpv6Mask = IpConversionUtil.compressedIpv6MaskFormat(ipv6IpAddressMask);\r
 207         Assert.assertEquals(compressedIpv6Mask.getValue(), "ffff::1001:1000");\r
 208         // :: present - no compression\r
 209         ipv6IpAddressMask = new Ipv6ArbitraryMask("FFFF::F000:0:0:1000");\r
 210         compressedIpv6Mask = IpConversionUtil.compressedIpv6MaskFormat(ipv6IpAddressMask);\r
 211         Assert.assertEquals(compressedIpv6Mask.getValue(), "ffff::f000:0:0:1000");\r
 212         // more zero sequences - compress only one\r
 213         ipv6IpAddressMask = new Ipv6ArbitraryMask("FFFF:0:0:F000:0000:0:0:1000");\r
 214         compressedIpv6Mask = IpConversionUtil.compressedIpv6MaskFormat(ipv6IpAddressMask);\r
 215         Assert.assertEquals(compressedIpv6Mask.getValue(), "ffff:0:0:f000::1000");\r
 216     }\r
 217 \r
 218     @Test\r
 219     public void compressedIpv6AddressFormatTest() {\r
 220         Ipv6Address compressedIpv6Address;\r
 221         Ipv6Address ipv6IpAddressMask;\r
 222         // zero compression\r
 223         ipv6IpAddressMask = new Ipv6Address("FFFF:0000:0000:0:0:0:1001:1000");\r
 224         compressedIpv6Address = IpConversionUtil.compressedIpv6AddressFormat(ipv6IpAddressMask);\r
 225         Assert.assertEquals(compressedIpv6Address.getValue(), "ffff::1001:1000");\r
 226         // :: present - no compression\r
 227         ipv6IpAddressMask = new Ipv6Address("FFFF::F000:0:0:1000");\r
 228         compressedIpv6Address = IpConversionUtil.compressedIpv6AddressFormat(ipv6IpAddressMask);\r
 229         Assert.assertEquals(compressedIpv6Address.getValue(), "ffff::f000:0:0:1000");\r
 230         // more zero sequences - compress only one\r
 231         ipv6IpAddressMask = new Ipv6Address("FFFF:0:0:F000:0000:0:0:1000");\r
 232         compressedIpv6Address = IpConversionUtil.compressedIpv6AddressFormat(ipv6IpAddressMask);\r
 233         Assert.assertEquals(compressedIpv6Address.getValue(), "ffff:0:0:f000::1000");\r
 234     }\r
 235 \r
 236 }\r