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

   1 /*\r
   2  * Copyright (c) 2013 Pantheon Technologies s.r.o. and others.  All rights reserved.\r
   3  *\r
   4  * This program and the accompanying materials are made available under the\r
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html\r
   7  */\r
   8 package org.opendaylight.openflowjava.protocol.impl.deserialization.factories;\r
   9 \r
  10 import io.netty.buffer.ByteBuf;\r
  11 \r
  12 import java.math.BigInteger;\r
  13 \r
  14 import org.junit.Assert;\r
  15 import org.junit.Test;\r
  16 import org.opendaylight.openflowjava.protocol.impl.util.BufferHelper;\r
  17 import org.opendaylight.openflowjava.protocol.impl.util.ByteBufUtils;\r
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.MaxLengthAction;\r
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.PortAction;\r
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.augments.rev131002.VlanVidAction;\r
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.Output;\r
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.SetVlanVid;\r
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.action.rev130731.actions.actions.list.Action;\r
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.FlowWildcardsV10;\r
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartReplyMessage;\r
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyAggregateCase;\r
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyDescCase;\r
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyFlowCase;\r
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyPortStatsCase;\r
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyQueueCase;\r
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyTableCase;\r
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.multipart.reply.aggregate._case.MultipartReplyAggregate;\r
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.multipart.reply.desc._case.MultipartReplyDesc;\r
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.multipart.reply.flow._case.MultipartReplyFlow;\r
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.multipart.reply.port.stats._case.MultipartReplyPortStats;\r
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.multipart.reply.queue._case.MultipartReplyQueue;\r
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.multipart.reply.table._case.MultipartReplyTable;\r
  38 \r
  39 /**\r
  40  * @author michal.polkorab\r
  41  *\r
  42  */\r
  43 public class OF10StatsReplyMessageFactoryTest {\r
  44 \r
  45     /**\r
  46      * Testing OF10StatsReplyMessageFactory (Desc) for correct deserialization\r
  47      */\r
  48     @Test\r
  49     public void testDesc() {\r
  50         final int DESC_STR_LEN = 256;\r
  51         final int SERIAL_NUM_LEN = 32;\r
  52         ByteBuf bb = BufferHelper.buildBuffer("00 00 00 00");\r
  53         \r
  54         String mfrDesc = "Manufacturer description";\r
  55         byte[] mfrDescBytes = new byte[256];\r
  56         mfrDescBytes = mfrDesc.getBytes();\r
  57         bb.writeBytes(mfrDescBytes);\r
  58         ByteBufUtils.padBuffer((DESC_STR_LEN - mfrDescBytes.length), bb);\r
  59         \r
  60         String hwDesc = "Hardware description";\r
  61         byte[] hwDescBytes = new byte[256];\r
  62         hwDescBytes = hwDesc.getBytes();\r
  63         bb.writeBytes(hwDescBytes);\r
  64         ByteBufUtils.padBuffer((DESC_STR_LEN - hwDescBytes.length), bb);\r
  65         \r
  66         String swDesc = "Software description";\r
  67         byte[] swDescBytes = new byte[256];\r
  68         swDescBytes = swDesc.getBytes();\r
  69         bb.writeBytes(swDescBytes);\r
  70         ByteBufUtils.padBuffer((DESC_STR_LEN - swDescBytes.length), bb);\r
  71         \r
  72         String serialNum = "SN0123456789";\r
  73         byte[] serialNumBytes = new byte[32];\r
  74         serialNumBytes = serialNum.getBytes();\r
  75         bb.writeBytes(serialNumBytes);\r
  76         ByteBufUtils.padBuffer((SERIAL_NUM_LEN - serialNumBytes.length), bb);\r
  77         \r
  78         String dpDesc = "switch3 in room 3120";\r
  79         byte[] dpDescBytes = new byte[256];\r
  80         dpDescBytes = dpDesc.getBytes();\r
  81         bb.writeBytes(dpDescBytes);\r
  82         ByteBufUtils.padBuffer((DESC_STR_LEN - dpDescBytes.length), bb);\r
  83         \r
  84         MultipartReplyMessage builtByFactory = BufferHelper.decodeV10(OF10StatsReplyMessageFactory.getInstance(), bb);\r
  85         \r
  86         BufferHelper.checkHeaderV10(builtByFactory);\r
  87         Assert.assertEquals("Wrong type", 0, builtByFactory.getType().getIntValue());\r
  88         Assert.assertEquals("Wrong flag", false, builtByFactory.getFlags().isOFPMPFREQMORE().booleanValue());\r
  89         MultipartReplyDescCase messageCase = (MultipartReplyDescCase) builtByFactory.getMultipartReplyBody();\r
  90         MultipartReplyDesc message = messageCase.getMultipartReplyDesc();\r
  91         Assert.assertEquals("Wrong mfrDesc", "Manufacturer description", message.getMfrDesc());\r
  92         Assert.assertEquals("Wrong hwDesc", "Hardware description", message.getHwDesc());\r
  93         Assert.assertEquals("Wrong swDesc", "Software description", message.getSwDesc());\r
  94         Assert.assertEquals("Wrong serialNum", "SN0123456789", message.getSerialNum());\r
  95         Assert.assertEquals("Wrong dpDesc", "switch3 in room 3120", message.getDpDesc());\r
  96         Assert.assertTrue("Unread data", bb.readableBytes() == 0);\r
  97     }\r
  98     \r
  99     /**\r
 100      * Testing OF10StatsReplyMessageFactory (Flow) for correct deserialization\r
 101      */\r
 102     @Test\r
 103     public void testFlow() {\r
 104         ByteBuf bb = BufferHelper.buildBuffer("00 01 00 01 00 68 01 00 "\r
 105                 + "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 "\r
 106                 + "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 "\r
 107                 + "00 00 00 02 00 00 00 03 00 04 00 05 00 06 00 00 00 00 00 00 "\r
 108                 + "FF 01 02 03 04 05 06 07 FF 01 02 03 04 05 06 07 FF 00 00 00 00 00 00 20 "\r
 109                 + "00 00 00 08 00 01 00 02 00 01 00 08 00 03 00 00");\r
 110         \r
 111         MultipartReplyMessage builtByFactory = \r
 112                 BufferHelper.decodeV10(OF10StatsReplyMessageFactory.getInstance(), bb);\r
 113 \r
 114         BufferHelper.checkHeaderV10(builtByFactory);\r
 115         Assert.assertEquals("Wrong type", 0x01, builtByFactory.getType().getIntValue());\r
 116         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE().booleanValue());\r
 117         MultipartReplyFlowCase messageCase = (MultipartReplyFlowCase) builtByFactory.getMultipartReplyBody();\r
 118         MultipartReplyFlow message = messageCase.getMultipartReplyFlow();\r
 119         Assert.assertEquals("Wrong tableId", 1, message.getFlowStats().get(0).getTableId().intValue());\r
 120         Assert.assertEquals("Wrong durationSec", 2, message.getFlowStats().get(0).getDurationSec().intValue());\r
 121         Assert.assertEquals("Wrong durationNsec", 3, message.getFlowStats().get(0).getDurationNsec().intValue());\r
 122         Assert.assertEquals("Wrong priority", 4, message.getFlowStats().get(0).getPriority().intValue());\r
 123         Assert.assertEquals("Wrong idleTimeOut", 5, message.getFlowStats().get(0).getIdleTimeout().intValue());\r
 124         Assert.assertEquals("Wrong hardTimeOut", 6, message.getFlowStats().get(0).getHardTimeout().intValue());\r
 125         Assert.assertEquals("Wrong cookie",\r
 126                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}), \r
 127                 message.getFlowStats().get(0).getCookie());\r
 128         Assert.assertEquals("Wrong packetCount",\r
 129                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}), \r
 130                 message.getFlowStats().get(0).getPacketCount());\r
 131         Assert.assertEquals("Wrong byteCount",\r
 132                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20}), \r
 133                 message.getFlowStats().get(0).getByteCount());\r
 134         Action action1 = message.getFlowStats().get(0).getActionsList().get(0).getAction();\r
 135         Assert.assertEquals("Wrong action type", Output.class, action1.getType());\r
 136         Assert.assertEquals("Wrong action port", 1, action1.getAugmentation(PortAction.class)\r
 137                 .getPort().getValue().intValue());\r
 138         Assert.assertEquals("Wrong action port", 2, action1.getAugmentation(MaxLengthAction.class)\r
 139                 .getMaxLength().intValue());\r
 140         Action action2 = message.getFlowStats().get(0).getActionsList().get(1).getAction();\r
 141         Assert.assertEquals("Wrong action type", SetVlanVid.class, action2.getType());\r
 142         Assert.assertEquals("Wrong action port", 3, action2.getAugmentation(VlanVidAction.class)\r
 143                 .getVlanVid().intValue());\r
 144         Assert.assertTrue("Unread data", bb.readableBytes() == 0);\r
 145     }\r
 146     \r
 147     /**\r
 148      * Testing OF10StatsReplyMessageFactory (Aggregate) for correct deserialization\r
 149      */\r
 150     @Test\r
 151     public void testAggregate() {\r
 152         ByteBuf bb = BufferHelper.buildBuffer("00 02 00 01 "\r
 153                 + "FF 01 02 03 04 05 06 07 FF 00 00 00 00 00 00 20 00 00 00 30 00 00 00 00");\r
 154         \r
 155         MultipartReplyMessage builtByFactory = \r
 156                 BufferHelper.decodeV10(OF10StatsReplyMessageFactory.getInstance(), bb);\r
 157 \r
 158         BufferHelper.checkHeaderV10(builtByFactory);\r
 159         Assert.assertEquals("Wrong type", 0x02, builtByFactory.getType().getIntValue());\r
 160         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE().booleanValue());\r
 161         MultipartReplyAggregateCase messageCase = (MultipartReplyAggregateCase) builtByFactory.getMultipartReplyBody();\r
 162         MultipartReplyAggregate message = messageCase.getMultipartReplyAggregate();\r
 163         Assert.assertEquals("Wrong packet-count",\r
 164                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}), \r
 165                 message.getPacketCount());\r
 166         Assert.assertEquals("Wrong byte-count",\r
 167                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20}), \r
 168                 message.getByteCount());\r
 169         Assert.assertEquals("Wrong flow-count", 48, message.getFlowCount().intValue());\r
 170         Assert.assertTrue("Unread data", bb.readableBytes() == 0);\r
 171     }\r
 172     \r
 173     /**\r
 174      * Testing OF10StatsReplyMessageFactory (Table) for correct deserialization\r
 175      */\r
 176     @Test\r
 177     public void testTable() {\r
 178         ByteBuf bb = BufferHelper.buildBuffer("00 03 00 01 "\r
 179                 + "08 00 00 00 4A 41 4D 45 53 20 42 4F 4E 44 00 00 00 00 00 00 00 00 00 "\r
 180                 + "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 "\r
 181                 + "00 00 00 30 00 00 00 10 FF 01 01 01 01 01 01 01 FF 01 01 01 01 01 01 00");\r
 182 \r
 183         MultipartReplyMessage builtByFactory = BufferHelper.decodeV10(OF10StatsReplyMessageFactory.getInstance(), bb);\r
 184 \r
 185         BufferHelper.checkHeaderV10(builtByFactory);\r
 186         Assert.assertEquals("Wrong type", 0x03, builtByFactory.getType().getIntValue());\r
 187         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE());\r
 188 \r
 189         MultipartReplyTableCase messageCase = (MultipartReplyTableCase) builtByFactory.getMultipartReplyBody();\r
 190         MultipartReplyTable message = messageCase.getMultipartReplyTable();\r
 191         Assert.assertEquals("Wrong tableId", 8, message.getTableStats().get(0).getTableId().intValue());\r
 192         Assert.assertEquals("Wrong name", "JAMES BOND", message.getTableStats().get(0).getName());\r
 193         Assert.assertEquals("Wrong wildcards", new FlowWildcardsV10(false, false, false, false, false, false, false,\r
 194                 false, false, false), message.getTableStats().get(0).getWildcards());\r
 195         Assert.assertEquals("Wrong src-mask", 32, message.getTableStats().get(0).getNwSrcMask().intValue());\r
 196         Assert.assertEquals("Wrong dst-mask", 32, message.getTableStats().get(0).getNwDstMask().intValue());\r
 197         Assert.assertEquals("Wrong max-entries", 48, message.getTableStats().get(0).getMaxEntries().longValue());\r
 198         Assert.assertEquals("Wrong activeCount", 16, message.getTableStats().get(0).getActiveCount().longValue());\r
 199         Assert.assertEquals("Wrong lookupCount", \r
 200                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 201                 message.getTableStats().get(0).getLookupCount());\r
 202         Assert.assertEquals("Wrong matchedCount", \r
 203                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00}), \r
 204                 message.getTableStats().get(0).getMatchedCount());\r
 205         Assert.assertTrue("Unread data", bb.readableBytes() == 0);\r
 206     }\r
 207     \r
 208     /**\r
 209      * Testing OF10StatsReplyMessageFactory (Port) for correct deserialization\r
 210      */\r
 211     @Test\r
 212     public void testPort() {\r
 213         ByteBuf bb = BufferHelper.buildBuffer("00 04 00 01 "\r
 214                 + "00 FF 00 00 00 00 00 00 "\r
 215                 + "FF 01 01 01 01 01 01 01 FF 02 02 02 02 02 02 02 "\r
 216                 + "FF 02 03 02 03 02 03 02 FF 02 03 02 03 02 03 02 "\r
 217                 + "FF 02 03 02 03 02 03 02 FF 02 03 02 03 02 03 02 "\r
 218                 + "FF 02 03 02 03 02 03 02 FF 02 03 02 03 02 03 02 "\r
 219                 + "FF 02 03 02 03 02 03 02 FF 02 03 02 03 02 03 02 FF 02 03 02 03 02 03 02 "\r
 220                 + "FF 02 03 02 03 02 03 02 ");\r
 221 \r
 222         MultipartReplyMessage builtByFactory = BufferHelper.decodeV10(OF10StatsReplyMessageFactory.getInstance(), bb);\r
 223 \r
 224         BufferHelper.checkHeaderV10(builtByFactory);\r
 225         Assert.assertEquals("Wrong type", 0x04, builtByFactory.getType().getIntValue());\r
 226         Assert.assertEquals("Wrong flag", true, builtByFactory.getFlags().isOFPMPFREQMORE());\r
 227         MultipartReplyPortStatsCase messageCase = (MultipartReplyPortStatsCase) builtByFactory.getMultipartReplyBody();\r
 228         MultipartReplyPortStats message = messageCase.getMultipartReplyPortStats();\r
 229         Assert.assertEquals("Wrong portNo", 255, message.getPortStats().get(0).getPortNo().intValue());\r
 230         Assert.assertEquals("Wrong rxPackets", \r
 231                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}), \r
 232                 message.getPortStats().get(0).getRxPackets());\r
 233         Assert.assertEquals("Wrong txPackets", \r
 234                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02}), \r
 235                 message.getPortStats().get(0).getTxPackets());\r
 236         Assert.assertEquals("Wrong rxBytes", \r
 237                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 238                 message.getPortStats().get(0).getRxBytes());\r
 239         Assert.assertEquals("Wrong txBytes", \r
 240                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 241                 message.getPortStats().get(0).getTxBytes());\r
 242         Assert.assertEquals("Wrong rxDropped", \r
 243                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 244                 message.getPortStats().get(0).getRxDropped());\r
 245         Assert.assertEquals("Wrong txDropped", \r
 246                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 247                 message.getPortStats().get(0).getTxDropped());\r
 248         Assert.assertEquals("Wrong rxErrors", \r
 249                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 250                 message.getPortStats().get(0).getRxErrors());\r
 251         Assert.assertEquals("Wrong txErrors", \r
 252                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 253                 message.getPortStats().get(0).getTxErrors());\r
 254         Assert.assertEquals("Wrong rxFrameErr", \r
 255                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 256                 message.getPortStats().get(0).getRxFrameErr());\r
 257         Assert.assertEquals("Wrong rxOverErr", \r
 258                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 259                 message.getPortStats().get(0).getRxOverErr());\r
 260         Assert.assertEquals("Wrong rxCrcErr", \r
 261                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 262                 message.getPortStats().get(0).getRxCrcErr());\r
 263         Assert.assertEquals("Wrong collisions", \r
 264                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 265                 message.getPortStats().get(0).getCollisions());\r
 266         Assert.assertTrue("Unread data", bb.readableBytes() == 0);\r
 267     }\r
 268     \r
 269     /**\r
 270      * Testing OF10StatsReplyMessageFactory (Queue) for correct deserialization\r
 271      */\r
 272     @Test\r
 273     public void testQueue() {\r
 274         ByteBuf bb = BufferHelper.buildBuffer("00 05 00 00 "\r
 275                 + "00 FF 00 00 00 00 00 10 "\r
 276                 + "FF 02 03 02 03 02 03 02 "\r
 277                 + "FF 02 02 02 02 02 02 02 "\r
 278                 + "FF 02 03 02 03 02 03 02 ");\r
 279 \r
 280         MultipartReplyMessage builtByFactory = BufferHelper.decodeV10(OF10StatsReplyMessageFactory.getInstance(), bb);\r
 281 \r
 282         BufferHelper.checkHeaderV10(builtByFactory);\r
 283         Assert.assertEquals("Wrong type", 0x05, builtByFactory.getType().getIntValue());\r
 284         Assert.assertEquals("Wrong flag", false, builtByFactory.getFlags().isOFPMPFREQMORE());\r
 285         MultipartReplyQueueCase messageCase = (MultipartReplyQueueCase) builtByFactory.getMultipartReplyBody();\r
 286         MultipartReplyQueue message = messageCase.getMultipartReplyQueue();\r
 287         Assert.assertEquals("Wrong portNo", 255, message.getQueueStats().get(0).getPortNo().intValue());\r
 288         Assert.assertEquals("Wrong queueId", 16, message.getQueueStats().get(0).getQueueId().intValue());\r
 289         Assert.assertEquals("Wrong txBytes", \r
 290                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 291                 message.getQueueStats().get(0).getTxBytes());\r
 292         Assert.assertEquals("Wrong txPackets", \r
 293                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02}), \r
 294                 message.getQueueStats().get(0).getTxPackets());\r
 295         Assert.assertEquals("Wrong txErrors", \r
 296                 new BigInteger(1, new byte[]{(byte) 0xFF, 0x02, 0x03, 0x02, 0x03, 0x02, 0x03, 0x02}), \r
 297                 message.getQueueStats().get(0).getTxErrors());\r
 298         Assert.assertTrue("Unread data", bb.readableBytes() == 0);\r
 299     }\r
 300 \r
 301 }\r