senf/Packets/ParseHelpers.test.cc

   1 // $Id$
   2 //
   3 // Copyright (C) 2007
   4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
   5 // Competence Center NETwork research (NET), St. Augustin, GERMANY
   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 unit tests */
  25
  26 //#include "ParseHelpers.test.hh"
  27 //#include "ParseHelpers.test.ih"
  28
  29 // Custom includes
  30 #include "Packets.hh"
  31
  32 #include <senf/Utils/auto_unit_test.hh>
  33 #include <boost/test/test_tools.hpp>
  34
  35 #define prefix_
  36 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  37
  38 namespace {
  39
  40     struct FixedBaseParser : public senf::PacketParserBase
  41     {
  42 #       include SENF_FIXED_PARSER()
  43
  44         SENF_PARSER_FIELD        ( normalField          , senf::UInt16Parser );
  45         SENF_PARSER_FIELD_RO     ( roField              , senf::UInt16Parser );
  46
  47         SENF_PARSER_CUSTOM_FIELD ( customField          , int, 2             ) {
  48             return parse<senf::UInt16Parser>(customField_offset);
  49         }
  50
  51         SENF_PARSER_BITFIELD     ( signedBitfield       , 4, signed          );
  52         SENF_PARSER_BITFIELD     ( unsignedBitfield     , 3, unsigned        );
  53         SENF_PARSER_BITFIELD     ( boolBitfield         , 1, bool            );
  54
  55         SENF_PARSER_BITFIELD_RO  ( roSignedBitfield     , 4, signed          );
  56         SENF_PARSER_BITFIELD_RO  ( roUnsignedBitfield   , 3, unsigned        );
  57         SENF_PARSER_BITFIELD_RO  ( roBoolBitfield       , 1, bool            );
  58
  59         SENF_PARSER_LABEL( end );
  60         SENF_PARSER_GOTO( roField );
  61
  62         SENF_PARSER_FIELD        ( overlayOfRoField     , senf::Int16Parser  );
  63         SENF_PARSER_SKIP( 2 );
  64         SENF_PARSER_FIELD        ( overlayOfBitfield    , senf::UInt8Parser  );
  65
  66         SENF_PARSER_GOTO_OFFSET( 1 );
  67
  68         SENF_PARSER_PRIVATE_FIELD ( privLowbyteOfNormalField , senf::UInt8Parser  );
  69
  70         unsigned lowbyteOfNormalField() {
  71             return privLowbyteOfNormalField();
  72         }
  73
  74         SENF_PARSER_GOTO( end );
  75
  76         SENF_PARSER_FINALIZE( FixedBaseParser );
  77     };
  78
  79     struct FixedDerivedParser : public FixedBaseParser
  80     {
  81 #       include SENF_FIXED_PARSER()
  82
  83         SENF_PARSER_INHERIT( FixedBaseParser );
  84
  85         SENF_PARSER_FIELD        ( derivedField         , senf::UInt16Parser );
  86
  87         SENF_PARSER_LABEL( end );
  88         SENF_PARSER_GOTO( signedBitfield );
  89
  90         SENF_PARSER_FIELD        ( anotherOverlay       , senf::UInt16Parser );
  91
  92         SENF_PARSER_GOTO( end );
  93
  94         SENF_PARSER_FINALIZE( FixedDerivedParser )
  95     };
  96 }
  97
  98 SENF_AUTO_UNIT_TEST(fixedParser)
  99 {
 100     unsigned char data[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x83, 0x84, 0x07, 0x08 };
 101
 102     senf::DataPacket p (senf::DataPacket::create(data));
 103
 104     FixedBaseParser baseParser (p.data().begin(), &p.data());
 105
 106     BOOST_CHECK_EQUAL( FixedBaseParser::fixed_bytes+0, 8u );
 107
 108     BOOST_CHECK_EQUAL (   baseParser.normalField()          , 0x0102u );
 109     BOOST_CHECK_EQUAL (   baseParser.roField()              , 0x0304u );
 110     BOOST_CHECK_EQUAL (   baseParser.customField()          , 0x0506  );
 111
 112     BOOST_CHECK_EQUAL (   baseParser.signedBitfield()       , -8      );
 113     BOOST_CHECK_EQUAL (   baseParser.unsignedBitfield()     , 1u      );
 114     BOOST_CHECK       (   baseParser.boolBitfield()                   );
 115
 116     BOOST_CHECK_EQUAL (   baseParser.roSignedBitfield()     , -8      );
 117     BOOST_CHECK_EQUAL (   baseParser.roUnsignedBitfield()   , 2u      );
 118     BOOST_CHECK       ( ! baseParser.roBoolBitfield()                 );
 119
 120     BOOST_CHECK_EQUAL (   baseParser.overlayOfRoField()     , 0x0304  );
 121     BOOST_CHECK_EQUAL (   baseParser.overlayOfBitfield()    , 0x83u   );
 122     BOOST_CHECK_EQUAL (   baseParser.lowbyteOfNormalField() , 0x02u   );
 123
 124     FixedDerivedParser derivedParser (p.data().begin(), &p.data());
 125
 126     BOOST_CHECK_EQUAL( FixedDerivedParser::fixed_bytes+0, 10u );
 127
 128     BOOST_CHECK_EQUAL (   derivedParser.normalField()          , 0x0102u );
 129     BOOST_CHECK_EQUAL (   derivedParser.roField()              , 0x0304u );
 130     BOOST_CHECK_EQUAL (   derivedParser.customField()          , 0x0506  );
 131
 132     BOOST_CHECK_EQUAL (   derivedParser.signedBitfield()       , -8      );
 133     BOOST_CHECK_EQUAL (   derivedParser.unsignedBitfield()     , 1u      );
 134     BOOST_CHECK       (   derivedParser.boolBitfield()                   );
 135
 136     BOOST_CHECK_EQUAL (   derivedParser.roSignedBitfield()     , -8      );
 137     BOOST_CHECK_EQUAL (   derivedParser.roUnsignedBitfield()   , 2u      );
 138     BOOST_CHECK       ( ! derivedParser.roBoolBitfield()                 );
 139
 140     BOOST_CHECK_EQUAL (   derivedParser.overlayOfRoField()     , 0x0304  );
 141     BOOST_CHECK_EQUAL (   derivedParser.overlayOfBitfield()    , 0x83u   );
 142     BOOST_CHECK_EQUAL (   derivedParser.lowbyteOfNormalField() , 0x02u   );
 143
 144     BOOST_CHECK_EQUAL (   derivedParser.derivedField()         , 0x0708u );
 145     BOOST_CHECK_EQUAL (   derivedParser.anotherOverlay()       , 0x8384u );
 146 }
 147
 148 namespace {
 149
 150     struct VariableBaseParser : public senf::PacketParserBase
 151     {
 152 #       include SENF_PARSER()
 153
 154         SENF_PARSER_FIELD        ( normalField              , senf::UInt16Parser );
 155         SENF_PARSER_FIELD_RO     ( roField                  , senf::UInt16Parser );
 156
 157         SENF_PARSER_CUSTOM_FIELD ( customField              , int, 2, 2          ) {
 158             return parse<senf::UInt16Parser>(customField_offset());
 159         }
 160
 161         SENF_PARSER_BITFIELD      ( signedBitfield           , 4, signed          );
 162         SENF_PARSER_BITFIELD      ( unsignedBitfield         , 3, unsigned        );
 163         SENF_PARSER_BITFIELD      ( boolBitfield             , 1, bool            );
 164
 165         SENF_PARSER_BITFIELD_RO   ( roSignedBitfield         , 4, signed          );
 166         SENF_PARSER_BITFIELD_RO   ( roUnsignedBitfield       , 3, unsigned        );
 167         SENF_PARSER_BITFIELD_RO   ( roBoolBitfield           , 1, bool            );
 168
 169         SENF_PARSER_LABEL( end );
 170         SENF_PARSER_GOTO( roField );
 171
 172         SENF_PARSER_FIELD         ( overlayOfRoField         , senf::Int16Parser  );
 173         SENF_PARSER_SKIP( 2, 2 );
 174         SENF_PARSER_FIELD         ( overlayOfBitfield        , senf::UInt8Parser  );
 175
 176         SENF_PARSER_GOTO_OFFSET( 1, 1 );
 177
 178         SENF_PARSER_PRIVATE_FIELD ( privLowbyteOfNormalField , senf::UInt8Parser  );
 179
 180         unsigned lowbyteOfNormalField() {
 181             return privLowbyteOfNormalField();
 182         }
 183
 184         SENF_PARSER_GOTO( end );
 185
 186         SENF_PARSER_FINALIZE( VariableBaseParser );
 187     };
 188
 189     struct VariableDerivedParser : public VariableBaseParser
 190     {
 191 #       include SENF_PARSER()
 192
 193         SENF_PARSER_INHERIT( VariableBaseParser );
 194
 195         SENF_PARSER_FIELD        ( derivedField         , senf::UInt16Parser );
 196
 197         SENF_PARSER_LABEL( end );
 198         SENF_PARSER_GOTO( signedBitfield );
 199
 200         SENF_PARSER_FIELD        ( anotherOverlay       , senf::UInt16Parser );
 201
 202         SENF_PARSER_GOTO( end );
 203
 204         SENF_PARSER_FINALIZE( VariableDerivedParser );
 205     };
 206 }
 207
 208 SENF_AUTO_UNIT_TEST(variableParser)
 209 {
 210     unsigned char data[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x83, 0x84, 0x07, 0x08 };
 211
 212     senf::DataPacket p (senf::DataPacket::create(data));
 213
 214     VariableBaseParser baseParser (p.data().begin(), &p.data());
 215
 216     BOOST_CHECK_EQUAL ( senf::bytes(baseParser), 8u );
 217
 218     BOOST_CHECK_EQUAL (   baseParser.normalField()          , 0x0102u );
 219     BOOST_CHECK_EQUAL (   baseParser.roField()              , 0x0304u );
 220     BOOST_CHECK_EQUAL (   baseParser.customField()          , 0x0506  );
 221
 222     BOOST_CHECK_EQUAL (   baseParser.signedBitfield()       , -8      );
 223     BOOST_CHECK_EQUAL (   baseParser.unsignedBitfield()     , 1u      );
 224     BOOST_CHECK       (   baseParser.boolBitfield()                   );
 225
 226     BOOST_CHECK_EQUAL (   baseParser.roSignedBitfield()     , -8      );
 227     BOOST_CHECK_EQUAL (   baseParser.roUnsignedBitfield()   , 2u      );
 228     BOOST_CHECK       ( ! baseParser.roBoolBitfield()                 );
 229
 230     BOOST_CHECK_EQUAL (   baseParser.overlayOfRoField()     , 0x0304  );
 231     BOOST_CHECK_EQUAL (   baseParser.overlayOfBitfield()    , 0x83u   );
 232     BOOST_CHECK_EQUAL (   baseParser.lowbyteOfNormalField() , 0x02u   );
 233
 234     VariableDerivedParser derivedParser (p.data().begin(), &p.data());
 235
 236     BOOST_CHECK_EQUAL ( senf::bytes(derivedParser), 10u );
 237
 238     BOOST_CHECK_EQUAL (   derivedParser.normalField()          , 0x0102u );
 239     BOOST_CHECK_EQUAL (   derivedParser.roField()              , 0x0304u );
 240     BOOST_CHECK_EQUAL (   derivedParser.customField()          , 0x0506  );
 241
 242     BOOST_CHECK_EQUAL (   derivedParser.signedBitfield()       , -8      );
 243     BOOST_CHECK_EQUAL (   derivedParser.unsignedBitfield()     , 1u      );
 244     BOOST_CHECK       (   derivedParser.boolBitfield()                   );
 245
 246     BOOST_CHECK_EQUAL (   derivedParser.roSignedBitfield()     , -8      );
 247     BOOST_CHECK_EQUAL (   derivedParser.roUnsignedBitfield()   , 2u      );
 248     BOOST_CHECK       ( ! derivedParser.roBoolBitfield()                 );
 249
 250     BOOST_CHECK_EQUAL (   derivedParser.overlayOfRoField()     , 0x0304  );
 251     BOOST_CHECK_EQUAL (   derivedParser.overlayOfBitfield()    , 0x83u   );
 252     BOOST_CHECK_EQUAL (   derivedParser.lowbyteOfNormalField() , 0x02u   );
 253
 254     BOOST_CHECK_EQUAL (   derivedParser.derivedField()         , 0x0708u );
 255     BOOST_CHECK_EQUAL (   derivedParser.anotherOverlay()       , 0x8384u );
 256 }
 257
 258 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 259 #undef prefix_
 260
 261 \f
 262 // Local Variables:
 263 // mode: c++
 264 // fill-column: 100
 265 // comment-column: 40
 266 // c-file-style: "senf"
 267 // indent-tabs-mode: nil
 268 // ispell-local-dictionary: "american"
 269 // compile-command: "scons -u test"
 270 // End: