Packets/ParseHelpers.test.cc

   1 // $Id$
   2 //
   3 // Copyright (C) 2007
   4 // Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
   5 // Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
   6 //     Stefan Bund <g0dil@berlios.de>
   7 //
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 2 of the License, or
  11 // (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the
  20 // Free Software Foundation, Inc.,
  21 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22
  23 /** \file
  24     \brief ParseHelpers.test unit tests */
  25
  26 //#include "ParseHelpers.test.hh"
  27 //#include "ParseHelpers.test.ih"
  28
  29 // Custom includes
  30 #include "Packets.hh"
  31
  32 #include <boost/test/auto_unit_test.hpp>
  33 #include <boost/test/test_tools.hpp>
  34
  35 #define prefix_
  36 ///////////////////////////////cc.p////////////////////////////////////////
  37
  38 namespace {
  39
  40     struct FixedBaseParser : public senf::PacketParserBase
  41     {
  42 #       include SENF_FIXED_PARSER()
  43
  44         SENF_PARSE_FIELD        ( normalField          , senf::Parse_UInt16 );
  45         SENF_PARSE_FIELD_RO     ( roField              , senf::Parse_UInt16 );
  46
  47         SENF_PARSE_CUSTOM_FIELD ( customField          , int, 2             ) {
  48             return parse<senf::Parse_UInt16>(customField_offset);
  49         }
  50
  51         SENF_PARSE_BITFIELD     ( signedBitfield       , 4, signed          );
  52         SENF_PARSE_BITFIELD     ( unsignedBitfield     , 3, unsigned        );
  53         SENF_PARSE_BITFIELD     ( boolBitfield         , 1, bool            );
  54
  55         SENF_PARSE_BITFIELD_RO  ( roSignedBitfield     , 4, signed          );
  56         SENF_PARSE_BITFIELD_RO  ( roUnsignedBitfield   , 3, unsigned        );
  57         SENF_PARSE_BITFIELD_RO  ( roBoolBitfield       , 1, bool            );
  58
  59         SENF_PARSER_LABEL( end );
  60         SENF_PARSER_GOTO( roField );
  61
  62         SENF_PARSE_FIELD        ( overlayOfRoField     , senf::Parse_Int16  );
  63         SENF_PARSER_SKIP( 2 );
  64         SENF_PARSE_FIELD        ( overlayOfBitfield    , senf::Parse_UInt8  );
  65
  66         SENF_PARSER_GOTO_OFFSET( 1 );
  67
  68         SENF_PARSE_FIELD        ( lowbyteOfNormalField , senf::Parse_UInt8  );
  69
  70         SENF_PARSER_GOTO( end );
  71
  72         SENF_PARSER_FINALIZE( FixedBaseParser );
  73     };
  74
  75     struct FixedDerivedParser : public FixedBaseParser
  76     {
  77 #       include SENF_FIXED_PARSER()
  78
  79         SENF_PARSER_INHERIT( FixedBaseParser );
  80
  81         SENF_PARSE_FIELD        ( derivedField         , senf::Parse_UInt16 );
  82
  83         SENF_PARSER_LABEL( end );
  84         SENF_PARSER_GOTO( signedBitfield );
  85
  86         SENF_PARSE_FIELD        ( anotherOverlay       , senf::Parse_UInt16 );
  87
  88         SENF_PARSER_GOTO( end );
  89
  90         SENF_PARSER_FINALIZE( FixedDerivedParser )
  91     };
  92 }
  93
  94 BOOST_AUTO_UNIT_TEST(fixedParser)
  95 {
  96     unsigned char data[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x83, 0x84, 0x07, 0x08 };
  97
  98     senf::DataPacket p (senf::DataPacket::create(data));
  99
 100     FixedBaseParser baseParser (p.data().begin(), &p.data());
 101
 102     BOOST_CHECK_EQUAL( FixedBaseParser::fixed_bytes+0, 8u );
 103
 104     BOOST_CHECK_EQUAL (   baseParser.normalField()          , 0x0102u );
 105     BOOST_CHECK_EQUAL (   baseParser.roField()              , 0x0304u );
 106     BOOST_CHECK_EQUAL (   baseParser.customField()          , 0x0506  );
 107
 108     BOOST_CHECK_EQUAL (   baseParser.signedBitfield()       , -8      );
 109     BOOST_CHECK_EQUAL (   baseParser.unsignedBitfield()     , 1u      );
 110     BOOST_CHECK       (   baseParser.boolBitfield()                   );
 111
 112     BOOST_CHECK_EQUAL (   baseParser.roSignedBitfield()     , -8      );
 113     BOOST_CHECK_EQUAL (   baseParser.roUnsignedBitfield()   , 2u      );
 114     BOOST_CHECK       ( ! baseParser.roBoolBitfield()                 );
 115
 116     BOOST_CHECK_EQUAL (   baseParser.overlayOfRoField()     , 0x0304  );
 117     BOOST_CHECK_EQUAL (   baseParser.overlayOfBitfield()    , 0x83u   );
 118     BOOST_CHECK_EQUAL (   baseParser.lowbyteOfNormalField() , 0x02u   );
 119
 120     FixedDerivedParser derivedParser (p.data().begin(), &p.data());
 121
 122     BOOST_CHECK_EQUAL( FixedDerivedParser::fixed_bytes+0, 10u );
 123
 124     BOOST_CHECK_EQUAL (   derivedParser.normalField()          , 0x0102u );
 125     BOOST_CHECK_EQUAL (   derivedParser.roField()              , 0x0304u );
 126     BOOST_CHECK_EQUAL (   derivedParser.customField()          , 0x0506  );
 127
 128     BOOST_CHECK_EQUAL (   derivedParser.signedBitfield()       , -8      );
 129     BOOST_CHECK_EQUAL (   derivedParser.unsignedBitfield()     , 1u      );
 130     BOOST_CHECK       (   derivedParser.boolBitfield()                   );
 131
 132     BOOST_CHECK_EQUAL (   derivedParser.roSignedBitfield()     , -8      );
 133     BOOST_CHECK_EQUAL (   derivedParser.roUnsignedBitfield()   , 2u      );
 134     BOOST_CHECK       ( ! derivedParser.roBoolBitfield()                 );
 135
 136     BOOST_CHECK_EQUAL (   derivedParser.overlayOfRoField()     , 0x0304  );
 137     BOOST_CHECK_EQUAL (   derivedParser.overlayOfBitfield()    , 0x83u   );
 138     BOOST_CHECK_EQUAL (   derivedParser.lowbyteOfNormalField() , 0x02u   );
 139
 140     BOOST_CHECK_EQUAL (   derivedParser.derivedField()         , 0x0708u );
 141     BOOST_CHECK_EQUAL (   derivedParser.anotherOverlay()       , 0x8384u );
 142 }
 143
 144 namespace {
 145
 146     struct VariableBaseParser : public senf::PacketParserBase
 147     {
 148 #       include SENF_PARSER()
 149
 150         SENF_PARSE_FIELD        ( normalField          , senf::Parse_UInt16 );
 151         SENF_PARSE_FIELD_RO     ( roField              , senf::Parse_UInt16 );
 152
 153         SENF_PARSE_CUSTOM_FIELD ( customField          , int, 2, 2          ) {
 154             return parse<senf::Parse_UInt16>(customField_offset());
 155         }
 156
 157         SENF_PARSE_BITFIELD     ( signedBitfield       , 4, signed          );
 158         SENF_PARSE_BITFIELD     ( unsignedBitfield     , 3, unsigned        );
 159         SENF_PARSE_BITFIELD     ( boolBitfield         , 1, bool            );
 160
 161         SENF_PARSE_BITFIELD_RO  ( roSignedBitfield     , 4, signed          );
 162         SENF_PARSE_BITFIELD_RO  ( roUnsignedBitfield   , 3, unsigned        );
 163         SENF_PARSE_BITFIELD_RO  ( roBoolBitfield       , 1, bool            );
 164
 165         SENF_PARSER_LABEL( end );
 166         SENF_PARSER_GOTO( roField );
 167
 168         SENF_PARSE_FIELD        ( overlayOfRoField     , senf::Parse_Int16  );
 169         SENF_PARSER_SKIP( 2, 2 );
 170         SENF_PARSE_FIELD        ( overlayOfBitfield    , senf::Parse_UInt8  );
 171
 172         SENF_PARSER_GOTO_OFFSET( 1, 1 );
 173
 174         SENF_PARSE_FIELD        ( lowbyteOfNormalField , senf::Parse_UInt8  );
 175
 176         SENF_PARSER_GOTO( end );
 177
 178         SENF_PARSER_FINALIZE( VariableBaseParser );
 179     };
 180
 181     struct VariableDerivedParser : public VariableBaseParser
 182     {
 183 #       include SENF_PARSER()
 184
 185         SENF_PARSER_INHERIT( VariableBaseParser );
 186
 187         SENF_PARSE_FIELD        ( derivedField         , senf::Parse_UInt16 );
 188
 189         SENF_PARSER_LABEL( end );
 190         SENF_PARSER_GOTO( signedBitfield );
 191
 192         SENF_PARSE_FIELD        ( anotherOverlay       , senf::Parse_UInt16 );
 193
 194         SENF_PARSER_GOTO( end );
 195
 196         SENF_PARSER_FINALIZE( VariableDerivedParser );
 197     };
 198 }
 199
 200 BOOST_AUTO_UNIT_TEST(variableParser)
 201 {
 202     unsigned char data[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x83, 0x84, 0x07, 0x08 };
 203
 204     senf::DataPacket p (senf::DataPacket::create(data));
 205
 206     VariableBaseParser baseParser (p.data().begin(), &p.data());
 207
 208     BOOST_CHECK_EQUAL ( senf::bytes(baseParser), 8u );
 209
 210     BOOST_CHECK_EQUAL (   baseParser.normalField()          , 0x0102u );
 211     BOOST_CHECK_EQUAL (   baseParser.roField()              , 0x0304u );
 212     BOOST_CHECK_EQUAL (   baseParser.customField()          , 0x0506  );
 213
 214     BOOST_CHECK_EQUAL (   baseParser.signedBitfield()       , -8      );
 215     BOOST_CHECK_EQUAL (   baseParser.unsignedBitfield()     , 1u      );
 216     BOOST_CHECK       (   baseParser.boolBitfield()                   );
 217
 218     BOOST_CHECK_EQUAL (   baseParser.roSignedBitfield()     , -8      );
 219     BOOST_CHECK_EQUAL (   baseParser.roUnsignedBitfield()   , 2u      );
 220     BOOST_CHECK       ( ! baseParser.roBoolBitfield()                 );
 221
 222     BOOST_CHECK_EQUAL (   baseParser.overlayOfRoField()     , 0x0304  );
 223     BOOST_CHECK_EQUAL (   baseParser.overlayOfBitfield()    , 0x83u   );
 224     BOOST_CHECK_EQUAL (   baseParser.lowbyteOfNormalField() , 0x02u   );
 225
 226     VariableDerivedParser derivedParser (p.data().begin(), &p.data());
 227
 228     BOOST_CHECK_EQUAL ( senf::bytes(derivedParser), 10u );
 229
 230     BOOST_CHECK_EQUAL (   derivedParser.normalField()          , 0x0102u );
 231     BOOST_CHECK_EQUAL (   derivedParser.roField()              , 0x0304u );
 232     BOOST_CHECK_EQUAL (   derivedParser.customField()          , 0x0506  );
 233
 234     BOOST_CHECK_EQUAL (   derivedParser.signedBitfield()       , -8      );
 235     BOOST_CHECK_EQUAL (   derivedParser.unsignedBitfield()     , 1u      );
 236     BOOST_CHECK       (   derivedParser.boolBitfield()                   );
 237
 238     BOOST_CHECK_EQUAL (   derivedParser.roSignedBitfield()     , -8      );
 239     BOOST_CHECK_EQUAL (   derivedParser.roUnsignedBitfield()   , 2u      );
 240     BOOST_CHECK       ( ! derivedParser.roBoolBitfield()                 );
 241
 242     BOOST_CHECK_EQUAL (   derivedParser.overlayOfRoField()     , 0x0304  );
 243     BOOST_CHECK_EQUAL (   derivedParser.overlayOfBitfield()    , 0x83u   );
 244     BOOST_CHECK_EQUAL (   derivedParser.lowbyteOfNormalField() , 0x02u   );
 245
 246     BOOST_CHECK_EQUAL (   derivedParser.derivedField()         , 0x0708u );
 247     BOOST_CHECK_EQUAL (   derivedParser.anotherOverlay()       , 0x8384u );
 248 }
 249
 250 ///////////////////////////////cc.e////////////////////////////////////////
 251 #undef prefix_
 252
 253 \f
 254 // Local Variables:
 255 // mode: c++
 256 // fill-column: 100
 257 // comment-column: 40
 258 // c-file-style: "senf"
 259 // indent-tabs-mode: nil
 260 // ispell-local-dictionary: "american"
 261 // compile-command: "scons -u test"
 262 // End: