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