openflowjava/openflow-protocol-impl/src/test/java/org/opendaylight/openflowjava/protocol/impl/serialization/factories/HelloInputMessageFactoryTest.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.protocol.impl.serialization.factories;
  10
  11 import io.netty.buffer.ByteBuf;
  12 import io.netty.buffer.UnpooledByteBufAllocator;
  13 import java.util.ArrayList;
  14 import java.util.List;
  15 import org.junit.Assert;
  16 import org.junit.Before;
  17 import org.junit.Test;
  18 import org.opendaylight.openflowjava.protocol.api.extensibility.OFSerializer;
  19 import org.opendaylight.openflowjava.protocol.api.extensibility.SerializerRegistry;
  20 import org.opendaylight.openflowjava.protocol.api.keys.MessageTypeKey;
  21 import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
  22 import org.opendaylight.openflowjava.protocol.impl.serialization.SerializerRegistryImpl;
  23 import org.opendaylight.openflowjava.protocol.impl.util.BufferHelper;
  24 import org.opendaylight.openflowjava.util.ByteBufUtils;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.HelloElementType;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.HelloInput;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.HelloInputBuilder;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.hello.Elements;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.hello.ElementsBuilder;
  30 import org.slf4j.Logger;
  31 import org.slf4j.LoggerFactory;
  32
  33 /**
  34  * Unit tests for HelloInputMessageFactory.
  35  *
  36  * @author michal.polkorab
  37  */
  38 public class HelloInputMessageFactoryTest {
  39
  40     private static final Logger LOG = LoggerFactory.getLogger(HelloInputMessageFactoryTest.class);
  41     private SerializerRegistry registry;
  42     private OFSerializer<HelloInput> helloFactory;
  43
  44     /**
  45      * Initializes serializer registry and stores correct factory in field.
  46      */
  47     @Before
  48     public void startUp() {
  49         registry = new SerializerRegistryImpl();
  50         registry.init();
  51         helloFactory = registry.getSerializer(
  52                 new MessageTypeKey<>(EncodeConstants.OF13_VERSION_ID, HelloInput.class));
  53     }
  54
  55     /**
  56      * Testing of {@link HelloInputMessageFactory} for correct translation from POJO.
  57      */
  58     @Test
  59     public void testWithoutElementsSet() throws Exception {
  60         HelloInputBuilder hib = new HelloInputBuilder();
  61         BufferHelper.setupHeader(hib, EncodeConstants.OF13_VERSION_ID);
  62         HelloInput hi = hib.build();
  63
  64         ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
  65         helloFactory.serialize(hi, out);
  66
  67         BufferHelper.checkHeaderV13(out,(byte) 0, EncodeConstants.OFHEADER_SIZE);
  68     }
  69
  70     /**
  71      * Testing of {@link HelloInputMessageFactory} for correct translation from POJO.
  72      */
  73     @Test
  74     public void testWith4BitVersionBitmap() throws Exception {
  75         int lengthOfBitmap = 4;
  76         HelloInputBuilder builder = new HelloInputBuilder();
  77         BufferHelper.setupHeader(builder, EncodeConstants.OF13_VERSION_ID);
  78         List<Elements> expectedElement = createElement(lengthOfBitmap);
  79         builder.setElements(expectedElement);
  80         HelloInput message = builder.build();
  81
  82         ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
  83         helloFactory.serialize(message, out);
  84         if (LOG.isDebugEnabled()) {
  85             LOG.debug("bytebuf: {}", ByteBufUtils.byteBufToHexString(out));
  86         }
  87
  88         BufferHelper.checkHeaderV13(out, (byte) 0, 16);
  89         Elements element = readElement(out).get(0);
  90         Assert.assertEquals("Wrong element type", expectedElement.get(0).getType(), element.getType());
  91         Elements comparation = createComparationElement(lengthOfBitmap).get(0);
  92         Assert.assertArrayEquals("Wrong element bitmap", comparation.getVersionBitmap().toArray(),
  93                 element.getVersionBitmap().toArray());
  94     }
  95
  96     /**
  97      * Testing of {@link HelloInputMessageFactory} for correct translation from POJO.
  98      */
  99     @Test
 100     public void testWith64BitVersionBitmap() throws Exception {
 101         int lengthOfBitmap = 64;
 102         HelloInputBuilder builder = new HelloInputBuilder();
 103         BufferHelper.setupHeader(builder, EncodeConstants.OF13_VERSION_ID);
 104         List<Elements> expectedElement = createElement(lengthOfBitmap);
 105         builder.setElements(expectedElement);
 106         HelloInput message = builder.build();
 107
 108         ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
 109         helloFactory.serialize(message, out);
 110         if (LOG.isDebugEnabled()) {
 111             LOG.debug("bytebuf: ", ByteBufUtils.byteBufToHexString(out));
 112         }
 113
 114         BufferHelper.checkHeaderV13(out, (byte) 0, 24);
 115         Elements element = readElement(out).get(0);
 116         Assert.assertEquals("Wrong element type", expectedElement.get(0).getType(), element.getType());
 117         Elements comparation = createComparationElement(lengthOfBitmap).get(0);
 118         Assert.assertArrayEquals("Wrong element bitmap", comparation.getVersionBitmap().toArray(),
 119                 element.getVersionBitmap().toArray());
 120     }
 121
 122     private static List<Elements> createElement(int lengthOfBitmap) {
 123         ElementsBuilder elementsBuilder = new ElementsBuilder();
 124         final List<Elements> elementsList = new ArrayList<>();
 125         List<Boolean> booleanList = new ArrayList<>();
 126         for (int i = 0; i < lengthOfBitmap; i++) {
 127             booleanList.add(true);
 128         }
 129         elementsBuilder.setType(HelloElementType.forValue(1));
 130         elementsBuilder.setVersionBitmap(booleanList);
 131         elementsList.add(elementsBuilder.build());
 132         return elementsList;
 133     }
 134
 135     private static List<Elements> createComparationElement(int lengthOfBitmap) {
 136         final ElementsBuilder elementsBuilder = new ElementsBuilder();
 137         final List<Elements> elementsList = new ArrayList<>();
 138         List<Boolean> booleanList = new ArrayList<>();
 139         for (int i = 0; i < lengthOfBitmap; i++) {
 140             booleanList.add(true);
 141         }
 142         if (lengthOfBitmap % Integer.SIZE != 0) {
 143             for (int i = 0; i < Integer.SIZE - lengthOfBitmap % Integer.SIZE; i++) {
 144                 booleanList.add(false);
 145             }
 146         }
 147         LOG.debug("boolsize {}", booleanList.size());
 148         elementsBuilder.setType(HelloElementType.forValue(1));
 149         elementsBuilder.setVersionBitmap(booleanList);
 150         elementsList.add(elementsBuilder.build());
 151         return elementsList;
 152     }
 153
 154     private static List<Elements> readElement(ByteBuf input) {
 155         List<Elements> elementsList = new ArrayList<>();
 156         while (input.readableBytes() > 0) {
 157             ElementsBuilder elementsBuilder = new ElementsBuilder();
 158             int type = input.readUnsignedShort();
 159             int elementLength = input.readUnsignedShort();
 160             if (type == HelloElementType.VERSIONBITMAP.getIntValue()) {
 161                 elementsBuilder.setType(HelloElementType.forValue(type));
 162                 int[] versionBitmap = new int[(elementLength - 4) / 4];
 163                 for (int i = 0; i < versionBitmap.length; i++) {
 164                     versionBitmap[i] = (int) input.readUnsignedInt();
 165                 }
 166                 elementsBuilder.setVersionBitmap(readVersionBitmap(versionBitmap));
 167                 int paddingRemainder = elementLength % EncodeConstants.PADDING;
 168                 if (paddingRemainder != 0) {
 169                     input.readBytes(EncodeConstants.PADDING - paddingRemainder);
 170                 }
 171             }
 172             elementsList.add(elementsBuilder.build());
 173         }
 174         return elementsList;
 175     }
 176
 177     private static List<Boolean> readVersionBitmap(int[] input) {
 178         List<Boolean> versionBitmapList = new ArrayList<>();
 179         for (int mask : input) {
 180             for (int j = 0; j < Integer.SIZE; j++) {
 181                 versionBitmapList.add((mask & 1 << j) != 0);
 182             }
 183         }
 184         return versionBitmapList;
 185     }
 186
 187 }