openflow-protocol-impl/src/test/java/org/opendaylight/openflowjava/protocol/impl/serialization/factories/MultipartRequestInputFactoryTest.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
  14 import java.math.BigInteger;
  15 import java.util.ArrayList;
  16 import java.util.List;
  17
  18 import junit.framework.Assert;
  19
  20 import org.junit.Test;
  21 import org.opendaylight.openflowjava.protocol.impl.deserialization.factories.HelloMessageFactoryTest;
  22 import org.opendaylight.openflowjava.protocol.impl.util.BufferHelper;
  23 import org.opendaylight.openflowjava.protocol.impl.util.EncodeConstants;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.GroupId;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MeterId;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MultipartRequestFlags;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MultipartType;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.TableConfig;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartRequestInput;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartRequestInputBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.MultipartRequestBody;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestAggregateCase;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestAggregateCaseBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestDescCaseBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestExperimenterCase;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestExperimenterCaseBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestFlowCase;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestFlowCaseBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestGroupCase;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestGroupCaseBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestMeterCase;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestMeterCaseBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestMeterConfigCase;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestMeterConfigCaseBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestPortStatsCase;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestPortStatsCaseBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestQueueCase;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestQueueCaseBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestTableFeaturesCase;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.MultipartRequestTableFeaturesCaseBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.multipart.request.aggregate._case.MultipartRequestAggregateBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.multipart.request.desc._case.MultipartRequestDescBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.multipart.request.experimenter._case.MultipartRequestExperimenterBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.multipart.request.flow._case.MultipartRequestFlowBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.multipart.request.group._case.MultipartRequestGroupBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.multipart.request.meter._case.MultipartRequestMeterBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.multipart.request.meter.config._case.MultipartRequestMeterConfigBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.multipart.request.port.stats._case.MultipartRequestPortStatsBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.multipart.request.queue._case.MultipartRequestQueueBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.multipart.request.table.features._case.MultipartRequestTableFeatures;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.multipart.request.table.features._case.MultipartRequestTableFeaturesBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.multipart.request.table.features._case.multipart.request.table.features.TableFeatures;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.request.multipart.request.body.multipart.request.table.features._case.multipart.request.table.features.TableFeaturesBuilder;
  64
  65 /**
  66  * @author timotej.kubas
  67  * @author michal.polkorab
  68  */
  69 public class MultipartRequestInputFactoryTest {
  70     private static final byte PADDING_IN_MULTIPART_REQUEST_MESSAGE = 4;
  71
  72     /**
  73      * @throws Exception
  74      * Testing of {@link MultipartRequestInputFactory} for correct translation from POJO
  75      */
  76     @Test
  77     public void testMultipartRequestInputFactory() throws Exception {
  78         MultipartRequestInputBuilder builder = new MultipartRequestInputBuilder();
  79         BufferHelper.setupHeader(builder, EncodeConstants.OF13_VERSION_ID);
  80         builder.setType(MultipartType.forValue(1));
  81         builder.setFlags(new MultipartRequestFlags(true));
  82         builder.setMultipartRequestBody(createRequestFlow());
  83         MultipartRequestInput message = builder.build();
  84
  85         ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
  86         MultipartRequestInputFactory factory = MultipartRequestInputFactory.getInstance();
  87         factory.messageToBuffer(HelloMessageFactoryTest.VERSION_YET_SUPPORTED, out, message);
  88
  89         BufferHelper.checkHeaderV13(out, factory.getMessageType(), factory.computeLength(message));
  90         Assert.assertEquals("Wrong type", message.getType().getIntValue(), out.readShort());
  91         Assert.assertEquals("Wrong flags", message.getFlags(), decodeMultipartRequestFlags(out.readShort()));
  92         out.skipBytes(PADDING_IN_MULTIPART_REQUEST_MESSAGE);
  93         Assert.assertEquals("Wrong flow", message.getMultipartRequestBody(), decodeRequestFlow(out));
  94     }
  95
  96     private static MultipartRequestFlowCase createRequestFlow() {
  97         MultipartRequestFlowCaseBuilder caseBuilder = new MultipartRequestFlowCaseBuilder();
  98         MultipartRequestFlowBuilder builder = new MultipartRequestFlowBuilder();
  99         builder.setTableId((short) 8);
 100         builder.setOutPort(85L);
 101         builder.setOutGroup(95L);
 102         byte[] cookie = new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
 103         builder.setCookie(new BigInteger(1, cookie));
 104         byte[] cookieMask = new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
 105         builder.setCookieMask(new BigInteger(1, cookieMask));
 106         caseBuilder.setMultipartRequestFlow(builder.build());
 107         //TODO match field
 108         return caseBuilder.build();
 109     }
 110
 111     private static MultipartRequestFlowCase decodeRequestFlow(ByteBuf output) {
 112         final byte PADDING_IN_MULTIPART_REQUEST_FLOW_BODY_01 = 3;
 113         final byte PADDING_IN_MULTIPART_REQUEST_FLOW_BODY_02 = 4;
 114         MultipartRequestFlowCaseBuilder caseBuilder = new MultipartRequestFlowCaseBuilder();
 115         MultipartRequestFlowBuilder builder = new MultipartRequestFlowBuilder();
 116         builder.setTableId(output.readUnsignedByte());
 117         output.skipBytes(PADDING_IN_MULTIPART_REQUEST_FLOW_BODY_01);
 118         builder.setOutPort(output.readUnsignedInt());
 119         builder.setOutGroup(output.readUnsignedInt());
 120         output.skipBytes(PADDING_IN_MULTIPART_REQUEST_FLOW_BODY_02);
 121         byte[] cookie = new byte[EncodeConstants.SIZE_OF_LONG_IN_BYTES];
 122         output.readBytes(cookie);
 123         builder.setCookie(new BigInteger(1, cookie));
 124         byte[] cookieMask = new byte[EncodeConstants.SIZE_OF_LONG_IN_BYTES];
 125         output.readBytes(cookieMask);
 126         builder.setCookieMask(new BigInteger(1, cookieMask));
 127         caseBuilder.setMultipartRequestFlow(builder.build());
 128         return caseBuilder.build();
 129     }
 130
 131     /**
 132      * @throws Exception
 133      * Testing of {@link MultipartRequestInputFactory} for correct translation from POJO
 134      */
 135     @Test
 136     public void testMultipartRequestInputAggregateBodyFactory() throws Exception {
 137         MultipartRequestInputBuilder builder = new MultipartRequestInputBuilder();
 138         BufferHelper.setupHeader(builder, EncodeConstants.OF13_VERSION_ID);
 139         builder.setType(MultipartType.forValue(2));
 140         builder.setFlags(new MultipartRequestFlags(true));
 141         builder.setMultipartRequestBody(createRequestAggregate());
 142         MultipartRequestInput message = builder.build();
 143
 144         ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
 145         MultipartRequestInputFactory factory = MultipartRequestInputFactory.getInstance();
 146         factory.messageToBuffer(HelloMessageFactoryTest.VERSION_YET_SUPPORTED, out, message);
 147
 148         BufferHelper.checkHeaderV13(out, factory.getMessageType(), factory.computeLength(message));
 149         Assert.assertEquals("Wrong type", message.getType().getIntValue(), out.readShort());
 150         Assert.assertEquals("Wrong flags", message.getFlags(), decodeMultipartRequestFlags(out.readShort()));
 151         out.skipBytes(PADDING_IN_MULTIPART_REQUEST_MESSAGE);
 152         Assert.assertEquals("Wrong aggregate", message.getMultipartRequestBody(), decodeRequestAggregate(out));
 153     }
 154
 155     private static MultipartRequestFlags decodeMultipartRequestFlags(short input){
 156         final Boolean _oFPMPFREQMORE = (input & (1 << 0)) > 0;
 157         return new MultipartRequestFlags(_oFPMPFREQMORE);
 158     }
 159
 160
 161     private static MultipartRequestAggregateCase createRequestAggregate() {
 162         MultipartRequestAggregateCaseBuilder caseBuilder = new MultipartRequestAggregateCaseBuilder();
 163         MultipartRequestAggregateBuilder builder = new MultipartRequestAggregateBuilder();
 164         builder.setTableId((short) 8);
 165         builder.setOutPort(85L);
 166         builder.setOutGroup(95L);
 167         byte[] cookie = new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
 168         builder.setCookie(new BigInteger(1, cookie));
 169         byte[] cookieMask = new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
 170         builder.setCookieMask(new BigInteger(1, cookieMask));
 171         caseBuilder.setMultipartRequestAggregate(builder.build());
 172       //TODO match field
 173         return caseBuilder.build();
 174     }
 175
 176     private static MultipartRequestAggregateCase decodeRequestAggregate(ByteBuf output) {
 177         final byte PADDING_IN_MULTIPART_REQUEST_AGGREGATE_BODY_01 = 3;
 178         final byte PADDING_IN_MULTIPART_REQUEST_AGGREGATE_BODY_02 = 4;
 179         MultipartRequestAggregateCaseBuilder caseBuilder = new MultipartRequestAggregateCaseBuilder();
 180         MultipartRequestAggregateBuilder builder = new MultipartRequestAggregateBuilder();
 181         builder.setTableId(output.readUnsignedByte());
 182         output.skipBytes(PADDING_IN_MULTIPART_REQUEST_AGGREGATE_BODY_01);
 183         builder.setOutPort(output.readUnsignedInt());
 184         builder.setOutGroup(output.readUnsignedInt());
 185         output.skipBytes(PADDING_IN_MULTIPART_REQUEST_AGGREGATE_BODY_02);
 186         byte[] cookie = new byte[EncodeConstants.SIZE_OF_LONG_IN_BYTES];
 187         output.readBytes(cookie);
 188         builder.setCookie(new BigInteger(1, cookie));
 189         byte[] cookieMask = new byte[EncodeConstants.SIZE_OF_LONG_IN_BYTES];
 190         output.readBytes(cookieMask);
 191         builder.setCookieMask(new BigInteger(1, cookieMask));
 192         caseBuilder.setMultipartRequestAggregate(builder.build());
 193         return caseBuilder.build();
 194     }
 195
 196     /**
 197      * @throws Exception
 198      * Testing of {@link MultipartRequestInputFactory} for correct translation from POJO
 199      */
 200     @Test
 201     public void testMultipartRequestInputTableFactory() throws Exception {
 202         MultipartRequestInputBuilder builder = new MultipartRequestInputBuilder();
 203         BufferHelper.setupHeader(builder, EncodeConstants.OF13_VERSION_ID);
 204         builder.setType(MultipartType.forValue(3));
 205         builder.setFlags(new MultipartRequestFlags(true));
 206         //multipart request for table does not have body
 207         MultipartRequestInput message = builder.build();
 208
 209         ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
 210         MultipartRequestInputFactory factory = MultipartRequestInputFactory.getInstance();
 211         factory.messageToBuffer(HelloMessageFactoryTest.VERSION_YET_SUPPORTED, out, message);
 212
 213         BufferHelper.checkHeaderV13(out, factory.getMessageType(), factory.computeLength(message));
 214         Assert.assertEquals("Wrong type", message.getType().getIntValue(), out.readShort());
 215         Assert.assertEquals("Wrong flags", message.getFlags(), decodeMultipartRequestFlags(out.readShort()));
 216         out.skipBytes(PADDING_IN_MULTIPART_REQUEST_MESSAGE);
 217     }
 218
 219     /**
 220      * @throws Exception
 221      * Testing of {@link MultipartRequestInputFactory} for correct translation from POJO
 222      */
 223     @Test
 224     public void testMultipartRequestPortStatsMessageFactory() throws Exception {
 225         MultipartRequestInputBuilder builder = new MultipartRequestInputBuilder();
 226         BufferHelper.setupHeader(builder, EncodeConstants.OF13_VERSION_ID);
 227         builder.setType(MultipartType.forValue(4));
 228         builder.setFlags(new MultipartRequestFlags(true));
 229         builder.setMultipartRequestBody(createRequestPortStats());
 230         MultipartRequestInput message = builder.build();
 231
 232         ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
 233         MultipartRequestInputFactory factory = MultipartRequestInputFactory.getInstance();
 234         factory.messageToBuffer(HelloMessageFactoryTest.VERSION_YET_SUPPORTED, out, message);
 235
 236         BufferHelper.checkHeaderV13(out, factory.getMessageType(), factory.computeLength(message));
 237         Assert.assertEquals("Wrong type", message.getType().getIntValue(), out.readShort());
 238         Assert.assertEquals("Wrong flags", message.getFlags(), decodeMultipartRequestFlags(out.readShort()));
 239         out.skipBytes(PADDING_IN_MULTIPART_REQUEST_MESSAGE);
 240         Assert.assertEquals("Wrong portStatsBody", message.getMultipartRequestBody(), decodeRequestPortStats(out));
 241     }
 242
 243     private static MultipartRequestPortStatsCase createRequestPortStats() {
 244         MultipartRequestPortStatsCaseBuilder caseBuilder = new MultipartRequestPortStatsCaseBuilder();
 245         MultipartRequestPortStatsBuilder builder = new MultipartRequestPortStatsBuilder();
 246         builder.setPortNo(2251L);
 247         caseBuilder.setMultipartRequestPortStats(builder.build());
 248         return caseBuilder.build();
 249     }
 250
 251     private static MultipartRequestPortStatsCase decodeRequestPortStats(ByteBuf output) {
 252         final byte PADDING_IN_MULTIPART_REQUEST_PORTSTATS_BODY = 4;
 253         MultipartRequestPortStatsCaseBuilder caseBuilder = new MultipartRequestPortStatsCaseBuilder();
 254         MultipartRequestPortStatsBuilder builder = new MultipartRequestPortStatsBuilder();
 255         builder.setPortNo(output.readUnsignedInt());
 256         output.skipBytes(PADDING_IN_MULTIPART_REQUEST_PORTSTATS_BODY);
 257         caseBuilder.setMultipartRequestPortStats(builder.build());
 258         return caseBuilder.build();
 259     }
 260
 261     /**
 262      * @throws Exception
 263      * Testing of {@link MultipartRequestInputFactory} for correct translation from POJO
 264      */
 265     @Test
 266     public void testMultipartRequestQueueMessageFactory() throws Exception {
 267         MultipartRequestInputBuilder builder = new MultipartRequestInputBuilder();
 268         BufferHelper.setupHeader(builder, EncodeConstants.OF13_VERSION_ID);
 269         builder.setType(MultipartType.forValue(5));
 270         builder.setFlags(new MultipartRequestFlags(true));
 271         builder.setMultipartRequestBody(createRequestQueue());
 272         MultipartRequestInput message = builder.build();
 273
 274         ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
 275         MultipartRequestInputFactory factory = MultipartRequestInputFactory.getInstance();
 276         factory.messageToBuffer(HelloMessageFactoryTest.VERSION_YET_SUPPORTED, out, message);
 277
 278         BufferHelper.checkHeaderV13(out, factory.getMessageType(), factory.computeLength(message));
 279         Assert.assertEquals("Wrong type", message.getType().getIntValue(), out.readShort());
 280         Assert.assertEquals("Wrong flags", message.getFlags(), decodeMultipartRequestFlags(out.readShort()));
 281         out.skipBytes(PADDING_IN_MULTIPART_REQUEST_MESSAGE);
 282         Assert.assertEquals("Wrong queueBody", message.getMultipartRequestBody(), decodeRequestQueue(out));
 283     }
 284
 285     private static MultipartRequestQueueCase createRequestQueue() {
 286         MultipartRequestQueueCaseBuilder caseBuilder = new MultipartRequestQueueCaseBuilder();
 287         MultipartRequestQueueBuilder builder = new MultipartRequestQueueBuilder();
 288         builder.setPortNo(2256L);
 289         builder.setQueueId(2211L);
 290         caseBuilder.setMultipartRequestQueue(builder.build());
 291         return caseBuilder.build();
 292     }
 293
 294     private static MultipartRequestQueueCase decodeRequestQueue(ByteBuf output) {
 295         MultipartRequestQueueCaseBuilder caseBuilder = new MultipartRequestQueueCaseBuilder();
 296         MultipartRequestQueueBuilder builder = new MultipartRequestQueueBuilder();
 297         builder.setPortNo(output.readUnsignedInt());
 298         builder.setQueueId(output.readUnsignedInt());
 299         caseBuilder.setMultipartRequestQueue(builder.build());
 300         return caseBuilder.build();
 301     }
 302
 303     /**
 304      * @throws Exception
 305      * Testing of {@link MultipartRequestInputFactory} for correct translation from POJO
 306      */
 307     @Test
 308     public void testMultipartRequestGroupMessageFactory() throws Exception {
 309         MultipartRequestInputBuilder builder = new MultipartRequestInputBuilder();
 310         BufferHelper.setupHeader(builder, EncodeConstants.OF13_VERSION_ID);
 311         builder.setType(MultipartType.forValue(6));
 312         builder.setFlags(new MultipartRequestFlags(true));
 313         builder.setMultipartRequestBody(createRequestGroup());
 314         MultipartRequestInput message = builder.build();
 315
 316         ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
 317         MultipartRequestInputFactory factory = MultipartRequestInputFactory.getInstance();
 318         factory.messageToBuffer(HelloMessageFactoryTest.VERSION_YET_SUPPORTED, out, message);
 319
 320         BufferHelper.checkHeaderV13(out, factory.getMessageType(), factory.computeLength(message));
 321         Assert.assertEquals("Wrong type", message.getType().getIntValue(), out.readShort());
 322         Assert.assertEquals("Wrong flags", message.getFlags(), decodeMultipartRequestFlags(out.readShort()));
 323         out.skipBytes(PADDING_IN_MULTIPART_REQUEST_MESSAGE);
 324         Assert.assertEquals("Wrong groupBody", message.getMultipartRequestBody(), decodeRequestGroup(out));
 325     }
 326
 327     private static MultipartRequestGroupCase createRequestGroup() {
 328         MultipartRequestGroupCaseBuilder caseBuilder = new MultipartRequestGroupCaseBuilder();
 329         MultipartRequestGroupBuilder builder = new MultipartRequestGroupBuilder();
 330         builder.setGroupId(new GroupId(2258L));
 331         caseBuilder.setMultipartRequestGroup(builder.build());
 332         return caseBuilder.build();
 333     }
 334
 335     private static MultipartRequestGroupCase decodeRequestGroup(ByteBuf output) {
 336         final byte PADDING_IN_MULTIPART_REQUEST_GROUP_BODY = 4;
 337         MultipartRequestGroupCaseBuilder caseBuilder = new MultipartRequestGroupCaseBuilder();
 338         MultipartRequestGroupBuilder builder = new MultipartRequestGroupBuilder();
 339         builder.setGroupId(new GroupId(output.readUnsignedInt()));
 340         output.skipBytes(PADDING_IN_MULTIPART_REQUEST_GROUP_BODY);
 341         caseBuilder.setMultipartRequestGroup(builder.build());
 342         return caseBuilder.build();
 343     }
 344
 345     /**
 346      * @throws Exception
 347      * Testing of {@link MultipartRequestInputFactory} for correct translation from POJO
 348      */
 349     @Test
 350     public void testMultipartRequestMeterMessageFactory() throws Exception {
 351         MultipartRequestInputBuilder builder = new MultipartRequestInputBuilder();
 352         BufferHelper.setupHeader(builder, EncodeConstants.OF13_VERSION_ID);
 353         builder.setType(MultipartType.forValue(9));
 354         builder.setFlags(new MultipartRequestFlags(true));
 355         builder.setMultipartRequestBody(createRequestMeter());
 356         MultipartRequestInput message = builder.build();
 357
 358         ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
 359         MultipartRequestInputFactory factory = MultipartRequestInputFactory.getInstance();
 360         factory.messageToBuffer(HelloMessageFactoryTest.VERSION_YET_SUPPORTED, out, message);
 361
 362         BufferHelper.checkHeaderV13(out, factory.getMessageType(), factory.computeLength(message));
 363         Assert.assertEquals("Wrong type", message.getType().getIntValue(), out.readShort());
 364         Assert.assertEquals("Wrong flags", message.getFlags(), decodeMultipartRequestFlags(out.readShort()));
 365         out.skipBytes(PADDING_IN_MULTIPART_REQUEST_MESSAGE);
 366         Assert.assertEquals("Wrong meterBody", message.getMultipartRequestBody(), decodeRequestMeter(out));
 367     }
 368
 369     private static MultipartRequestMeterCase createRequestMeter() {
 370         MultipartRequestMeterCaseBuilder caseBuilder = new MultipartRequestMeterCaseBuilder();
 371         MultipartRequestMeterBuilder builder = new MultipartRequestMeterBuilder();
 372         builder.setMeterId(new MeterId(1121L));
 373         caseBuilder.setMultipartRequestMeter(builder.build());
 374         return caseBuilder.build();
 375     }
 376
 377     private static MultipartRequestMeterCase decodeRequestMeter(ByteBuf output) {
 378         final byte PADDING_IN_MULTIPART_REQUEST_METER_BODY = 4;
 379         MultipartRequestMeterCaseBuilder caseBuilder = new MultipartRequestMeterCaseBuilder();
 380         MultipartRequestMeterBuilder builder = new MultipartRequestMeterBuilder();
 381         builder.setMeterId(new MeterId(output.readUnsignedInt()));
 382         output.skipBytes(PADDING_IN_MULTIPART_REQUEST_METER_BODY);
 383         caseBuilder.setMultipartRequestMeter(builder.build());
 384         return caseBuilder.build();
 385     }
 386
 387     /**
 388      * @throws Exception
 389      * Testing of {@link MultipartRequestInputFactory} for correct translation from POJO
 390      */
 391     @Test
 392     public void testMultipartRequestMeterConfigMessageFactory() throws Exception {
 393         MultipartRequestInputBuilder builder = new MultipartRequestInputBuilder();
 394         BufferHelper.setupHeader(builder, EncodeConstants.OF13_VERSION_ID);
 395         builder.setType(MultipartType.forValue(10));
 396         builder.setFlags(new MultipartRequestFlags(true));
 397         builder.setMultipartRequestBody(createRequestMeterConfig());
 398         MultipartRequestInput message = builder.build();
 399
 400         ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
 401         MultipartRequestInputFactory factory = MultipartRequestInputFactory.getInstance();
 402         factory.messageToBuffer(HelloMessageFactoryTest.VERSION_YET_SUPPORTED, out, message);
 403
 404         BufferHelper.checkHeaderV13(out, factory.getMessageType(), factory.computeLength(message));
 405         Assert.assertEquals("Wrong type", message.getType().getIntValue(), out.readShort());
 406         Assert.assertEquals("Wrong flags", message.getFlags(), decodeMultipartRequestFlags(out.readShort()));
 407         out.skipBytes(PADDING_IN_MULTIPART_REQUEST_MESSAGE);
 408         Assert.assertEquals("Wrong meterConfigBody", message.getMultipartRequestBody(), decodeRequestMeterConfig(out));
 409     }
 410
 411     private static MultipartRequestMeterConfigCase createRequestMeterConfig() {
 412         MultipartRequestMeterConfigCaseBuilder caseBuilder = new MultipartRequestMeterConfigCaseBuilder();
 413         MultipartRequestMeterConfigBuilder builder = new MultipartRequestMeterConfigBuilder();
 414         builder.setMeterId(new MeterId(1133L));
 415         caseBuilder.setMultipartRequestMeterConfig(builder.build());
 416         return caseBuilder.build();
 417     }
 418
 419     private static MultipartRequestMeterConfigCase decodeRequestMeterConfig(ByteBuf output) {
 420         final byte PADDING_IN_MULTIPART_REQUEST_METER_CONFIG_BODY = 4;
 421         MultipartRequestMeterConfigCaseBuilder caseBuilder = new MultipartRequestMeterConfigCaseBuilder();
 422         MultipartRequestMeterConfigBuilder builder = new MultipartRequestMeterConfigBuilder();
 423         builder.setMeterId(new MeterId(output.readUnsignedInt()));
 424         output.skipBytes(PADDING_IN_MULTIPART_REQUEST_METER_CONFIG_BODY);
 425         caseBuilder.setMultipartRequestMeterConfig(builder.build());
 426         return caseBuilder.build();
 427     }
 428
 429     /**
 430      * @throws Exception
 431      * Testing of {@link MultipartRequestInputFactory} for correct translation from POJO
 432      */
 433     @Test
 434     public void testMultipartRequestExperimenterMessageFactory() throws Exception {
 435         MultipartRequestInputBuilder builder = new MultipartRequestInputBuilder();
 436         BufferHelper.setupHeader(builder, EncodeConstants.OF13_VERSION_ID);
 437         builder.setType(MultipartType.forValue(0xffff));
 438         builder.setFlags(new MultipartRequestFlags(true));
 439         builder.setMultipartRequestBody(createRequestExperimenter());
 440         MultipartRequestInput message = builder.build();
 441
 442         ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
 443         MultipartRequestInputFactory factory = MultipartRequestInputFactory.getInstance();
 444         factory.messageToBuffer(HelloMessageFactoryTest.VERSION_YET_SUPPORTED, out, message);
 445
 446         BufferHelper.checkHeaderV13(out, factory.getMessageType(), factory.computeLength(message));
 447         Assert.assertEquals("Wrong type", message.getType().getIntValue(), out.readUnsignedShort());
 448         Assert.assertEquals("Wrong flags", message.getFlags(), decodeMultipartRequestFlags(out.readShort()));
 449         out.skipBytes(PADDING_IN_MULTIPART_REQUEST_MESSAGE);
 450         Assert.assertEquals("Wrong experimenterBody", message.getMultipartRequestBody(), decodeRequestExperimenter(out));
 451     }
 452
 453     private static MultipartRequestExperimenterCase createRequestExperimenter() {
 454         MultipartRequestExperimenterCaseBuilder caseBuilder = new MultipartRequestExperimenterCaseBuilder();
 455         MultipartRequestExperimenterBuilder builder = new MultipartRequestExperimenterBuilder();
 456         builder.setExperimenter(1133L);
 457         builder.setExpType(1135L);
 458         caseBuilder.setMultipartRequestExperimenter(builder.build());
 459         return caseBuilder.build();
 460     }
 461
 462     private static MultipartRequestExperimenterCase decodeRequestExperimenter(ByteBuf output) {
 463         MultipartRequestExperimenterCaseBuilder caseBuilder = new MultipartRequestExperimenterCaseBuilder();
 464         MultipartRequestExperimenterBuilder builder = new MultipartRequestExperimenterBuilder();
 465         builder.setExperimenter(output.readUnsignedInt());
 466         builder.setExpType(output.readUnsignedInt());
 467         caseBuilder.setMultipartRequestExperimenter(builder.build());
 468         return caseBuilder.build();
 469     }
 470
 471     /**
 472      * @throws Exception
 473      * Testing of {@link MultipartRequestInputFactory} for correct translation from POJO
 474      */
 475     @Test
 476     public void testMultipartRequestDescMessageFactory() throws Exception {
 477         MultipartRequestInputBuilder builder = new MultipartRequestInputBuilder();
 478         BufferHelper.setupHeader(builder, EncodeConstants.OF13_VERSION_ID);
 479         builder.setType(MultipartType.forValue(0));
 480         builder.setFlags(new MultipartRequestFlags(true));
 481         builder.setMultipartRequestBody(createRequestDesc());
 482         MultipartRequestInput message = builder.build();
 483
 484         ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
 485         MultipartRequestInputFactory factory = MultipartRequestInputFactory.getInstance();
 486         factory.messageToBuffer(HelloMessageFactoryTest.VERSION_YET_SUPPORTED, out, message);
 487
 488         BufferHelper.checkHeaderV13(out, factory.getMessageType(), factory.computeLength(message));
 489         Assert.assertEquals("Wrong type", message.getType().getIntValue(), out.readUnsignedShort());
 490         Assert.assertEquals("Wrong flags", message.getFlags(), decodeMultipartRequestFlags(out.readShort()));
 491     }
 492
 493     private static MultipartRequestBody createRequestDesc() {
 494         MultipartRequestDescCaseBuilder caseBuilder = new MultipartRequestDescCaseBuilder();
 495         MultipartRequestDescBuilder builder = new MultipartRequestDescBuilder();
 496         caseBuilder.setMultipartRequestDesc(builder.build());
 497         return caseBuilder.build();
 498     }
 499
 500     /**
 501      * @throws Exception
 502      * Testing of {@link MultipartRequestInputFactory} for correct translation from POJO
 503      */
 504     @Test
 505     public void testMultipartRequestTableFeaturesMessageFactory() throws Exception {
 506         MultipartRequestInputBuilder builder = new MultipartRequestInputBuilder();
 507         BufferHelper.setupHeader(builder, EncodeConstants.OF13_VERSION_ID);
 508         builder.setType(MultipartType.forValue(12));
 509         builder.setFlags(new MultipartRequestFlags(true));
 510         builder.setMultipartRequestBody(createRequestTableFeatures());
 511         MultipartRequestInput message = builder.build();
 512
 513         ByteBuf out = UnpooledByteBufAllocator.DEFAULT.buffer();
 514         MultipartRequestInputFactory factory = MultipartRequestInputFactory.getInstance();
 515         factory.messageToBuffer(HelloMessageFactoryTest.VERSION_YET_SUPPORTED, out, message);
 516
 517         BufferHelper.checkHeaderV13(out, factory.getMessageType(), factory.computeLength(message));
 518         Assert.assertEquals("Wrong type", message.getType().getIntValue(), out.readUnsignedShort());
 519         Assert.assertEquals("Wrong flags", message.getFlags(), decodeMultipartRequestFlags(out.readShort()));
 520         out.skipBytes(PADDING_IN_MULTIPART_REQUEST_MESSAGE);
 521         MultipartRequestTableFeaturesCase messageTableFeaturesCase = (MultipartRequestTableFeaturesCase) message.getMultipartRequestBody();
 522         MultipartRequestTableFeatures messageTableFeatures = messageTableFeaturesCase.getMultipartRequestTableFeatures();
 523         Assert.assertEquals("Wrong tableFeaturesBody", messageTableFeatures.getTableFeatures(), decodeRequestTableFeatures(out).
 524                 getMultipartRequestTableFeatures().getTableFeatures());
 525     }
 526
 527     private static MultipartRequestTableFeaturesCase createRequestTableFeatures() {
 528         MultipartRequestTableFeaturesCaseBuilder caseBuilder = new MultipartRequestTableFeaturesCaseBuilder();
 529         MultipartRequestTableFeaturesBuilder builder = new MultipartRequestTableFeaturesBuilder();
 530         List<TableFeatures> tableFeaturesList = new ArrayList<>();
 531         TableFeaturesBuilder tableFeaturesBuilder = new TableFeaturesBuilder();
 532         tableFeaturesBuilder.setTableId((short) 8);
 533         tableFeaturesBuilder.setName("AAAABBBBCCCCDDDDEEEEFFFFGGGG");
 534         tableFeaturesBuilder.setMetadataMatch(new BigInteger(1, new byte[] {0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}));
 535         tableFeaturesBuilder.setMetadataWrite(new BigInteger(1, new byte[] {0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}));
 536         tableFeaturesBuilder.setConfig(new TableConfig(true));
 537         tableFeaturesBuilder.setMaxEntries(65L);
 538         TableFeatures tableFeature = tableFeaturesBuilder.build();
 539         tableFeaturesList.add(tableFeature);
 540         builder.setTableFeatures(tableFeaturesList);
 541         caseBuilder.setMultipartRequestTableFeatures(builder.build());
 542         return caseBuilder.build();
 543     }
 544
 545     private static MultipartRequestTableFeaturesCase decodeRequestTableFeatures(ByteBuf output) {
 546         final byte PADDING_IN_MULTIPART_REQUEST_TABLE_FEATURES_BODY = 5;
 547         final byte OFP_MAX_TABLE_NAME_LEN = 32;
 548         MultipartRequestTableFeaturesCaseBuilder caseBuilder = new MultipartRequestTableFeaturesCaseBuilder();
 549         MultipartRequestTableFeaturesBuilder builder = new MultipartRequestTableFeaturesBuilder();
 550         List<TableFeatures> tableFeaturesList = new ArrayList<>();
 551         TableFeaturesBuilder tableFeaturesBuilder = new TableFeaturesBuilder();
 552         output.skipBytes(2);
 553         tableFeaturesBuilder.setTableId(output.readUnsignedByte());
 554         output.skipBytes(PADDING_IN_MULTIPART_REQUEST_TABLE_FEATURES_BODY);
 555         byte[] tableNameBytes = new byte[OFP_MAX_TABLE_NAME_LEN];
 556         output.readBytes(tableNameBytes);
 557         String tableName = new String(tableNameBytes);
 558         tableFeaturesBuilder.setName(tableName.trim());
 559         byte[] metadataMatch = new byte[EncodeConstants.SIZE_OF_LONG_IN_BYTES];
 560         output.readBytes(metadataMatch);
 561         tableFeaturesBuilder.setMetadataMatch(new BigInteger(1, metadataMatch));
 562         byte[] metadataWrite = new byte[EncodeConstants.SIZE_OF_LONG_IN_BYTES];
 563         output.readBytes(metadataWrite);
 564         tableFeaturesBuilder.setMetadataWrite(new BigInteger(1, metadataWrite));
 565         tableFeaturesBuilder.setConfig(decodeTableConfig(output.readInt()));
 566         tableFeaturesBuilder.setMaxEntries(output.readUnsignedInt());
 567         TableFeatures tableFeature = tableFeaturesBuilder.build();
 568         tableFeaturesList.add(tableFeature);
 569         builder.setTableFeatures(tableFeaturesList);
 570         caseBuilder.setMultipartRequestTableFeatures(builder.build());
 571         return caseBuilder.build();
 572     }
 573
 574     private static TableConfig decodeTableConfig(int input) {
 575         final Boolean _oFPTCDEPRECATEDMASK = (input & (1 << 3)) > 0;
 576         return new TableConfig(_oFPTCDEPRECATEDMASK);
 577     }
 578
 579 }