openflow-protocol-impl/src/test/java/org/opendaylight/openflowjava/protocol/impl/deserialization/factories/MultipartReplyMessageFactoryTest.java

   1 /* Copyright (C)2013 Pantheon Technologies, s.r.o. All rights reserved. */\r
   2 package org.opendaylight.openflowjava.protocol.impl.deserialization.factories;\r
   3 \r
   4 import io.netty.buffer.ByteBuf;\r
   5 \r
   6 import java.math.BigInteger;\r
   7 \r
   8 import org.junit.Assert;\r
   9 import org.junit.Test;\r
  10 import org.opendaylight.openflowjava.protocol.impl.util.BufferHelper;\r
  11 import org.opendaylight.openflowjava.protocol.impl.util.ByteBufUtils;\r
  12 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;\r
  13 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.EthertypeAction;\r
  14 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.ExperimenterAction;\r
  15 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.GroupIdAction;\r
  16 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.MaxLengthAction;\r
  17 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.MplsTtlAction;\r
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.NwTtlAction;\r
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.OxmFieldsAction;\r
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.PortAction;\r
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.PortNumberMatchEntry;\r
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.QueueIdAction;\r
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.CopyTtlIn;\r
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.CopyTtlOut;\r
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.DecMplsTtl;\r
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.DecNwTtl;\r
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.Experimenter;\r
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.Group;\r
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.Output;\r
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.PopMpls;\r
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.PopPbb;\r
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.PopVlan;\r
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.PushMpls;\r
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.PushPbb;\r
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.PushVlan;\r
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.SetField;\r
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.SetMplsTtl;\r
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.SetNwTtl;\r
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.SetQueue;\r
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.FlowModFlags;\r
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MeterFlags;\r
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.PortConfig;\r
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.PortFeatures;\r
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.PortState;\r
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.InPhyPort;\r
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.InPort;\r
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.oxm.rev130731.OpenflowBasicClass;\r
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartReplyMessage;\r
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.meter.band.header.meter.band.MeterBandDrop;\r
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.meter.band.header.meter.band.MeterBandDscpRemark;\r
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.meter.band.header.meter.band.MeterBandExperimenter;\r
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyAggregate;\r
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyDesc;\r
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyExperimenter;\r
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyFlow;\r
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyGroup;\r
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyGroupDesc;\r
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyMeter;\r
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyMeterConfig;\r
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyMeterFeatures;\r
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyPortDesc;\r
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyPortStats;\r
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyQueue;\r
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyTable;\r
  65 \r
  66 /**\r
  67  * @author timotej.kubas\r
  68  * @author michal.polkorab\r
  69  */\r
  70 public class MultipartReplyMessageFactoryTest {\r
  71 \r
  72     /**\r
  73      * Testing {@link MultipartReplyMessageFactory} for correct translation into POJO\r
  74      *//*\r
  75     @Test\r
  76     public void test(){\r
  77         ByteBuf bb = BufferHelper.buildBuffer("00 07 00 01 00 00 00 00 01 02 03 04");\r
  78         MultipartReplyMessage builtByFactory = BufferHelper.decodeV13(MultipartReplyMessageFactory.getInstance(), bb);\r
  79         \r
  80         BufferHelper.checkHeaderV13(builtByFactory);\r
  81         \r
  82         Assert.assertEquals("Wrong type", 0x07, builtByFactory.getType().getIntValue());\r
  83         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE());\r
  84         //Assert.assertArrayEquals("Wrong body", new byte[]{0x01, 0x02, 0x03, 0x04}, builtByFactory.getBody());\r
  85     }*/\r
  86     \r
  87     /**\r
  88      * Testing {@link MultipartReplyMessageFactory} for correct translation into POJO\r
  89      */\r
  90     @Test\r
  91     public void testMultipartReplyDescBody(){\r
  92         final int DESC_STR_LEN = 256;\r
  93         final int SERIAL_NUM_LEN = 32;\r
  94         ByteBuf bb = BufferHelper.buildBuffer("00 00 00 01 00 00 00 00");\r
  95         \r
  96         String mfrDesc = "Manufacturer description";\r
  97         byte[] mfrDescBytes = new byte[256];\r
  98         mfrDescBytes = mfrDesc.getBytes();\r
  99         bb.writeBytes(mfrDescBytes);\r
 100         ByteBufUtils.padBuffer((DESC_STR_LEN - mfrDescBytes.length), bb);\r
 101         \r
 102         String hwDesc = "Hardware description";\r
 103         byte[] hwDescBytes = new byte[256];\r
 104         hwDescBytes = hwDesc.getBytes();\r
 105         bb.writeBytes(hwDescBytes);\r
 106         ByteBufUtils.padBuffer((DESC_STR_LEN - hwDescBytes.length), bb);\r
 107         \r
 108         String swDesc = "Software description";\r
 109         byte[] swDescBytes = new byte[256];\r
 110         swDescBytes = swDesc.getBytes();\r
 111         bb.writeBytes(swDescBytes);\r
 112         ByteBufUtils.padBuffer((DESC_STR_LEN - swDescBytes.length), bb);\r
 113         \r
 114         String serialNum = "SN0123456789";\r
 115         byte[] serialNumBytes = new byte[32];\r
 116         serialNumBytes = serialNum.getBytes();\r
 117         bb.writeBytes(serialNumBytes);\r
 118         ByteBufUtils.padBuffer((SERIAL_NUM_LEN - serialNumBytes.length), bb);\r
 119         \r
 120         String dpDesc = "switch3 in room 3120";\r
 121         byte[] dpDescBytes = new byte[256];\r
 122         dpDescBytes = dpDesc.getBytes();\r
 123         bb.writeBytes(dpDescBytes);\r
 124         ByteBufUtils.padBuffer((DESC_STR_LEN - dpDescBytes.length), bb);\r
 125         \r
 126         MultipartReplyMessage builtByFactory = BufferHelper.decodeV13(MultipartReplyMessageFactory.getInstance(), bb);\r
 127         \r
 128         BufferHelper.checkHeaderV13(builtByFactory);\r
 129         Assert.assertEquals("Wrong type", 0x00, builtByFactory.getType().getIntValue());\r
 130         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE());\r
 131         MultipartReplyDesc message = (MultipartReplyDesc) builtByFactory.getMultipartReplyBody();\r
 132         Assert.assertEquals("Wrong mfrDesc", "Manufacturer description", message.getMfrDesc());\r
 133         Assert.assertEquals("Wrong hwDesc", "Hardware description", message.getHwDesc());\r
 134         Assert.assertEquals("Wrong swDesc", "Software description", message.getSwDesc());\r
 135         Assert.assertEquals("Wrong serialNum", "SN0123456789", message.getSerialNum());\r
 136         Assert.assertEquals("Wrong dpDesc", "switch3 in room 3120", message.getDpDesc());\r
 137     }\r
 138     \r
 139     /**\r
 140      * Testing {@link MultipartReplyMessageFactory} for correct translation into POJO\r
 141      */\r
 142     @Test\r
 143     public void testMultipartReplyFlowBody(){\r
 144         ByteBuf bb = BufferHelper.buildBuffer("00 01 00 01 00 00 00 00 "+\r
 145                                               "00 0C "+//length\r
 146                                               "08 "+//tableId\r
 147                                               "00 "+//pad_01\r
 148                                               "00 00 00 09 "+//durationSec\r
 149                                               "00 00 00 07 "+//durationNsec\r
 150                                               "00 0C "+//priority\r
 151                                               "00 0E "+//idleTimeout\r
 152                                               "00 0F "+//hardTimeout\r
 153                                               "00 0B "+//flags\r
 154                                               "00 00 00 00 "+//pad_02\r
 155                                               "00 01 01 01 01 01 01 01 "+//cookie\r
 156                                               "00 01 01 01 01 01 01 01 "+//packetCount\r
 157                                               "00 01 01 01 01 01 01 01"//byteCount\r
 158                                               );\r
 159         \r
 160         MultipartReplyMessage builtByFactory = BufferHelper.decodeV13(MultipartReplyMessageFactory.getInstance(), bb);\r
 161         \r
 162         BufferHelper.checkHeaderV13(builtByFactory);\r
 163         Assert.assertEquals("Wrong type", 0x01, builtByFactory.getType().getIntValue());\r
 164         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE());\r
 165         MultipartReplyFlow message = (MultipartReplyFlow) builtByFactory.getMultipartReplyBody();\r
 166         Assert.assertEquals("Wrong tableId", 8, message.getFlowStats().get(0).getTableId().intValue());\r
 167         Assert.assertEquals("Wrong durationSec", 9, message.getFlowStats().get(0).getDurationSec().intValue());\r
 168         Assert.assertEquals("Wrong durationNsec", 7, message.getFlowStats().get(0).getDurationNsec().intValue());\r
 169         Assert.assertEquals("Wrong priority", 12, message.getFlowStats().get(0).getPriority().intValue());\r
 170         Assert.assertEquals("Wrong idleTimeOut", 14, message.getFlowStats().get(0).getIdleTimeout().intValue());\r
 171         Assert.assertEquals("Wrong hardTimeOut", 15, message.getFlowStats().get(0).getHardTimeout().intValue());\r
 172         Assert.assertEquals("Wrong flags", new FlowModFlags(true, false, true, false, true), \r
 173                                            message.getFlowStats().get(0).getFlags());\r
 174         Assert.assertEquals("Wrong cookie", \r
 175                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 176                 message.getFlowStats().get(0).getCookie());\r
 177         Assert.assertEquals("Wrong packetCount", \r
 178                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 179                 message.getFlowStats().get(0).getPacketCount());\r
 180         Assert.assertEquals("Wrong byteCount", \r
 181                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 182                 message.getFlowStats().get(0).getByteCount());\r
 183     }\r
 184     \r
 185     /**\r
 186      * Testing {@link MultipartReplyMessageFactory} for correct translation into POJO\r
 187      */\r
 188     @Test\r
 189     public void testMultipartReplyAggregateBody(){\r
 190         ByteBuf bb = BufferHelper.buildBuffer("00 02 00 01 00 00 00 00 "+\r
 191                                               "00 01 01 01 01 01 01 01 "+//packetCount\r
 192                                               "00 01 01 01 01 01 01 01 "+//byteCount\r
 193                                               "00 00 00 08 "+//flowCount\r
 194                                               "00 00 00 00"//pad\r
 195                                               );\r
 196         \r
 197         MultipartReplyMessage builtByFactory = BufferHelper.decodeV13(MultipartReplyMessageFactory.getInstance(), bb);\r
 198         \r
 199         BufferHelper.checkHeaderV13(builtByFactory);\r
 200         Assert.assertEquals("Wrong type", 0x02, builtByFactory.getType().getIntValue());\r
 201         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE());\r
 202         MultipartReplyAggregate message = (MultipartReplyAggregate) builtByFactory.getMultipartReplyBody();\r
 203         Assert.assertEquals("Wrong packetCount", \r
 204                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 205                 message.getPacketCount());\r
 206         Assert.assertEquals("Wrong byteCount", \r
 207                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 208                 message.getByteCount());\r
 209         Assert.assertEquals("Wrong flowCount", \r
 210                 8, \r
 211                 message.getFlowCount().intValue());\r
 212     }\r
 213     \r
 214     /**\r
 215      * Testing {@link MultipartReplyMessageFactory} for correct translation into POJO\r
 216      */\r
 217     @Test\r
 218     public void testMultipartReplyTableBody(){\r
 219         ByteBuf bb = BufferHelper.buildBuffer("00 03 00 01 00 00 00 00 "+\r
 220                                               "08 "+//tableId\r
 221                                               "00 00 00 "+//pad\r
 222                                               "00 00 00 10 "+//activeCount\r
 223                                               "00 01 01 01 01 01 01 01 "+//lookupCount\r
 224                                               "00 01 01 01 01 01 01 01"//matchedCount\r
 225                                               );\r
 226         \r
 227         MultipartReplyMessage builtByFactory = BufferHelper.decodeV13(MultipartReplyMessageFactory.getInstance(), bb);\r
 228         \r
 229         BufferHelper.checkHeaderV13(builtByFactory);\r
 230         Assert.assertEquals("Wrong type", 0x03, builtByFactory.getType().getIntValue());\r
 231         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE());\r
 232         \r
 233         MultipartReplyTable message = (MultipartReplyTable) builtByFactory.getMultipartReplyBody();\r
 234         Assert.assertEquals("Wrong tableId", 8, message.getTableStats().get(0).getTableId().intValue());\r
 235         Assert.assertEquals("Wrong activeCount", 16, message.getTableStats().get(0).getActiveCount().longValue());\r
 236         Assert.assertEquals("Wrong lookupCount", \r
 237                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 238                 message.getTableStats().get(0).getLookupCount());\r
 239         Assert.assertEquals("Wrong matchedCount", \r
 240                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 241                 message.getTableStats().get(0).getMatchedCount());\r
 242     }\r
 243     \r
 244     /**\r
 245      * Testing {@link MultipartReplyMessageFactory} for correct translation into POJO\r
 246      */\r
 247     @Test\r
 248     public void testMultipartReplyPortStatsBody(){\r
 249         ByteBuf bb = BufferHelper.buildBuffer("00 04 00 01 00 00 00 00 "+\r
 250                                               "00 00 00 FF "+//portNo\r
 251                                               "00 00 00 00 "+//pad\r
 252                                               "00 01 01 01 01 01 01 01 "+//rxPackets\r
 253                                               "00 02 02 02 02 02 02 02 "+//txPackets\r
 254                                               "00 02 03 02 03 02 03 02 "+//rxBytes\r
 255                                               "00 02 03 02 03 02 03 02 "+//txBytes\r
 256                                               "00 02 03 02 03 02 03 02 "+//rxDropped\r
 257                                               "00 02 03 02 03 02 03 02 "+//txDropped\r
 258                                               "00 02 03 02 03 02 03 02 "+//rxErrors\r
 259                                               "00 02 03 02 03 02 03 02 "+//txErrors\r
 260                                               "00 02 03 02 03 02 03 02 "+//rxFrameErr\r
 261                                               "00 02 03 02 03 02 03 02 "+//rxOverErr\r
 262                                               "00 02 03 02 03 02 03 02 "+//rxCrcErr\r
 263                                               "00 02 03 02 03 02 03 02 "+//collisions\r
 264                                               "00 00 00 02 "+//durationSec\r
 265                                               "00 00 00 04"//durationNsec\r
 266                                               );\r
 267         \r
 268         MultipartReplyMessage builtByFactory = BufferHelper.decodeV13(MultipartReplyMessageFactory.getInstance(), bb);\r
 269         \r
 270         BufferHelper.checkHeaderV13(builtByFactory);\r
 271         Assert.assertEquals("Wrong type", 0x04, builtByFactory.getType().getIntValue());\r
 272         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE());\r
 273         \r
 274         MultipartReplyPortStats message = (MultipartReplyPortStats) builtByFactory.getMultipartReplyBody();\r
 275         \r
 276         Assert.assertEquals("Wrong portNo", 255, message.getPortStats().get(0).getPortNo().intValue());\r
 277         Assert.assertEquals("Wrong rxPackets", \r
 278                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 279                 message.getPortStats().get(0).getRxPackets());\r
 280         Assert.assertEquals("Wrong txPackets", \r
 281                 new BigInteger(new byte[]{0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02}), \r
 282                 message.getPortStats().get(0).getTxPackets());\r
 283         Assert.assertEquals("Wrong rxBytes", \r
 284                 new BigInteger(new byte[]{0x00, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 285                 message.getPortStats().get(0).getRxBytes());\r
 286         Assert.assertEquals("Wrong txBytes", \r
 287                 new BigInteger(new byte[]{0x00, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 288                 message.getPortStats().get(0).getTxBytes());\r
 289         Assert.assertEquals("Wrong rxDropped", \r
 290                 new BigInteger(new byte[]{0x00, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 291                 message.getPortStats().get(0).getRxDropped());\r
 292         Assert.assertEquals("Wrong txDropped", \r
 293                 new BigInteger(new byte[]{0x00, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 294                 message.getPortStats().get(0).getTxDropped());\r
 295         Assert.assertEquals("Wrong rxErrors", \r
 296                 new BigInteger(new byte[]{0x00, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 297                 message.getPortStats().get(0).getRxErrors());\r
 298         Assert.assertEquals("Wrong txErrors", \r
 299                 new BigInteger(new byte[]{0x00, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 300                 message.getPortStats().get(0).getTxErrors());\r
 301         Assert.assertEquals("Wrong rxFrameErr", \r
 302                 new BigInteger(new byte[]{0x00, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 303                 message.getPortStats().get(0).getRxFrameErr());\r
 304         Assert.assertEquals("Wrong rxOverErr", \r
 305                 new BigInteger(new byte[]{0x00, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 306                 message.getPortStats().get(0).getRxOverErr());\r
 307         Assert.assertEquals("Wrong rxCrcErr", \r
 308                 new BigInteger(new byte[]{0x00, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 309                 message.getPortStats().get(0).getRxCrcErr());\r
 310         Assert.assertEquals("Wrong collisions", \r
 311                 new BigInteger(new byte[]{0x00, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 312                 message.getPortStats().get(0).getCollisions());\r
 313         Assert.assertEquals("Wrong durationSec", 2, message.getPortStats().get(0).getDurationSec().intValue());\r
 314         Assert.assertEquals("Wrong durationNsec", 4, message.getPortStats().get(0).getDurationNsec().intValue());\r
 315     }\r
 316     \r
 317     /**\r
 318      * Testing {@link MultipartReplyMessageFactory} for correct translation into POJO\r
 319      */\r
 320     @Test\r
 321     public void testMultipartReplyQueueBody(){\r
 322         ByteBuf bb = BufferHelper.buildBuffer("00 05 00 01 00 00 00 00 "+\r
 323                                               "00 00 00 FF "+//portNo\r
 324                                               "00 00 00 10 "+//queueId\r
 325                                               "00 02 03 02 03 02 03 02 "+//txBytes\r
 326                                               "00 02 02 02 02 02 02 02 "+//txPackets\r
 327                                               "00 02 03 02 03 02 03 02 "+//txErrors\r
 328                                               "00 00 00 02 "+//durationSec\r
 329                                               "00 00 00 04"//durationNsec\r
 330                                               );\r
 331         \r
 332         MultipartReplyMessage builtByFactory = BufferHelper.decodeV13(MultipartReplyMessageFactory.getInstance(), bb);\r
 333         \r
 334         BufferHelper.checkHeaderV13(builtByFactory);\r
 335         Assert.assertEquals("Wrong type", 0x05, builtByFactory.getType().getIntValue());\r
 336         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE());\r
 337         \r
 338         MultipartReplyQueue message = (MultipartReplyQueue) builtByFactory.getMultipartReplyBody();\r
 339         \r
 340         Assert.assertEquals("Wrong portNo", 255, message.getQueueStats().get(0).getPortNo().intValue());\r
 341         Assert.assertEquals("Wrong queueId", 16, message.getQueueStats().get(0).getQueueId().intValue());\r
 342         Assert.assertEquals("Wrong txBytes", \r
 343                 new BigInteger(new byte[]{0x00, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 344                 message.getQueueStats().get(0).getTxBytes());\r
 345         Assert.assertEquals("Wrong txPackets", \r
 346                 new BigInteger(new byte[]{0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02}), \r
 347                 message.getQueueStats().get(0).getTxPackets());\r
 348         Assert.assertEquals("Wrong txErrors", \r
 349                 new BigInteger(new byte[]{0x00, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 350                 message.getQueueStats().get(0).getTxErrors());\r
 351         Assert.assertEquals("Wrong durationSec", 2, message.getQueueStats().get(0).getDurationSec().intValue());\r
 352         Assert.assertEquals("Wrong durationNsec", 4, message.getQueueStats().get(0).getDurationNsec().intValue());\r
 353     }\r
 354     \r
 355     /**\r
 356      * Testing {@link MultipartReplyMessageFactory} for correct translation into POJO\r
 357      */\r
 358     @Test\r
 359     public void testMultipartReplyGroupBody(){\r
 360         ByteBuf bb = BufferHelper.buildBuffer("00 06 00 01 00 00 00 00 "+\r
 361                                               "00 48 "+//length\r
 362                                               "00 00 "+//pad1\r
 363                                               "00 00 00 10 "+//groupId\r
 364                                               "00 00 00 12 "+//refCount\r
 365                                               "00 00 00 00 "+//pad2\r
 366                                               "00 01 01 01 01 01 01 01 "+//packetCount\r
 367                                               "00 01 01 01 01 01 01 01 "+//byteCount\r
 368                                               "00 00 00 08 "+//durationSec\r
 369                                               "00 00 00 09 "+//durationNsec\r
 370                                               "00 01 01 01 01 01 01 01 "+//packetCountBucket\r
 371                                               "00 01 01 01 01 01 01 01 "+//byteCountBucket\r
 372                                               "00 02 02 02 02 02 02 02 "+//packetCountBucket_2\r
 373                                               "00 02 02 02 02 02 02 02 "+//byteCountBucket_2\r
 374                                               "00 48 "+//length_2\r
 375                                               "00 00 "+//pad1.2\r
 376                                               "00 00 00 10 "+//groupId_2\r
 377                                               "00 00 00 12 "+//refCount_2\r
 378                                               "00 00 00 00 "+//pad2.2\r
 379                                               "00 01 01 01 01 01 01 01 "+//packetCount_2\r
 380                                               "00 01 01 01 01 01 01 01 "+//byteCount_2\r
 381                                               "00 00 00 08 "+//durationSec_2\r
 382                                               "00 00 00 09 "+//durationNsec_2\r
 383                                               "00 01 01 01 01 01 01 01 "+//packetCountBucket_1.2\r
 384                                               "00 01 01 01 01 01 01 01 "+//byteCountBucket_1.2\r
 385                                               "00 02 02 02 02 02 02 02 "+//packetCountBucket_2.2\r
 386                                               "00 02 02 02 02 02 02 02"//byteCountBucket_2.2\r
 387                                               );\r
 388         \r
 389         MultipartReplyMessage builtByFactory = BufferHelper.decodeV13(MultipartReplyMessageFactory.getInstance(), bb);\r
 390         \r
 391         BufferHelper.checkHeaderV13(builtByFactory);\r
 392         Assert.assertEquals("Wrong type", 0x06, builtByFactory.getType().getIntValue());\r
 393         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE());\r
 394         \r
 395         MultipartReplyGroup message = (MultipartReplyGroup) builtByFactory.getMultipartReplyBody();\r
 396         \r
 397         Assert.assertEquals("Wrong groupId", 16, message.getGroupStats().get(0).getGroupId().intValue());\r
 398         Assert.assertEquals("Wrong refCount", 18, message.getGroupStats().get(0).getRefCount().intValue());\r
 399         Assert.assertEquals("Wrong packetCount", \r
 400                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 401                 message.getGroupStats().get(0).getPacketCount());\r
 402         Assert.assertEquals("Wrong byteCount", \r
 403                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 404                 message.getGroupStats().get(0).getByteCount());\r
 405         Assert.assertEquals("Wrong durationSec", 8, message.getGroupStats().get(0).getDurationSec().intValue());\r
 406         Assert.assertEquals("Wrong durationNsec", 9, message.getGroupStats().get(0).getDurationNsec().intValue());\r
 407         Assert.assertEquals("Wrong packetCountBucket", \r
 408                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 409                 message.getGroupStats().get(0).getBucketStats().get(0).getPacketCount());\r
 410         Assert.assertEquals("Wrong byteCountBucket", \r
 411                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 412                 message.getGroupStats().get(0).getBucketStats().get(0).getByteCount());\r
 413         Assert.assertEquals("Wrong packetCountBucket_2", \r
 414                 new BigInteger(new byte[]{0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02}), \r
 415                 message.getGroupStats().get(0).getBucketStats().get(1).getPacketCount());\r
 416         Assert.assertEquals("Wrong byteCountBucket_2", \r
 417                 new BigInteger(new byte[]{0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02}), \r
 418                 message.getGroupStats().get(0).getBucketStats().get(1).getByteCount());\r
 419         \r
 420         Assert.assertEquals("Wrong groupId_2", 16, message.getGroupStats().get(1).getGroupId().intValue());\r
 421         Assert.assertEquals("Wrong refCount_2", 18, message.getGroupStats().get(1).getRefCount().intValue());\r
 422         Assert.assertEquals("Wrong packetCount_2", \r
 423                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 424                 message.getGroupStats().get(1).getPacketCount());\r
 425         Assert.assertEquals("Wrong byteCount_2", \r
 426                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 427                 message.getGroupStats().get(1).getByteCount());\r
 428         Assert.assertEquals("Wrong durationSec_2", 8, message.getGroupStats().get(1).getDurationSec().intValue());\r
 429         Assert.assertEquals("Wrong durationNsec_2", 9, message.getGroupStats().get(1).getDurationNsec().intValue());\r
 430         Assert.assertEquals("Wrong packetCountBucket_1.2", \r
 431                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 432                 message.getGroupStats().get(1).getBucketStats().get(0).getPacketCount());\r
 433         Assert.assertEquals("Wrong byteCountBucket_1.2", \r
 434                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 435                 message.getGroupStats().get(1).getBucketStats().get(0).getByteCount());\r
 436         Assert.assertEquals("Wrong packetCountBucket_2.2", \r
 437                 new BigInteger(new byte[]{0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02}), \r
 438                 message.getGroupStats().get(1).getBucketStats().get(1).getPacketCount());\r
 439         Assert.assertEquals("Wrong byteCountBucket_2.2", \r
 440                 new BigInteger(new byte[]{0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02}), \r
 441                 message.getGroupStats().get(1).getBucketStats().get(1).getByteCount());\r
 442     }\r
 443     \r
 444     /**\r
 445      * Testing {@link MultipartReplyMessageFactory} for correct translation into POJO\r
 446      */\r
 447     @Test\r
 448     public void testMultipartReplyMeterFeaturesBody(){\r
 449         ByteBuf bb = BufferHelper.buildBuffer("00 0B 00 01 00 00 00 00 "+\r
 450                                               "00 00 00 09 "+//maxMeter\r
 451                                               "00 00 00 01 "+//bandTypes\r
 452                                               "00 00 00 03 "+//capabilities\r
 453                                               "03 "+//maxBands\r
 454                                               "04 "+//maxColor\r
 455                                               "00 00"//pad\r
 456                                               );\r
 457         \r
 458         MultipartReplyMessage builtByFactory = BufferHelper.decodeV13(MultipartReplyMessageFactory.getInstance(), bb);\r
 459         \r
 460         BufferHelper.checkHeaderV13(builtByFactory);\r
 461         Assert.assertEquals("Wrong type", 11, builtByFactory.getType().getIntValue());\r
 462         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE());\r
 463         \r
 464         MultipartReplyMeterFeatures message = (MultipartReplyMeterFeatures) builtByFactory.getMultipartReplyBody();\r
 465         \r
 466         Assert.assertEquals("Wrong maxMeter", 9, message.getMaxMeter().intValue());\r
 467         Assert.assertEquals("Wrong bandTypes", 1, message.getBandTypes().getIntValue());\r
 468         Assert.assertEquals("Wrong capabilities", new MeterFlags(false, true, true, false), \r
 469                                                       message.getCapabilities());\r
 470         Assert.assertEquals("Wrong maxBands", 3, message.getMaxBands().intValue());\r
 471         Assert.assertEquals("Wrong maxColor", 4, message.getMaxColor().intValue());\r
 472     }\r
 473     \r
 474     /**\r
 475      * Testing {@link MultipartReplyMessageFactory} for correct translation into POJO\r
 476      */\r
 477     @Test\r
 478     public void testMultipartReplyMeterBody(){\r
 479         ByteBuf bb = BufferHelper.buildBuffer("00 09 00 01 00 00 00 00 "+\r
 480                                               "00 00 00 09 "+//meterId\r
 481                                               "00 58 "+//len\r
 482                                               "00 00 00 00 00 00 "+//pad\r
 483                                               "00 00 00 07 "+//flowCount\r
 484                                               "00 01 01 01 01 01 01 01 "+//packetInCount\r
 485                                               "00 01 01 01 01 01 01 01 "+//byteInCount\r
 486                                               "00 00 00 05 "+//durationSec\r
 487                                               "00 00 00 05 "+//durationNsec\r
 488                                               "00 01 01 01 01 01 01 01 "+//packetBandCount_01\r
 489                                               "00 01 01 01 01 01 01 01 "+//byteBandCount_01\r
 490                                               "00 02 02 02 02 02 02 02 "+//packetBandCount_02\r
 491                                               "00 02 02 02 02 02 02 02 "+//byteBandCount_02\r
 492                                               "00 03 03 03 03 03 03 03 "+//packetBandCount_03\r
 493                                               "00 03 03 03 03 03 03 03"//byteBandCount_03\r
 494                                               );\r
 495         \r
 496         MultipartReplyMessage builtByFactory = BufferHelper.decodeV13(MultipartReplyMessageFactory.getInstance(), bb);\r
 497         \r
 498         BufferHelper.checkHeaderV13(builtByFactory);\r
 499         Assert.assertEquals("Wrong type", 9, builtByFactory.getType().getIntValue());\r
 500         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE());\r
 501         \r
 502         MultipartReplyMeter message = (MultipartReplyMeter) builtByFactory.getMultipartReplyBody();\r
 503         \r
 504         Assert.assertEquals("Wrong meterId", 9, \r
 505                              message.getMeterStats().get(0).getMeterId().intValue());\r
 506         Assert.assertEquals("Wrong flowCount", 7, \r
 507                             message.getMeterStats().get(0).getFlowCount().intValue());\r
 508         Assert.assertEquals("Wrong packetInCount", \r
 509                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 510                 message.getMeterStats().get(0).getPacketInCount());\r
 511         Assert.assertEquals("Wrong byteInCount", \r
 512                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 513                 message.getMeterStats().get(0).getByteInCount());\r
 514         Assert.assertEquals("Wrong durationSec", 5, \r
 515                 message.getMeterStats().get(0).getDurationSec().intValue());\r
 516         Assert.assertEquals("Wrong durationNsec", 5, \r
 517                 message.getMeterStats().get(0).getDurationNsec().intValue());\r
 518         Assert.assertEquals("Wrong packetBandCount_01", \r
 519                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 520                 message.getMeterStats().get(0).getMeterBandStats().get(0).getPacketBandCount());\r
 521         Assert.assertEquals("Wrong byteBandCount_01", \r
 522                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 523                 message.getMeterStats().get(0).getMeterBandStats().get(0).getByteBandCount());\r
 524         Assert.assertEquals("Wrong packetBandCount_02", \r
 525                 new BigInteger(new byte[]{0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02}), \r
 526                 message.getMeterStats().get(0).getMeterBandStats().get(1).getPacketBandCount());\r
 527         Assert.assertEquals("Wrong byteBandCount_02", \r
 528                 new BigInteger(new byte[]{0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02}), \r
 529                 message.getMeterStats().get(0).getMeterBandStats().get(1).getByteBandCount());\r
 530         Assert.assertEquals("Wrong packetBandCount_03", \r
 531                 new BigInteger(new byte[]{0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03}), \r
 532                 message.getMeterStats().get(0).getMeterBandStats().get(2).getPacketBandCount());\r
 533         Assert.assertEquals("Wrong byteBandCount_03", \r
 534                 new BigInteger(new byte[]{0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03}), \r
 535                 message.getMeterStats().get(0).getMeterBandStats().get(2).getByteBandCount());\r
 536     }\r
 537     \r
 538     @Test\r
 539     public void testMultipartReplyMeterBodyMulti(){\r
 540         ByteBuf bb = BufferHelper.buildBuffer("00 09 00 01 00 00 00 00 "+\r
 541                                               "00 00 00 09 "+//meterId_0\r
 542                                               "00 58 "+//len_0\r
 543                                               "00 00 00 00 00 00 "+//pad_0\r
 544                                               "00 00 00 07 "+//flowCount_0\r
 545                                               "00 01 01 01 01 01 01 01 "+//packetInCount_0\r
 546                                               "00 01 01 01 01 01 01 01 "+//byteInCount_0\r
 547                                               "00 00 00 05 "+//durationSec_0\r
 548                                               "00 00 00 05 "+//durationNsec_0\r
 549                                               "00 01 01 01 01 01 01 01 "+//packetBandCount_01\r
 550                                               "00 01 01 01 01 01 01 01 "+//byteBandCount_01\r
 551                                               "00 02 02 02 02 02 02 02 "+//packetBandCount_02\r
 552                                               "00 02 02 02 02 02 02 02 "+//byteBandCount_02\r
 553                                               "00 03 03 03 03 03 03 03 "+//packetBandCount_03\r
 554                                               "00 03 03 03 03 03 03 03 "+//byteBandCount_03\r
 555                                               "00 00 00 08 "+//meterId_1\r
 556                                               "00 58 "+//len_1\r
 557                                               "00 00 00 00 00 00 "+//pad_1\r
 558                                               "00 00 00 07 "+//flowCount_1\r
 559                                               "00 01 01 01 01 01 01 01 "+//packetInCount_1\r
 560                                               "00 01 01 01 01 01 01 01 "+//byteInCount_1\r
 561                                               "00 00 00 05 "+//durationSec_1\r
 562                                               "00 00 00 05 "+//durationNsec_1\r
 563                                               "00 01 01 01 01 01 01 01 "+//packetBandCount_11\r
 564                                               "00 01 01 01 01 01 01 01 "+//byteBandCount_11\r
 565                                               "00 02 02 02 02 02 02 02 "+//packetBandCount_12\r
 566                                               "00 02 02 02 02 02 02 02 "+//byteBandCount_12\r
 567                                               "00 03 03 03 03 03 03 03 "+//packetBandCount_13\r
 568                                               "00 03 03 03 03 03 03 03"//byteBandCount_13\r
 569                                               );\r
 570         \r
 571         MultipartReplyMessage builtByFactory = BufferHelper.decodeV13(MultipartReplyMessageFactory.getInstance(), bb);\r
 572         \r
 573         BufferHelper.checkHeaderV13(builtByFactory);\r
 574         Assert.assertEquals("Wrong type", 9, builtByFactory.getType().getIntValue());\r
 575         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE());\r
 576         \r
 577         MultipartReplyMeter message = (MultipartReplyMeter) builtByFactory.getMultipartReplyBody();\r
 578         \r
 579         Assert.assertEquals("Wrong meterId", 9, \r
 580                              message.getMeterStats().get(0).getMeterId().intValue());\r
 581         Assert.assertEquals("Wrong flowCount", 7, \r
 582                             message.getMeterStats().get(0).getFlowCount().intValue());\r
 583         Assert.assertEquals("Wrong packetInCount", \r
 584                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 585                 message.getMeterStats().get(0).getPacketInCount());\r
 586         Assert.assertEquals("Wrong byteInCount", \r
 587                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 588                 message.getMeterStats().get(0).getByteInCount());\r
 589         Assert.assertEquals("Wrong durationSec", 5, \r
 590                 message.getMeterStats().get(0).getDurationSec().intValue());\r
 591         Assert.assertEquals("Wrong durationNsec", 5, \r
 592                 message.getMeterStats().get(0).getDurationNsec().intValue());\r
 593         Assert.assertEquals("Wrong packetBandCount_01", \r
 594                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 595                 message.getMeterStats().get(0).getMeterBandStats().get(0).getPacketBandCount());\r
 596         Assert.assertEquals("Wrong byteBandCount_01", \r
 597                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 598                 message.getMeterStats().get(0).getMeterBandStats().get(0).getByteBandCount());\r
 599         Assert.assertEquals("Wrong packetBandCount_02", \r
 600                 new BigInteger(new byte[]{0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02}), \r
 601                 message.getMeterStats().get(0).getMeterBandStats().get(1).getPacketBandCount());\r
 602         Assert.assertEquals("Wrong byteBandCount_02", \r
 603                 new BigInteger(new byte[]{0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02}), \r
 604                 message.getMeterStats().get(0).getMeterBandStats().get(1).getByteBandCount());\r
 605         Assert.assertEquals("Wrong packetBandCount_03", \r
 606                 new BigInteger(new byte[]{0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03}), \r
 607                 message.getMeterStats().get(0).getMeterBandStats().get(2).getPacketBandCount());\r
 608         Assert.assertEquals("Wrong byteBandCount_03", \r
 609                 new BigInteger(new byte[]{0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03}), \r
 610                 message.getMeterStats().get(0).getMeterBandStats().get(2).getByteBandCount());\r
 611         \r
 612         Assert.assertEquals("Wrong meterId", 8, \r
 613                 message.getMeterStats().get(1).getMeterId().intValue());\r
 614         Assert.assertEquals("Wrong flowCount", 7, \r
 615                 message.getMeterStats().get(1).getFlowCount().intValue());\r
 616         Assert.assertEquals("Wrong packetInCount", \r
 617                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 618                 message.getMeterStats().get(1).getPacketInCount());\r
 619         Assert.assertEquals("Wrong byteInCount", \r
 620                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 621                 message.getMeterStats().get(1).getByteInCount());\r
 622         Assert.assertEquals("Wrong durationSec", 5, \r
 623                 message.getMeterStats().get(1).getDurationSec().intValue());\r
 624         Assert.assertEquals("Wrong durationNsec", 5, \r
 625                 message.getMeterStats().get(1).getDurationNsec().intValue());\r
 626         Assert.assertEquals("Wrong packetBandCount_01", \r
 627                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 628                 message.getMeterStats().get(1).getMeterBandStats().get(0).getPacketBandCount());\r
 629         Assert.assertEquals("Wrong byteBandCount_01", \r
 630                 new BigInteger(new byte[]{0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 631                 message.getMeterStats().get(1).getMeterBandStats().get(0).getByteBandCount());\r
 632         Assert.assertEquals("Wrong packetBandCount_02", \r
 633                 new BigInteger(new byte[]{0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02}), \r
 634                 message.getMeterStats().get(1).getMeterBandStats().get(1).getPacketBandCount());\r
 635         Assert.assertEquals("Wrong byteBandCount_02", \r
 636                 new BigInteger(new byte[]{0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02}), \r
 637                 message.getMeterStats().get(1).getMeterBandStats().get(1).getByteBandCount());\r
 638         Assert.assertEquals("Wrong packetBandCount_03", \r
 639                 new BigInteger(new byte[]{0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03}), \r
 640                 message.getMeterStats().get(1).getMeterBandStats().get(2).getPacketBandCount());\r
 641         Assert.assertEquals("Wrong byteBandCount_03", \r
 642                 new BigInteger(new byte[]{0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03}), \r
 643                 message.getMeterStats().get(1).getMeterBandStats().get(2).getByteBandCount());\r
 644     }\r
 645     \r
 646     /**\r
 647      * Testing {@link MultipartReplyMessageFactory} for correct translation into POJO\r
 648      */\r
 649     @Test\r
 650     public void testMultipartReplyMeterConfigBody(){\r
 651         ByteBuf bb = BufferHelper.buildBuffer("00 0A 00 01 00 00 00 00 "+\r
 652                                               "00 38 "+//len\r
 653                                               "00 01 "+//flags\r
 654                                               "00 00 00 09 "+//meterId\r
 655                                               "00 01 "+//meterBandDrop.type\r
 656                                               "00 10 "+//meterBandDrop.len\r
 657                                               "00 00 00 11 "+//meterBandDrop.rate\r
 658                                               "00 00 00 20 "+//meterBandDrop.burstSize\r
 659                                               "00 00 00 00 "+//meterBandDrop.pad\r
 660                                               "00 02 "+//meterBandDscp.type\r
 661                                               "00 10 "+//meterBandDscp.len\r
 662                                               "00 00 00 11 "+//meterBandDscp.rate\r
 663                                               "00 00 00 20 "+//meterBandDscp.burstSize\r
 664                                               "04 "+//meterBandDscp.precLevel\r
 665                                               "00 00 00 "+//meterBandDscp.pad\r
 666                                               "FF FF "+//meterBandExperimenter.type\r
 667                                               "00 10 "+//meterBandExperimenter.len\r
 668                                               "00 00 00 11 "+//meterBandExperimenter.rate\r
 669                                               "00 00 00 20 "+//meterBandExperimenter.burstSize\r
 670                                               "00 00 00 04"//meterBandExperimenter.experimenter\r
 671                                               );\r
 672         \r
 673         MultipartReplyMessage builtByFactory = BufferHelper.decodeV13(MultipartReplyMessageFactory.getInstance(), bb);\r
 674         \r
 675         BufferHelper.checkHeaderV13(builtByFactory);\r
 676         Assert.assertEquals("Wrong type", 10, builtByFactory.getType().getIntValue());\r
 677         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE());\r
 678         \r
 679         MultipartReplyMeterConfig message = (MultipartReplyMeterConfig) builtByFactory.getMultipartReplyBody();\r
 680         \r
 681         Assert.assertEquals("Wrong flags", 1, \r
 682                              message.getMeterConfig().get(0).getFlags().getIntValue());\r
 683         Assert.assertEquals("Wrong meterId", 9, \r
 684                              message.getMeterConfig().get(0).getMeterId().intValue());\r
 685         \r
 686         MeterBandDrop meterBandDrop = (MeterBandDrop) message.getMeterConfig().get(0).getBands().get(0).getMeterBand(); \r
 687         Assert.assertEquals("Wrong meterBandDrop.type", 1, meterBandDrop.getType().getIntValue()); \r
 688         Assert.assertEquals("Wrong meterBandDrop.rate", 17, meterBandDrop.getRate().intValue());\r
 689         Assert.assertEquals("Wrong meterBandDrop.burstSize", 32, meterBandDrop.getBurstSize().intValue());\r
 690         \r
 691         MeterBandDscpRemark meterBandDscp = (MeterBandDscpRemark) message.getMeterConfig().get(0).getBands().get(1).getMeterBand(); \r
 692         Assert.assertEquals("Wrong meterBandDscp.type", 2, meterBandDscp.getType().getIntValue()); \r
 693         Assert.assertEquals("Wrong meterBandDscp.rate", 17, meterBandDscp.getRate().intValue());\r
 694         Assert.assertEquals("Wrong meterBandDscp.burstSize", 32, meterBandDscp.getBurstSize().intValue());\r
 695         Assert.assertEquals("Wrong meterBandDscp.precLevel", 4, meterBandDscp.getPrecLevel().intValue());\r
 696         \r
 697         MeterBandExperimenter meterBandExperimenter = (MeterBandExperimenter) message.getMeterConfig().get(0).getBands().get(2).getMeterBand(); \r
 698         Assert.assertEquals("Wrong meterBandExperimenter.type", 0xFFFF, meterBandExperimenter.getType().getIntValue()); \r
 699         Assert.assertEquals("Wrong meterBandExperimenter.rate", 17, meterBandExperimenter.getRate().intValue());\r
 700         Assert.assertEquals("Wrong meterBandExperimenter.burstSize", 32, meterBandExperimenter.getBurstSize().intValue());\r
 701         Assert.assertEquals("Wrong meterBandExperimenter.experimenter", 4, meterBandExperimenter.getExperimenter().intValue());\r
 702     }\r
 703     \r
 704     /**\r
 705      * Testing {@link MultipartReplyMessageFactory} for correct translation into POJO\r
 706      */\r
 707     @Test\r
 708     public void testMultipartReplyMeterConfigBodyMulti(){\r
 709         ByteBuf bb = BufferHelper.buildBuffer("00 0A 00 01 00 00 00 00 "+\r
 710                                               "00 38 "+//len\r
 711                                               "00 01 "+//flags\r
 712                                               "00 00 00 09 "+//meterId\r
 713                                               "00 01 "+//meterBandDrop.type\r
 714                                               "00 10 "+//meterBandDrop.len\r
 715                                               "00 00 00 11 "+//meterBandDrop.rate\r
 716                                               "00 00 00 20 "+//meterBandDrop.burstSize\r
 717                                               "00 00 00 00 "+//meterBandDrop.pad\r
 718                                               "00 02 "+//meterBandDscp.type\r
 719                                               "00 10 "+//meterBandDscp.len\r
 720                                               "00 00 00 11 "+//meterBandDscp.rate\r
 721                                               "00 00 00 20 "+//meterBandDscp.burstSize\r
 722                                               "04 "+//meterBandDscp.precLevel\r
 723                                               "00 00 00 "+//meterBandDscp.pad\r
 724                                               "FF FF "+//meterBandExperimenter.type\r
 725                                               "00 10 "+//meterBandExperimenter.len\r
 726                                               "00 00 00 11 "+//meterBandExperimenter.rate\r
 727                                               "00 00 00 20 "+//meterBandExperimenter.burstSize\r
 728                                               "00 00 00 04 "+//meterBandExperimenter.experimenter\r
 729                                               \r
 730                                               "00 18 "+//len01\r
 731                                               "00 00 "+//flags01\r
 732                                               "00 00 00 07 "+//meterId01\r
 733                                               "00 02 "+//meterBandDscp01.type\r
 734                                               "00 10 "+//meterBandDscp01.len\r
 735                                               "00 00 00 11 "+//meterBandDscp01.rate\r
 736                                               "00 00 00 20 "+//meterBandDscp01.burstSize\r
 737                                               "04 "+//meterBandDscp01.precLevel\r
 738                                               "00 00 00"//meterBandDscp01.pad\r
 739                                               );\r
 740         \r
 741         MultipartReplyMessage builtByFactory = BufferHelper.decodeV13(MultipartReplyMessageFactory.getInstance(), bb);\r
 742         \r
 743         BufferHelper.checkHeaderV13(builtByFactory);\r
 744         Assert.assertEquals("Wrong type", 10, builtByFactory.getType().getIntValue());\r
 745         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE());\r
 746         \r
 747         MultipartReplyMeterConfig message = (MultipartReplyMeterConfig) builtByFactory.getMultipartReplyBody();\r
 748         \r
 749         Assert.assertEquals("Wrong flags", 1, \r
 750                              message.getMeterConfig().get(0).getFlags().getIntValue());\r
 751         Assert.assertEquals("Wrong meterId", 9, \r
 752                              message.getMeterConfig().get(0).getMeterId().intValue());\r
 753         \r
 754         MeterBandDrop meterBandDrop = (MeterBandDrop) message.getMeterConfig().get(0).getBands().get(0).getMeterBand(); \r
 755         Assert.assertEquals("Wrong meterBandDrop.type", 1, meterBandDrop.getType().getIntValue()); \r
 756         Assert.assertEquals("Wrong meterBandDrop.rate", 17, meterBandDrop.getRate().intValue());\r
 757         Assert.assertEquals("Wrong meterBandDrop.burstSize", 32, meterBandDrop.getBurstSize().intValue());\r
 758         \r
 759         MeterBandDscpRemark meterBandDscp = (MeterBandDscpRemark) message.getMeterConfig().get(0).getBands().get(1).getMeterBand(); \r
 760         Assert.assertEquals("Wrong meterBandDscp.type", 2, meterBandDscp.getType().getIntValue()); \r
 761         Assert.assertEquals("Wrong meterBandDscp.rate", 17, meterBandDscp.getRate().intValue());\r
 762         Assert.assertEquals("Wrong meterBandDscp.burstSize", 32, meterBandDscp.getBurstSize().intValue());\r
 763         Assert.assertEquals("Wrong meterBandDscp.precLevel", 4, meterBandDscp.getPrecLevel().intValue());\r
 764         \r
 765         MeterBandExperimenter meterBandExperimenter = (MeterBandExperimenter) message.getMeterConfig().get(0).getBands().get(2).getMeterBand(); \r
 766         Assert.assertEquals("Wrong meterBandExperimenter.type", 0xFFFF, meterBandExperimenter.getType().getIntValue()); \r
 767         Assert.assertEquals("Wrong meterBandExperimenter.rate", 17, meterBandExperimenter.getRate().intValue());\r
 768         Assert.assertEquals("Wrong meterBandExperimenter.burstSize", 32, meterBandExperimenter.getBurstSize().intValue());\r
 769         Assert.assertEquals("Wrong meterBandExperimenter.experimenter", 4, meterBandExperimenter.getExperimenter().intValue());\r
 770         \r
 771         Assert.assertEquals("Wrong flags01", 1, \r
 772                              message.getMeterConfig().get(0).getFlags().getIntValue());\r
 773         Assert.assertEquals("Wrong meterId01", 7, \r
 774                              message.getMeterConfig().get(1).getMeterId().intValue());\r
 775         \r
 776         MeterBandDscpRemark meterBandDscp01 = (MeterBandDscpRemark) message.getMeterConfig().get(1).getBands().get(0).getMeterBand(); \r
 777         Assert.assertEquals("Wrong meterBandDscp01.type", 2, meterBandDscp01.getType().getIntValue()); \r
 778         Assert.assertEquals("Wrong meterBandDscp01.rate", 17, meterBandDscp01.getRate().intValue());\r
 779         Assert.assertEquals("Wrong meterBandDscp01.burstSize", 32, meterBandDscp01.getBurstSize().intValue());\r
 780         Assert.assertEquals("Wrong meterBandDscp01.precLevel", 4, meterBandDscp01.getPrecLevel().intValue());\r
 781         \r
 782     }\r
 783     \r
 784     /**\r
 785      * Testing {@link MultipartReplyMessageFactory} for correct translation into POJO\r
 786      */\r
 787     @Test\r
 788     public void testMultipartReplyExperimenterBody(){\r
 789         ByteBuf bb = BufferHelper.buildBuffer("FF FF 00 01 00 00 00 00 "+\r
 790                                               "00 00 00 0F "+//experimenterId\r
 791                                               "00 00 00 FF "+//expType\r
 792                                               "00 00 01 01 00 00 01 01"\r
 793                                               );\r
 794         \r
 795         MultipartReplyMessage builtByFactory = BufferHelper.decodeV13(MultipartReplyMessageFactory.getInstance(), bb);\r
 796         \r
 797         BufferHelper.checkHeaderV13(builtByFactory);\r
 798         Assert.assertEquals("Wrong type", 0xFFFF, builtByFactory.getType().getIntValue());\r
 799         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE());\r
 800         \r
 801         MultipartReplyExperimenter message = (MultipartReplyExperimenter) builtByFactory.getMultipartReplyBody();\r
 802         \r
 803         Assert.assertEquals("Wrong experimenterId", 15, message.getExperimenter().intValue());\r
 804         Assert.assertEquals("Wrong expType", 255, message.getExpType().intValue());\r
 805         Assert.assertArrayEquals("Wrong data", new byte[]{0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01}, \r
 806                              message.getData());\r
 807     }\r
 808     \r
 809     /**\r
 810      * Testing {@link MultipartReplyMessageFactory} for correct translation into POJO\r
 811      */\r
 812     @Test\r
 813     public void testMultipartReplyPortDescBody(){\r
 814         final byte MAX_PORT_NAME_LEN = 16;\r
 815         ByteBuf bb = BufferHelper.buildBuffer("00 0D 00 01 00 00 00 00 "+\r
 816                                               "00 01 02 03 "+ //portNo\r
 817                                               "00 00 00 00 "+ //padding01\r
 818                                               "08 00 27 00 B0 EB " + //mac address\r
 819                                               "00 00 "); //padding02\r
 820         //port name\r
 821         String portName = "SampleText";\r
 822         byte[] portNameBytes = new byte[MAX_PORT_NAME_LEN];\r
 823         portNameBytes = portName.getBytes();\r
 824         bb.writeBytes(portNameBytes);\r
 825         ByteBufUtils.padBuffer((MAX_PORT_NAME_LEN - portNameBytes.length), bb);\r
 826         \r
 827         ByteBuf bb2 =  BufferHelper.buildBuffer("00 00 00 41 " + //port config\r
 828                                                 "00 00 00 05 " + //port state\r
 829                                                 "00 00 00 81 " + //current features\r
 830                                                 "00 00 00 81 " + //advertised features\r
 831                                                 "00 00 00 81 " + //supported features\r
 832                                                 "00 00 00 81 " + //peer features\r
 833                                                 "00 00 00 81 " + //curr speed\r
 834                                                 "00 00 00 80" //max speed\r
 835                                                 );\r
 836         bb.writeBytes(bb2.copy(4, bb2.readableBytes()-4));//excluding version and xid\r
 837         \r
 838         MultipartReplyMessage builtByFactory = BufferHelper.decodeV13(MultipartReplyMessageFactory.getInstance(), bb);\r
 839         \r
 840         BufferHelper.checkHeaderV13(builtByFactory);\r
 841         Assert.assertEquals("Wrong type", 13, builtByFactory.getType().getIntValue());\r
 842         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE());\r
 843         \r
 844         MultipartReplyPortDesc message = (MultipartReplyPortDesc) builtByFactory.getMultipartReplyBody();\r
 845         \r
 846         Assert.assertEquals("Wrong portNo", 66051L, message.getPorts().get(0).getPortNo().longValue());\r
 847         Assert.assertEquals("Wrong macAddress", new MacAddress("08002700B0EB"), \r
 848                                                 message.getPorts().get(0).getHwAddr());\r
 849         Assert.assertEquals("Wrong portName", "SampleText", \r
 850                                                 message.getPorts().get(0).getName());\r
 851         Assert.assertEquals("Wrong portConfig", new PortConfig(false, true, false, true), \r
 852                                                 message.getPorts().get(0).getConfig());\r
 853         Assert.assertEquals("Wrong portState", new PortState(true, false, true), \r
 854                                                message.getPorts().get(0).getState());\r
 855         Assert.assertEquals("Wrong currentFeatures", new PortFeatures(true, false, false, false,\r
 856                                                                       false, false, false, true, \r
 857                                                                       false, false, false, false, \r
 858                                                                       false, false, false, false), \r
 859                                                   message.getPorts().get(0).getCurrentFeatures());\r
 860         Assert.assertEquals("Wrong advertisedFeatures", \r
 861                              new PortFeatures(true, false, false, false,\r
 862                                               false, false, false, true, \r
 863                                               false, false, false, false, \r
 864                                               false, false, false, false), \r
 865                                               message.getPorts().get(0).getAdvertisedFeatures());\r
 866         Assert.assertEquals("Wrong supportedFeatures", \r
 867                              new PortFeatures(true, false, false, false,\r
 868                                               false, false, false, true, \r
 869                                               false, false, false, false, \r
 870                                               false, false, false, false), \r
 871                                               message.getPorts().get(0).getSupportedFeatures());\r
 872         Assert.assertEquals("Wrong peerFeatures", \r
 873                              new PortFeatures(true, false, false, false,\r
 874                                               false, false, false, true, \r
 875                                               false, false, false, false, \r
 876                                               false, false, false, false), \r
 877                                               message.getPorts().get(0).getPeerFeatures());\r
 878         Assert.assertEquals("Wrong currSpeed", 129L, message.getPorts().get(0).getCurrSpeed().longValue());\r
 879         Assert.assertEquals("Wrong maxSpeed", 128L, message.getPorts().get(0).getMaxSpeed().longValue());\r
 880     }\r
 881     \r
 882     /**\r
 883      * Testing {@link MultipartReplyMessageFactory} for correct translation into POJO\r
 884      * Test covers bodies of actions Output, Copy TTL Out, Copy TTL In\r
 885      */\r
 886     @Test\r
 887     public void testMultipartReplyGroupDescBody01(){\r
 888         ByteBuf bb = BufferHelper.buildBuffer("00 07 00 01 00 00 00 00 "+\r
 889                                               "00 38 "+//len\r
 890                                               "01 "+//type\r
 891                                               "00 "+//pad\r
 892                                               "00 00 00 08 "+//groupId\r
 893                                               "00 30 "+//bucketLen\r
 894                                               "00 06 "+//bucketWeight\r
 895                                               "00 00 00 05 "+//bucketWatchPort\r
 896                                               "00 00 00 04 "+//bucketWatchGroup\r
 897                                               "00 00 00 00 "+//bucketPad\r
 898                                               "00 00 "+//outputType\r
 899                                               "00 10 "+//outputLen\r
 900                                               "00 00 10 FF "+//outputPort\r
 901                                               "FF FF "+//outputMaxLen\r
 902                                               "00 00 00 00 00 00 "+//outputPad\r
 903                                               "00 0B "+//copyTTLOutType\r
 904                                               "00 08 "+//copyTTLOutLen\r
 905                                               "00 00 00 00 "+//copyTTLOutPad\r
 906                                               "00 0C "+//copyTTLIntType\r
 907                                               "00 08 "+//copyTTLIntLen\r
 908                                               "00 00 00 00"//copyTTLInPad\r
 909                                               );\r
 910         \r
 911         MultipartReplyMessage builtByFactory = BufferHelper.decodeV13(MultipartReplyMessageFactory.getInstance(), bb);\r
 912         \r
 913         BufferHelper.checkHeaderV13(builtByFactory);\r
 914         Assert.assertEquals("Wrong type", 7, builtByFactory.getType().getIntValue());\r
 915         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE());\r
 916         \r
 917         MultipartReplyGroupDesc message = (MultipartReplyGroupDesc) builtByFactory.getMultipartReplyBody();\r
 918         \r
 919         Assert.assertEquals("Wrong type", 1, \r
 920                              message.getGroupDesc().get(0).getType().getIntValue());\r
 921         Assert.assertEquals("Wrong groupId", 8, \r
 922                              message.getGroupDesc().get(0).getGroupId().intValue());\r
 923         Assert.assertEquals("Wrong bucketWeight", 6, \r
 924                 message.getGroupDesc().get(0).getBucketsList().get(0).getWeight().intValue());\r
 925         Assert.assertEquals("Wrong bucketWatchPort", 5, \r
 926                 message.getGroupDesc().get(0).getBucketsList().get(0).getWatchPort().\r
 927                                                                         getValue().intValue());\r
 928         Assert.assertEquals("Wrong bucketWatchGroup", 4, \r
 929                 message.getGroupDesc().get(0).getBucketsList().get(0).getWatchGroup().intValue());\r
 930         \r
 931         Assert.assertEquals("Wrong outputType", Output.class, \r
 932                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(0).\r
 933                 getAction().getType());\r
 934         \r
 935         Assert.assertEquals("Wrong outputPort", 4351, \r
 936                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(0).\r
 937                 getAction().getAugmentation(PortAction.class).\r
 938                 getPort().getPortNumber().getValue().intValue());\r
 939         \r
 940         Assert.assertEquals("Wrong outputMaxLen", 65535, \r
 941                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(0).\r
 942                 getAction().getAugmentation(MaxLengthAction.class).\r
 943                 getMaxLength().intValue());\r
 944         \r
 945         Assert.assertEquals("Wrong copyTtlOutType", CopyTtlOut.class, \r
 946                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(1).\r
 947                 getAction().getType());\r
 948         \r
 949         Assert.assertEquals("Wrong copyTtlInType", CopyTtlIn.class, \r
 950                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(2).\r
 951                 getAction().getType());\r
 952     }\r
 953     \r
 954     /**\r
 955      * Testing {@link MultipartReplyMessageFactory} for correct translation into POJO\r
 956      * Test covers bodies of actions Set MPLS TTL , Dec MPLS TTL, Push VLAN. Push MPLS, Push PBB\r
 957      */\r
 958     @Test\r
 959     public void testMultipartReplyGroupDescBody02(){\r
 960         ByteBuf bb = BufferHelper.buildBuffer("00 07 00 01 00 00 00 00 "+\r
 961                                               "00 40 "+//len\r
 962                                               "01 "+//type\r
 963                                               "00 "+//pad\r
 964                                               "00 00 00 08 "+//groupId\r
 965                                               "00 38 "+//bucketLen\r
 966                                               "00 06 "+//bucketWeight\r
 967                                               "00 00 00 05 "+//bucketWatchPort\r
 968                                               "00 00 00 04 "+//bucketWatchGroup\r
 969                                               "00 00 00 00 "+//bucketPad\r
 970                                               "00 0F "+//setMplsTtlType\r
 971                                               "00 08 "+//setMplsTtlLen\r
 972                                               "09 "+//setMplsTtlMPLS_TTL\r
 973                                               "00 00 00 "+//setMplsTtlPad\r
 974                                               "00 10 "+//decMplsTtlType\r
 975                                               "00 08 "+//decMplsTtlLen\r
 976                                               "00 00 00 00 "+//decMplsTtlPad\r
 977                                               "00 11 "+//pushVlanType\r
 978                                               "00 08 "+//pushVlanLen\r
 979                                               "00 20 "+//pushVlanEthertype\r
 980                                               "00 00 "+//pushVlanPad\r
 981                                               "00 13 "+//pushMplsType\r
 982                                               "00 08 "+//pushMplsLen\r
 983                                               "00 FF "+//pushMplsEthertype\r
 984                                               "00 00 "+//pushMplsPad\r
 985                                               "00 1A "+//pushPbbType\r
 986                                               "00 08 "+//pushPbbLen\r
 987                                               "0F FF "+//pushPbbEthertype\r
 988                                               "00 00"//pushPbbPad\r
 989                                               );\r
 990         \r
 991         MultipartReplyMessage builtByFactory = BufferHelper.decodeV13(MultipartReplyMessageFactory.getInstance(), bb);\r
 992         \r
 993         BufferHelper.checkHeaderV13(builtByFactory);\r
 994         Assert.assertEquals("Wrong type", 7, builtByFactory.getType().getIntValue());\r
 995         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE());\r
 996         \r
 997         MultipartReplyGroupDesc message = (MultipartReplyGroupDesc) builtByFactory.getMultipartReplyBody();\r
 998         \r
 999         Assert.assertEquals("Wrong type", 1, \r
1000                              message.getGroupDesc().get(0).getType().getIntValue());\r
1001         Assert.assertEquals("Wrong groupId", 8, \r
1002                              message.getGroupDesc().get(0).getGroupId().intValue());\r
1003         Assert.assertEquals("Wrong bucketWeight", 6, \r
1004                 message.getGroupDesc().get(0).getBucketsList().get(0).getWeight().intValue());\r
1005         Assert.assertEquals("Wrong bucketWatchPort", 5, \r
1006                 message.getGroupDesc().get(0).getBucketsList().get(0).getWatchPort().\r
1007                                                                         getValue().intValue());\r
1008         Assert.assertEquals("Wrong bucketWatchGroup", 4, \r
1009                 message.getGroupDesc().get(0).getBucketsList().get(0).getWatchGroup().intValue());\r
1010         \r
1011         \r
1012         Assert.assertEquals("Wrong setMplsTtlType", SetMplsTtl.class, \r
1013                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(0).\r
1014                 getAction().getType());\r
1015         \r
1016         Assert.assertEquals("Wrong setMplsTtlMPLS_TTL", 9, \r
1017                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(0).\r
1018                 getAction().getAugmentation(MplsTtlAction.class).\r
1019                 getMplsTtl().intValue());\r
1020         \r
1021         Assert.assertEquals("Wrong decMplsTtlType", DecMplsTtl.class, \r
1022                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(1).\r
1023                 getAction().getType());\r
1024         \r
1025         Assert.assertEquals("Wrong pushVlanType", PushVlan.class, \r
1026                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(2).\r
1027                 getAction().getType());\r
1028         \r
1029         Assert.assertEquals("Wrong pushVlanEthertype", 32, \r
1030                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(2).\r
1031                 getAction().getAugmentation(EthertypeAction.class).\r
1032                 getEthertype().getValue().intValue());\r
1033         \r
1034         Assert.assertEquals("Wrong pushMplsType", PushMpls.class, \r
1035                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(3).\r
1036                 getAction().getType());\r
1037         \r
1038         Assert.assertEquals("Wrong pushMplsEthertype", 255, \r
1039                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(3).\r
1040                 getAction().getAugmentation(EthertypeAction.class).\r
1041                 getEthertype().getValue().intValue());\r
1042         \r
1043         Assert.assertEquals("Wrong pushPbbType", PushPbb.class, \r
1044                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(4).\r
1045                 getAction().getType());\r
1046         \r
1047         Assert.assertEquals("Wrong pushPbbEthertype", 4095, \r
1048                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(4).\r
1049                 getAction().getAugmentation(EthertypeAction.class).\r
1050                 getEthertype().getValue().intValue());\r
1051         \r
1052     }\r
1053     \r
1054     /**\r
1055      * Testing {@link MultipartReplyMessageFactory} for correct translation into POJO\r
1056      * Test covers bodies of actions Pop VLAN, Pop PBB, Pop MPLS, Group, Dec NW TTL\r
1057      */\r
1058     @Test\r
1059     public void testMultipartReplyGroupDescBody03(){\r
1060         ByteBuf bb = BufferHelper.buildBuffer("00 07 00 01 00 00 00 00 "+\r
1061                                               "00 48 "+//len\r
1062                                               "01 "+//type\r
1063                                               "00 "+//pad\r
1064                                               "00 00 00 08 "+//groupId\r
1065                                               "00 40 "+//bucketLen\r
1066                                               "00 06 "+//bucketWeight\r
1067                                               "00 00 00 05 "+//bucketWatchPort\r
1068                                               "00 00 00 04 "+//bucketWatchGroup\r
1069                                               "00 00 00 00 "+//bucketPad\r
1070                                               "00 12 "+//popVlanType\r
1071                                               "00 08 "+//popVlanLen\r
1072                                               "00 00 00 00 "+//popVlanPad\r
1073                                               "00 1B "+//popPbbType\r
1074                                               "00 08 "+//popPbbLen\r
1075                                               "00 00 00 00 "+//popPbbPad\r
1076                                               "00 14 "+//popMplsType\r
1077                                               "00 08 "+//popMplsLen\r
1078                                               "00 CF "+//popMplsEthertype\r
1079                                               "00 00 "+//popMplsPad\r
1080                                               "00 15 "+//setQueueType\r
1081                                               "00 08 "+//setQueueLen\r
1082                                               "00 CF 00 00 "+//setQueueQueueId\r
1083                                               "00 16 "+//groupType\r
1084                                               "00 08 "+//groupLen\r
1085                                               "00 CF 00 00 "+//groupGroupId\r
1086                                               "00 18 "+//decNwTtlType\r
1087                                               "00 08 "+//decNwTtlLen\r
1088                                               "00 00 00 00"//decNwTtlPad\r
1089                                               );\r
1090         \r
1091         MultipartReplyMessage builtByFactory = BufferHelper.decodeV13(MultipartReplyMessageFactory.getInstance(), bb);\r
1092         \r
1093         BufferHelper.checkHeaderV13(builtByFactory);\r
1094         Assert.assertEquals("Wrong type", 7, builtByFactory.getType().getIntValue());\r
1095         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE());\r
1096         \r
1097         MultipartReplyGroupDesc message = (MultipartReplyGroupDesc) builtByFactory.getMultipartReplyBody();\r
1098         \r
1099         Assert.assertEquals("Wrong type", 1, \r
1100                              message.getGroupDesc().get(0).getType().getIntValue());\r
1101         Assert.assertEquals("Wrong groupId", 8, \r
1102                              message.getGroupDesc().get(0).getGroupId().intValue());\r
1103         Assert.assertEquals("Wrong bucketWeight", 6, \r
1104                 message.getGroupDesc().get(0).getBucketsList().get(0).getWeight().intValue());\r
1105         Assert.assertEquals("Wrong bucketWatchPort", 5, \r
1106                 message.getGroupDesc().get(0).getBucketsList().get(0).getWatchPort().\r
1107                                                                         getValue().intValue());\r
1108         Assert.assertEquals("Wrong bucketWatchGroup", 4, \r
1109                 message.getGroupDesc().get(0).getBucketsList().get(0).getWatchGroup().intValue());\r
1110         \r
1111         Assert.assertEquals("Wrong popVlanType", PopVlan.class, \r
1112                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(0).\r
1113                 getAction().getType());\r
1114         \r
1115         Assert.assertEquals("Wrong popPbbType", PopPbb.class, \r
1116                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(1).\r
1117                 getAction().getType());\r
1118         \r
1119         Assert.assertEquals("Wrong popMplsType", PopMpls.class, \r
1120                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(2).\r
1121                 getAction().getType());\r
1122         \r
1123         Assert.assertEquals("Wrong popMplsEthertype", 207, \r
1124                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(2).\r
1125                 getAction().getAugmentation(EthertypeAction.class).\r
1126                 getEthertype().getValue().intValue());\r
1127         \r
1128         Assert.assertEquals("Wrong setQueueType", SetQueue.class, \r
1129                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(3).\r
1130                 getAction().getType());\r
1131         \r
1132         Assert.assertEquals("Wrong setQueueQueueId", 13565952, \r
1133                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(3).\r
1134                 getAction().getAugmentation(QueueIdAction.class).\r
1135                 getQueueId().intValue());\r
1136         \r
1137         Assert.assertEquals("Wrong groupType", Group.class, \r
1138                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(4).\r
1139                 getAction().getType());\r
1140         \r
1141         Assert.assertEquals("Wrong groupGroupId", 13565952, \r
1142                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(4).\r
1143                 getAction().getAugmentation(GroupIdAction.class).\r
1144                 getGroupId().intValue());\r
1145         \r
1146         Assert.assertEquals("Wrong decNwTtlType", DecNwTtl.class, \r
1147                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(5).\r
1148                 getAction().getType());\r
1149     }\r
1150     \r
1151     /**\r
1152      * Testing {@link MultipartReplyMessageFactory} for correct translation into POJO\r
1153      * Test covers bodies of actions NW TTL, Experimenter\r
1154      */\r
1155     @Test\r
1156     public void testMultipartReplyGroupDescBody04(){\r
1157         ByteBuf bb = BufferHelper.buildBuffer("00 07 00 01 00 00 00 00 "+\r
1158                                               "00 3C "+//len\r
1159                                               "01 "+//type\r
1160                                               "00 "+//pad\r
1161                                               "00 00 00 08 "+//groupId\r
1162                                               "00 34 "+//bucketLen\r
1163                                               "00 06 "+//bucketWeight\r
1164                                               "00 00 00 05 "+//bucketWatchPort\r
1165                                               "00 00 00 04 "+//bucketWatchGroup\r
1166                                               "00 00 00 00 "+//bucketPad\r
1167                                               "00 17 "+//nwTTlType\r
1168                                               "00 08 "+//nwTTlLen\r
1169                                               "0E "+//nwTTlnwTTL\r
1170                                               "00 00 00 "+//nwTTlPad\r
1171                                               "FF FF "+//experimenterType\r
1172                                               "00 08 "+//experimenterLen\r
1173                                               "00 01 02 03 "+//experimenterExperimenter\r
1174                                               "00 19 "+//setFieldType\r
1175                                               "00 14 "+//setFieldLen\r
1176                                               "80 00 "+//setFieldOXMClass\r
1177                                               "00 "+//setFieldOXMField\r
1178                                               "04 "+//setFieldOXMLength\r
1179                                               "00 00 00 FF "+//setFieldPort\r
1180                                               \r
1181                                               "80 00 "+//setFieldOXMClass\r
1182                                               "03 "+//setFieldOXMField\r
1183                                               "04 "+//setFieldOXMLength\r
1184                                               "00 00 0F FF"//setFieldPort\r
1185                                               );\r
1186         \r
1187         MultipartReplyMessage builtByFactory = BufferHelper.decodeV13(MultipartReplyMessageFactory.getInstance(), bb);\r
1188         \r
1189         BufferHelper.checkHeaderV13(builtByFactory);\r
1190         Assert.assertEquals("Wrong type", 7, builtByFactory.getType().getIntValue());\r
1191         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE());\r
1192         \r
1193         MultipartReplyGroupDesc message = (MultipartReplyGroupDesc) builtByFactory.getMultipartReplyBody();\r
1194         \r
1195         Assert.assertEquals("Wrong type", 1, \r
1196                              message.getGroupDesc().get(0).getType().getIntValue());\r
1197         Assert.assertEquals("Wrong groupId", 8, \r
1198                              message.getGroupDesc().get(0).getGroupId().intValue());\r
1199         Assert.assertEquals("Wrong bucketWeight", 6, \r
1200                 message.getGroupDesc().get(0).getBucketsList().get(0).getWeight().intValue());\r
1201         Assert.assertEquals("Wrong bucketWatchPort", 5, \r
1202                 message.getGroupDesc().get(0).getBucketsList().get(0).getWatchPort().\r
1203                                                                         getValue().intValue());\r
1204         Assert.assertEquals("Wrong bucketWatchGroup", 4, \r
1205                 message.getGroupDesc().get(0).getBucketsList().get(0).getWatchGroup().intValue());\r
1206         \r
1207         Assert.assertEquals("Wrong nwTTlType", SetNwTtl.class, \r
1208                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(0).\r
1209                 getAction().getType());\r
1210         \r
1211         Assert.assertEquals("Wrong nwTTlnwTTL", 14, \r
1212                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(0).\r
1213                 getAction().getAugmentation(NwTtlAction.class).getNwTtl().intValue());\r
1214         \r
1215         Assert.assertEquals("Wrong experimenterType", Experimenter.class, \r
1216                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(1).\r
1217                 getAction().getType());\r
1218         \r
1219         Assert.assertEquals("Wrong experimenterExperimenter", 66051, \r
1220                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(1).\r
1221                 getAction().getAugmentation(ExperimenterAction.class).getExperimenter().intValue());\r
1222         \r
1223         Assert.assertEquals("Wrong setFieldType", SetField.class, \r
1224                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(2).\r
1225                 getAction().getType());\r
1226         \r
1227         Assert.assertEquals("Wrong setFieldOXMClass", OpenflowBasicClass.class, \r
1228                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(2).\r
1229                 getAction().getAugmentation(OxmFieldsAction.class).getMatchEntries().get(0).getOxmClass());\r
1230         \r
1231         Assert.assertEquals("Wrong setFieldOXMField", InPort.class, \r
1232                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(2).\r
1233                 getAction().getAugmentation(OxmFieldsAction.class).getMatchEntries().get(0).getOxmMatchField());\r
1234         \r
1235         Assert.assertEquals("Wrong setFieldOXMField", 255, \r
1236                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(2).\r
1237                 getAction().getAugmentation(OxmFieldsAction.class).getMatchEntries().get(0).\r
1238                 getAugmentation(PortNumberMatchEntry.class).getPortNumber().getValue().intValue());\r
1239         \r
1240         \r
1241         Assert.assertEquals("Wrong setFieldOXMClass", OpenflowBasicClass.class, \r
1242                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(2).\r
1243                 getAction().getAugmentation(OxmFieldsAction.class).getMatchEntries().get(1).getOxmClass());\r
1244         \r
1245         Assert.assertEquals("Wrong setFieldOXMField", InPhyPort.class, \r
1246                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(2).\r
1247                 getAction().getAugmentation(OxmFieldsAction.class).getMatchEntries().get(1).getOxmMatchField());\r
1248         \r
1249         Assert.assertEquals("Wrong setFieldOXMField", 4095, \r
1250                 message.getGroupDesc().get(0).getBucketsList().get(0).getActionsList().get(2).\r
1251                 getAction().getAugmentation(OxmFieldsAction.class).getMatchEntries().get(1).\r
1252                 getAugmentation(PortNumberMatchEntry.class).getPortNumber().getValue().intValue());\r
1253     }\r
1254 }\r