util/src/test/java/org/opendaylight/openflowjava/util/ByteBufUtilsTest.java

   1 /*
   2  * Copyright (c) 2013 Pantheon Technologies s.r.o. 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
   9 package org.opendaylight.openflowjava.util;
  10
  11 import io.netty.buffer.ByteBuf;
  12 import io.netty.buffer.PooledByteBufAllocator;
  13 import io.netty.buffer.UnpooledByteBufAllocator;
  14
  15 import java.util.ArrayList;
  16 import java.util.HashMap;
  17 import java.util.List;
  18 import java.util.Map;
  19
  20 import org.junit.Assert;
  21 import org.junit.Test;
  22 import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
  23 import org.opendaylight.openflowjava.util.ByteBufUtils;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.HelloInput;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.HelloInputBuilder;
  26
  27 /**
  28  * @author michal.polkorab
  29  *
  30  */
  31 public class ByteBufUtilsTest {
  32
  33     private byte[] expected = new byte[]{0x01, 0x02, 0x03, 0x04, 0x05, (byte) 0xff};
  34
  35     /**
  36      * Test of {@link org.opendaylight.openflowjava.util.ByteBufUtils#hexStringToBytes(String)}
  37      */
  38     @Test
  39     public void testHexStringToBytes() {
  40         byte[] data = ByteBufUtils.hexStringToBytes("01 02 03 04 05 ff");
  41
  42         Assert.assertArrayEquals(expected, data);
  43     }
  44
  45     /**
  46      * Test of {@link ByteBufUtils#hexStringToBytes(String, boolean)}
  47      */
  48     @Test
  49     public void testHexStringToBytes2() {
  50         byte[] data = ByteBufUtils.hexStringToBytes("0102030405ff", false);
  51
  52         Assert.assertArrayEquals(expected, data);
  53     }
  54
  55     /**
  56      * Test of {@link ByteBufUtils#hexStringToByteBuf(String)}
  57      */
  58     @Test
  59     public void testHexStringToByteBuf() {
  60         ByteBuf bb = ByteBufUtils.hexStringToByteBuf("01 02 03 04 05 ff");
  61
  62         Assert.assertArrayEquals(expected, byteBufToByteArray(bb));
  63     }
  64
  65     /**
  66      * Test of {@link ByteBufUtils#hexStringToByteBuf(String, ByteBuf)}
  67      */
  68     @Test
  69     public void testHexStringToGivenByteBuf() {
  70         ByteBuf buffer = UnpooledByteBufAllocator.DEFAULT.buffer();
  71         ByteBufUtils.hexStringToByteBuf("01 02 03 04 05 ff", buffer);
  72
  73         Assert.assertArrayEquals(expected, byteBufToByteArray(buffer));
  74     }
  75
  76     private static byte[] byteBufToByteArray(ByteBuf bb) {
  77         byte[] result = new byte[bb.readableBytes()];
  78         bb.readBytes(result);
  79         return result;
  80     }
  81
  82     /**
  83      * Test of {@link ByteBufUtils#fillBitMaskFromMap(java.util.Map)}
  84      */
  85     @Test
  86     public void testFillBitmaskByEmptyMap() {
  87         Map<Integer, Boolean> emptyMap = new HashMap<>();
  88         String expectedBinaryString = "00000000000000000000000000000000";
  89         String bitmaskInBinaryString = toBinaryString(emptyMap, 32);
  90
  91         Assert.assertEquals("Not null string", expectedBinaryString, bitmaskInBinaryString);
  92     }
  93
  94     private static String toBinaryString(Map<Integer, Boolean> emptyMap, int length) {
  95         String binaryString = Integer.toBinaryString(ByteBufUtils.fillBitMaskFromMap(emptyMap));
  96         return String.format("%"+length+"s", binaryString).replaceAll(" ", "0");
  97     }
  98
  99     /**
 100      * Test of {@link ByteBufUtils#fillBitMaskFromMap(java.util.Map)}
 101      */
 102     @Test
 103     public void testFillBitmaskByFullMap() {
 104         Map<Integer, Boolean> fullMap = new HashMap<>();
 105         String expectedBinaryString = "11111111111111111111111111111111";
 106         String bitmaskValueInBinarySytring;
 107         for(Integer i=0;i<=31;i++) {
 108             fullMap.put(i, true);
 109         }
 110         bitmaskValueInBinarySytring = toBinaryString(fullMap, 32);
 111         Assert.assertEquals("Strings does not match", expectedBinaryString, bitmaskValueInBinarySytring);
 112     }
 113
 114     /**
 115      * Test of {@link ByteBufUtils#fillBitMaskFromMap(java.util.Map)}
 116      */
 117     @Test
 118     public void testFillBitmaskByZeroMap() {
 119         Map<Integer, Boolean> zeroMap = new HashMap<>();
 120         String expectedBinaryString = "00000000000000000000000000000000";
 121         String bitmaskValueInBinarySytring;
 122         for(Integer i=0;i<=31;i++) {
 123             zeroMap.put(i, false);
 124         }
 125         bitmaskValueInBinarySytring = toBinaryString(zeroMap, 32);
 126         Assert.assertEquals("Strings does not match", expectedBinaryString, bitmaskValueInBinarySytring);
 127     }
 128
 129     /**
 130      * Test of {@link ByteBufUtils#fillBitMaskFromMap(java.util.Map)}
 131      */
 132     @Test
 133     public void testFillBitmaskByRandomSet() {
 134         Map<Integer, Boolean> randomMap = new HashMap<>();
 135         String expectedBinaryString = "00000000000000000111100000000000";
 136         String bitmaskValueInBinarySytring;
 137         Boolean mapValue;
 138         for(Integer i=0;i<=31;i++) {
 139             mapValue = false;
 140             if(i>=11 && i<=14) {
 141                 mapValue = true;
 142             }
 143             randomMap.put(i, mapValue);
 144         }
 145         bitmaskValueInBinarySytring = toBinaryString(randomMap, 32);
 146         Assert.assertEquals("Strings does not match", expectedBinaryString, bitmaskValueInBinarySytring);
 147     }
 148
 149     /**
 150      * Test of {@link ByteBufUtils#fillBitMaskFromList(List)}
 151      */
 152     @Test
 153     public void testFillBitmaskByEmptyList() {
 154         List<Boolean> emptyList = new ArrayList<>();
 155         emptyList.add(null);
 156         String expectedBinaryString = "00000000000000000000000000000000";
 157         String bitmaskInBinaryString = listToBinaryString(emptyList, 32);
 158
 159         Assert.assertEquals("Not null string", expectedBinaryString, bitmaskInBinaryString);
 160     }
 161
 162     private static String listToBinaryString(List<Boolean> emptyList, int length) {
 163         int[] bitMaskArray;
 164         bitMaskArray = ByteBufUtils.fillBitMaskFromList(emptyList);
 165         String binaryString = Integer.toBinaryString(bitMaskArray[0]);
 166         return String.format("%"+length+"s", binaryString).replaceAll(" ", "0");
 167     }
 168
 169     /**
 170      * Test of {@link ByteBufUtils#fillBitMaskFromList(List)}
 171      */
 172     @Test
 173     public void testFillBitmaskByFullList() {
 174         List<Boolean> fullList = new ArrayList<>();
 175         String expectedBinaryString = "11111111111111111111111111111111";
 176         String bitmaskValueInBinarySytring;
 177         for(Integer i=0;i<=31;i++) {
 178             fullList.add(true);
 179         }
 180         bitmaskValueInBinarySytring = listToBinaryString(fullList, 32);
 181         Assert.assertEquals("Strings does not match", expectedBinaryString, bitmaskValueInBinarySytring);
 182     }
 183
 184     /**
 185      * Test of {@link ByteBufUtils#fillBitMaskFromList(List)}
 186      */
 187     @Test
 188     public void testFillBitmaskByZeroList() {
 189         List<Boolean> zeroList = new ArrayList<>();
 190         String expectedBinaryString = "00000000000000000000000000000000";
 191         String bitmaskValueInBinarySytring;
 192         for(Integer i=0;i<=31;i++) {
 193             zeroList.add(false);
 194         }
 195         bitmaskValueInBinarySytring = listToBinaryString(zeroList, 32);
 196         Assert.assertEquals("Strings does not match", expectedBinaryString, bitmaskValueInBinarySytring);
 197     }
 198
 199     /**
 200      * Test of {@link ByteBufUtils#fillBitMaskFromList(List)}
 201      */
 202     @Test
 203     public void testFillBitmaskFromRandomList() {
 204         List<Boolean> randomList = new ArrayList<>();
 205         String expectedBinaryString = "00000000000000000111100000000000";
 206         String bitmaskValueInBinarySytring;
 207         Boolean listValue;
 208         for(Integer i=0;i<=31;i++) {
 209             listValue = false;
 210             if(i>=11 && i<=14) {
 211                 listValue = true;
 212             }
 213             randomList.add(listValue);
 214         }
 215         bitmaskValueInBinarySytring = listToBinaryString(randomList, 32);
 216         Assert.assertEquals("Strings does not match", expectedBinaryString, bitmaskValueInBinarySytring);
 217     }
 218
 219     /**
 220      * Test of {@link ByteBufUtils#macAddressToBytes(String)}
 221      */
 222     @Test
 223     public void testMacToBytes() {
 224         Assert.assertArrayEquals("Wrong byte array", new byte[]{0, 1, 2, 3, (byte) 255, 5},
 225                 ByteBufUtils.macAddressToBytes("00:01:02:03:FF:05"));
 226         Assert.assertArrayEquals("Wrong byte array", new byte[]{11, 1, 2, 3, (byte) 255, 10},
 227                 ByteBufUtils.macAddressToBytes("0b:01:02:03:FF:0a"));
 228     }
 229
 230     /**
 231      * Test of {@link ByteBufUtils#macAddressToBytes(String)}
 232      */
 233     @Test(expected=IllegalArgumentException.class)
 234     public void testMacToBytes2() {
 235         Assert.assertArrayEquals("Wrong byte array", new byte[]{0, 1, 2, 3, (byte) 255, 5},
 236                 ByteBufUtils.macAddressToBytes("00:01:02:03:FF:0G"));
 237     }
 238
 239     /**
 240      * Test of {@link ByteBufUtils#macAddressToString(byte[])}
 241      */
 242     @Test(expected=IllegalArgumentException.class)
 243     public void testMacToString() {
 244         Assert.assertEquals("Wrong string decoded", "00:01:02:03:FF:05",
 245                 ByteBufUtils.macAddressToString(new byte[]{0, 1, 2, 3, (byte) 255, 5}));
 246         ByteBufUtils.macAddressToString(new byte[]{0, 1, 2, 3, (byte) 255, 5, 6});
 247     }
 248
 249     /**
 250      * Test of {@link ByteBufUtils#decodeNullTerminatedString(ByteBuf, int)}
 251      */
 252     @Test
 253     public void testDecodeString() {
 254         ByteBuf buf = ByteBufUtils.hexStringToByteBuf("4A 41 4D 45 53 20 42 4F 4E 44 00 00 00 00 00 00");
 255         Assert.assertEquals("Wrong string decoded", "JAMES BOND", ByteBufUtils.decodeNullTerminatedString(buf, 16));
 256
 257         ByteBuf buf2 = ByteBufUtils.hexStringToByteBuf("53 50 49 44 45 52 4D 41 4E 00 00 00 00 00 00");
 258         Assert.assertEquals("Wrong string decoded", "SPIDERMAN", ByteBufUtils.decodeNullTerminatedString(buf2, 15));
 259     }
 260
 261     /**
 262      * Test of {@link ByteBufUtils#byteBufToHexString(ByteBuf)}
 263      */
 264     @Test
 265     public void testByteBufToHexString() {
 266         ByteBuf buf = ByteBufUtils.hexStringToByteBuf("00 01 02 03 04 05 06 07");
 267         buf.skipBytes(4);
 268         Assert.assertEquals("Wrong data read", "04 05 06 07", ByteBufUtils.byteBufToHexString(buf));
 269     }
 270
 271     /**
 272      * Buffer padding test
 273      */
 274     @Test
 275     public void testPadBuffer() {
 276         ByteBuf buf = PooledByteBufAllocator.DEFAULT.buffer();
 277         ByteBufUtils.padBuffer(4, buf);
 278         Assert.assertEquals("Wrong padding", 0, buf.readUnsignedInt());
 279         ByteBufUtils.padBuffer(0, buf);
 280         Assert.assertTrue("Wrong padding", buf.readableBytes() == 0);
 281     }
 282
 283     /**
 284      * Write OF header test
 285      */
 286     @Test
 287     public void testWriteHeader() {
 288         ByteBuf buf = PooledByteBufAllocator.DEFAULT.buffer();
 289         HelloInputBuilder helloBuilder = new HelloInputBuilder();
 290         helloBuilder.setVersion((short) EncodeConstants.OF13_VERSION_ID);
 291         helloBuilder.setXid(12345L);
 292         helloBuilder.setElements(null);
 293         HelloInput helloInput = helloBuilder.build();
 294         ByteBufUtils.writeOFHeader((byte) 0, helloInput, buf, EncodeConstants.OFHEADER_SIZE);
 295         Assert.assertEquals("Wrong version", EncodeConstants.OF13_VERSION_ID, buf.readUnsignedByte());
 296         Assert.assertEquals("Wrong type", 0, buf.readUnsignedByte());
 297         Assert.assertEquals("Wrong length", EncodeConstants.OFHEADER_SIZE, buf.readUnsignedShort());
 298         Assert.assertEquals("Wrong xid", 12345, buf.readUnsignedInt());
 299         Assert.assertTrue("Unexpected data", buf.readableBytes() == 0);
 300     }
 301
 302     /**
 303      * Fill bitmask test
 304      */
 305     @Test
 306     public void testFillBitmask() {
 307         Assert.assertEquals("Wrong bitmask", 0, ByteBufUtils.fillBitMask(0, false));
 308         Assert.assertEquals("Wrong bitmask", 1, ByteBufUtils.fillBitMask(0, true));
 309         Assert.assertEquals("Wrong bitmask", 3, ByteBufUtils.fillBitMask(0, true, true));
 310         Assert.assertEquals("Wrong bitmask", 2, ByteBufUtils.fillBitMask(0, false, true));
 311         Assert.assertEquals("Wrong bitmask", 1, ByteBufUtils.fillBitMask(0, true, false));
 312         Assert.assertEquals("Wrong bitmask", 2, ByteBufUtils.fillBitMask(1, true, false));
 313         Assert.assertEquals("Wrong bitmask", 4, ByteBufUtils.fillBitMask(1, false, true));
 314         Assert.assertEquals("Wrong bitmask", 6, ByteBufUtils.fillBitMask(1, true, true));
 315         Assert.assertEquals("Wrong bitmask", 0, ByteBufUtils.fillBitMask(1));
 316     }
 317
 318     /**
 319      * Test bytes to hex string
 320      */
 321     @Test
 322     public void testBytesToHexString() {
 323         byte[] array = new byte[]{10, 11, 12, 13, 14, 15, 16};
 324         Assert.assertEquals("Wrong conversion", "0a 0b 0c 0d 0e 0f 10", ByteBufUtils.bytesToHexString(array));
 325         byte[] empty = new byte[0];
 326         Assert.assertEquals("Wrong conversion", "", ByteBufUtils.bytesToHexString(empty));
 327     }
 328
 329     /**
 330      * Test ipv4 address conversion
 331      */
 332     @Test(expected=IndexOutOfBoundsException.class)
 333     public void testReadIpv4Address() {
 334         ByteBuf buffer = PooledByteBufAllocator.DEFAULT.buffer();
 335         buffer.writeByte(10);
 336         buffer.writeByte(20);
 337         buffer.writeByte(30);
 338         buffer.writeByte(40);
 339         String ipv4Address = ByteBufUtils.readIpv4Address(buffer);
 340         Assert.assertEquals("Wrong conversion", "10.20.30.40", ipv4Address);
 341         Assert.assertTrue("Unexpected data", buffer.readableBytes() == 0);
 342
 343         ByteBuf buffer2 = PooledByteBufAllocator.DEFAULT.buffer();
 344         buffer.writeByte(10);
 345         ipv4Address = ByteBufUtils.readIpv4Address(buffer2);
 346     }
 347
 348     /**
 349      * Test ipv6 address conversion
 350      */
 351     @Test(expected=IndexOutOfBoundsException.class)
 352     public void testReadIpv6Address() {
 353         ByteBuf buffer = PooledByteBufAllocator.DEFAULT.buffer();
 354         buffer.writeShort(10);
 355         buffer.writeShort(65535);
 356         buffer.writeShort(4096);
 357         buffer.writeShort(0);
 358         buffer.writeShort(1024);
 359         buffer.writeShort(42);
 360         buffer.writeShort(2568);
 361         buffer.writeShort(45689);
 362         String ipv4Address = ByteBufUtils.readIpv6Address(buffer);
 363         Assert.assertEquals("Wrong conversion", "000A:FFFF:1000:0000:0400:002A:0A08:B279", ipv4Address);
 364         Assert.assertTrue("Unexpected data", buffer.readableBytes() == 0);
 365
 366         ByteBuf buffer2 = PooledByteBufAllocator.DEFAULT.buffer();
 367         buffer.writeShort(10);
 368         ipv4Address = ByteBufUtils.readIpv6Address(buffer2);
 369     }
 370 }