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