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