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