util/src/test/java/org/opendaylight/protocol/util/ByteBufWriteUtilTest.java

   1 /*
   2  * Copyright (c) 2014 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
   9 package org.opendaylight.protocol.util;
  10
  11 import static org.junit.Assert.assertArrayEquals;
  12 import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeBoolean;
  13 import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeFloat32;
  14 import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeInt;
  15 import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeIpv4Address;
  16 import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeIpv4Prefix;
  17 import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeIpv6Address;
  18 import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeIpv6Prefix;
  19 import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeLong;
  20 import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeMedium;
  21 import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeShort;
  22 import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeUnsignedByte;
  23 import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeUnsignedInt;
  24 import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeUnsignedLong;
  25 import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeUnsignedShort;
  26
  27 import io.netty.buffer.ByteBuf;
  28 import io.netty.buffer.Unpooled;
  29 import org.junit.Test;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ieee754.rev130819.Float32;
  35 import org.opendaylight.yangtools.yang.common.Uint16;
  36 import org.opendaylight.yangtools.yang.common.Uint32;
  37 import org.opendaylight.yangtools.yang.common.Uint64;
  38 import org.opendaylight.yangtools.yang.common.Uint8;
  39
  40 public class ByteBufWriteUtilTest {
  41
  42     private static final byte[] ONE_BYTE_ZERO = {0};
  43
  44     private static final byte[] TWO_BYTE_ZEROS = {0, 0};
  45
  46     private static final byte[] FOUR_BYTE_ZEROS = {0, 0, 0, 0};
  47
  48     private static final byte[] EIGHT_BYTE_ZEROS = { 0, 0, 0, 0, 0, 0, 0, 0 };
  49
  50     @Test
  51     public void testWriteIntegerValue() {
  52         final byte[] result = { 0, 0, 0, 5 };
  53         final ByteBuf output = Unpooled.buffer(ByteBufWriteUtil.INT_BYTES_LENGTH);
  54         writeInt(5, output);
  55         assertArrayEquals(result, output.array());
  56
  57         output.clear();
  58         writeInt(null, output);
  59         assertArrayEquals(FOUR_BYTE_ZEROS, output.array());
  60     }
  61
  62     @Test
  63     public void testWriteShortValue() {
  64         final byte[] result = { 0, 5 };
  65         final ByteBuf output = Unpooled.buffer(ByteBufWriteUtil.SHORT_BYTES_LENGTH);
  66         writeShort((short) 5, output);
  67         assertArrayEquals(result, output.array());
  68
  69         output.clear();
  70         writeShort(null, output);
  71         assertArrayEquals(TWO_BYTE_ZEROS, output.array());
  72     }
  73
  74     @Test
  75     public void testWriteMediumValue() {
  76         final byte[] result = { 0, 0, 5 };
  77         final ByteBuf output = Unpooled.buffer(3);
  78         writeMedium(5, output);
  79         assertArrayEquals(result, output.array());
  80
  81         output.clear();
  82         final byte[] resultZero = { 0, 0, 0 };
  83         writeMedium(null, output);
  84         assertArrayEquals(resultZero, output.array());
  85     }
  86
  87     @Test
  88     public void testWriteLongValue() {
  89         final byte[] result = { 0, 0, 0, 0, 0, 0, 0, 5 };
  90         final ByteBuf output = Unpooled.buffer(ByteBufWriteUtil.LONG_BYTES_LENGTH);
  91         writeLong((long) 5, output);
  92         assertArrayEquals(result, output.array());
  93
  94         output.clear();
  95         writeLong(null, output);
  96         assertArrayEquals(EIGHT_BYTE_ZEROS, output.array());
  97     }
  98
  99     @Test
 100     public void testWriteBooleanValue() {
 101         final byte[] result = { 1 };
 102         final ByteBuf output = Unpooled.buffer(ByteBufWriteUtil.ONE_BYTE_LENGTH);
 103         writeBoolean(true, output);
 104         assertArrayEquals(result, output.array());
 105
 106         output.clear();
 107         writeBoolean(null, output);
 108         assertArrayEquals(ONE_BYTE_ZERO, output.array());
 109     }
 110
 111     @Test
 112     public void testWriteUnsignedByteValue() {
 113         final byte[] result = { 5 };
 114         final ByteBuf output = Unpooled.buffer(ByteBufWriteUtil.ONE_BYTE_LENGTH);
 115         writeUnsignedByte(Uint8.valueOf(5), output);
 116         assertArrayEquals(result, output.array());
 117
 118         output.clear();
 119         writeUnsignedByte((Uint8) null, output);
 120         assertArrayEquals(ONE_BYTE_ZERO, output.array());
 121     }
 122
 123     @Test
 124     public void testWriteUnsignedShortValue() {
 125         final byte[] result = { 0, 5 };
 126         final ByteBuf output = Unpooled.buffer(ByteBufWriteUtil.SHORT_BYTES_LENGTH);
 127         writeUnsignedShort(Uint16.valueOf(5), output);
 128         assertArrayEquals(result, output.array());
 129
 130         output.clear();
 131         writeUnsignedShort((Uint16) null, output);
 132         assertArrayEquals(TWO_BYTE_ZEROS, output.array());
 133     }
 134
 135     @Test
 136     public void testWriteUnsignedIntValue() {
 137         final byte[] result = { 0, 0, 0, 5 };
 138         final ByteBuf output = Unpooled.buffer(ByteBufWriteUtil.INT_BYTES_LENGTH);
 139         ByteBufWriteUtil.writeUnsignedInt(Uint32.valueOf(5), output);
 140         assertArrayEquals(result, output.array());
 141
 142         output.clear();
 143         writeUnsignedInt((Uint32) null, output);
 144         assertArrayEquals(FOUR_BYTE_ZEROS, output.array());
 145     }
 146
 147     @Test
 148     public void testWriteUnsignedLongValue() {
 149         final byte[] result = { 0, 0, 0, 0, 0, 0, 0, 5 };
 150         final ByteBuf output = Unpooled.buffer(ByteBufWriteUtil.LONG_BYTES_LENGTH);
 151         writeUnsignedLong(Uint64.valueOf(5), output);
 152         assertArrayEquals(result, output.array());
 153
 154         output.clear();
 155         writeUnsignedLong((Uint64) null, output);
 156         assertArrayEquals(EIGHT_BYTE_ZEROS, output.array());
 157     }
 158
 159     @Test
 160     public void testWriteIpv4Address() {
 161         final byte[] result = { 127, 0, 0, 1 };
 162         final ByteBuf output = Unpooled.buffer(Ipv4Util.IP4_LENGTH);
 163         writeIpv4Address(new Ipv4Address("127.0.0.1"), output);
 164         assertArrayEquals(result, output.array());
 165
 166         output.clear();
 167         writeIpv4Address(null, output);
 168         assertArrayEquals(FOUR_BYTE_ZEROS, output.array());
 169     }
 170
 171     @Test
 172     public void testWriteIpv4Prefix() {
 173         final byte[] result = { 123, 122, 4, 5, 8 };
 174         final ByteBuf output = Unpooled.buffer(ByteBufWriteUtil.IPV4_PREFIX_BYTE_LENGTH);
 175         writeIpv4Prefix(new Ipv4Prefix("123.122.4.5/8"), output);
 176         assertArrayEquals(result, output.array());
 177
 178         output.clear();
 179         final byte[] zeroResult = { 0, 0, 0, 0, 0 };
 180         writeIpv4Prefix(null, output);
 181         assertArrayEquals(zeroResult, output.array());
 182     }
 183
 184     @Test
 185     public void testWriteIpv6Address() {
 186         final byte[] result = { 0x20, (byte) 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 187             0x00, 0x00, 0x01 };
 188         final ByteBuf output = Unpooled.buffer(Ipv6Util.IPV6_LENGTH);
 189         writeIpv6Address(new Ipv6Address("2001::1"), output);
 190         assertArrayEquals(result, output.array());
 191
 192         output.clear();
 193         final byte[] zeroResult = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,};
 194         writeIpv6Address(null, output);
 195         assertArrayEquals(zeroResult, output.array());
 196     }
 197
 198     @Test
 199     public void testWriteIpv6Prefix() {
 200         final byte[] result = { 0x20, (byte) 0x01, 0x0d, (byte) 0xb8, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
 201             0x00, 0x00, 0x00, 0x00, 0x40 };
 202         final ByteBuf output = Unpooled.buffer(ByteBufWriteUtil.IPV6_PREFIX_BYTE_LENGTH);
 203         writeIpv6Prefix(new Ipv6Prefix("2001:db8:1:2::/64"), output);
 204         assertArrayEquals(result, output.array());
 205
 206         output.clear();
 207         final byte[] zeroResult = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 208         writeIpv6Prefix(null, output);
 209         assertArrayEquals(zeroResult, output.array());
 210     }
 211
 212     @Test
 213     public void testWriteFloat32() {
 214         final byte[] result = { 0, 0, 0, 5 };
 215         final ByteBuf output = Unpooled.buffer(ByteBufWriteUtil.FLOAT32_BYTES_LENGTH);
 216         writeFloat32(new Float32(result), output);
 217         assertArrayEquals(result, output.array());
 218
 219         output.clear();
 220         writeFloat32(null, output);
 221         assertArrayEquals(FOUR_BYTE_ZEROS, output.array());
 222     }
 223 }