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