senf/Packets/ParseHelpers.test.cc

   1 // $Id$
   2 //
   3 // Copyright (C) 2007
   4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
   5 //
   6 // The contents of this file are subject to the Fraunhofer FOKUS Public License
   7 // Version 1.0 (the "License"); you may not use this file except in compliance
   8 // with the License. You may obtain a copy of the License at
   9 // http://senf.berlios.de/license.html
  10 //
  11 // The Fraunhofer FOKUS Public License Version 1.0 is based on,
  12 // but modifies the Mozilla Public License Version 1.1.
  13 // See the full license text for the amendments.
  14 //
  15 // Software distributed under the License is distributed on an "AS IS" basis,
  16 // WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  17 // for the specific language governing rights and limitations under the License.
  18 //
  19 // The Original Code is Fraunhofer FOKUS code.
  20 //
  21 // The Initial Developer of the Original Code is Fraunhofer-Gesellschaft e.V.
  22 // (registered association), Hansastraße 27 c, 80686 Munich, Germany.
  23 // All Rights Reserved.
  24 //
  25 // Contributor(s):
  26 //   Stefan Bund <g0dil@berlios.de>
  27
  28 /** \file
  29     \brief ParseHelpers unit tests */
  30
  31 //#include "ParseHelpers.test.hh"
  32 //#include "ParseHelpers.test.ih"
  33
  34 // Custom includes
  35 #include "Packets.hh"
  36
  37 #include <senf/Utils/auto_unit_test.hh>
  38 #include <boost/test/test_tools.hpp>
  39
  40 #define prefix_
  41 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  42
  43 namespace {
  44
  45     struct FixedBaseParser : public senf::PacketParserBase
  46     {
  47 #       include SENF_FIXED_PARSER()
  48
  49         SENF_PARSER_FIELD        ( normalField          , senf::UInt16Parser );
  50         SENF_PARSER_FIELD_RO     ( roField              , senf::UInt16Parser );
  51
  52         SENF_PARSER_CUSTOM_FIELD ( customField          , int, 2             ) {
  53             return parse<senf::UInt16Parser>(customField_offset);
  54         }
  55
  56         SENF_PARSER_BITFIELD     ( signedBitfield       , 4, signed          );
  57         SENF_PARSER_BITFIELD     ( unsignedBitfield     , 3, unsigned        );
  58         SENF_PARSER_BITFIELD     ( boolBitfield         , 1, bool            );
  59
  60         SENF_PARSER_BITFIELD_RO  ( roSignedBitfield     , 4, signed          );
  61         SENF_PARSER_BITFIELD_RO  ( roUnsignedBitfield   , 3, unsigned        );
  62         SENF_PARSER_BITFIELD_RO  ( roBoolBitfield       , 1, bool            );
  63
  64         SENF_PARSER_LABEL( end );
  65         SENF_PARSER_GOTO( roField );
  66
  67         SENF_PARSER_FIELD        ( overlayOfRoField     , senf::Int16Parser  );
  68         SENF_PARSER_SKIP( 2 );
  69         SENF_PARSER_FIELD        ( overlayOfBitfield    , senf::UInt8Parser  );
  70
  71         SENF_PARSER_GOTO_OFFSET( 1 );
  72
  73         SENF_PARSER_PRIVATE_FIELD ( privLowbyteOfNormalField , senf::UInt8Parser  );
  74
  75         unsigned lowbyteOfNormalField() {
  76             return privLowbyteOfNormalField();
  77         }
  78
  79         SENF_PARSER_GOTO( end );
  80
  81         SENF_PARSER_FINALIZE( FixedBaseParser );
  82     };
  83
  84     struct FixedDerivedParser : public FixedBaseParser
  85     {
  86 #       include SENF_FIXED_PARSER()
  87
  88         SENF_PARSER_INHERIT( FixedBaseParser );
  89
  90         SENF_PARSER_FIELD        ( derivedField         , senf::UInt16Parser );
  91
  92         SENF_PARSER_LABEL( end );
  93         SENF_PARSER_GOTO( signedBitfield );
  94
  95         SENF_PARSER_FIELD        ( anotherOverlay       , senf::UInt16Parser );
  96
  97         SENF_PARSER_GOTO( end );
  98
  99         SENF_PARSER_FINALIZE( FixedDerivedParser )
 100     };
 101 }
 102
 103 SENF_AUTO_UNIT_TEST(fixedParser)
 104 {
 105     unsigned char data[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x83, 0x84, 0x07, 0x08 };
 106
 107     senf::DataPacket p (senf::DataPacket::create(data));
 108
 109     FixedBaseParser baseParser (p.data().begin(), &p.data());
 110
 111     BOOST_CHECK_EQUAL( FixedBaseParser::fixed_bytes+0, 8u );
 112
 113     BOOST_CHECK_EQUAL (   baseParser.normalField()          , 0x0102u );
 114     BOOST_CHECK_EQUAL (   baseParser.roField()              , 0x0304u );
 115     BOOST_CHECK_EQUAL (   baseParser.customField()          , 0x0506  );
 116
 117     BOOST_CHECK_EQUAL (   baseParser.signedBitfield()       , -8      );
 118     BOOST_CHECK_EQUAL (   baseParser.unsignedBitfield()     , 1u      );
 119     BOOST_CHECK       (   baseParser.boolBitfield()                   );
 120
 121     BOOST_CHECK_EQUAL (   baseParser.roSignedBitfield()     , -8      );
 122     BOOST_CHECK_EQUAL (   baseParser.roUnsignedBitfield()   , 2u      );
 123     BOOST_CHECK       ( ! baseParser.roBoolBitfield()                 );
 124
 125     BOOST_CHECK_EQUAL (   baseParser.overlayOfRoField()     , 0x0304  );
 126     BOOST_CHECK_EQUAL (   baseParser.overlayOfBitfield()    , 0x83u   );
 127     BOOST_CHECK_EQUAL (   baseParser.lowbyteOfNormalField() , 0x02u   );
 128
 129     FixedDerivedParser derivedParser (p.data().begin(), &p.data());
 130
 131     BOOST_CHECK_EQUAL( FixedDerivedParser::fixed_bytes+0, 10u );
 132
 133     BOOST_CHECK_EQUAL (   derivedParser.normalField()          , 0x0102u );
 134     BOOST_CHECK_EQUAL (   derivedParser.roField()              , 0x0304u );
 135     BOOST_CHECK_EQUAL (   derivedParser.customField()          , 0x0506  );
 136
 137     BOOST_CHECK_EQUAL (   derivedParser.signedBitfield()       , -8      );
 138     BOOST_CHECK_EQUAL (   derivedParser.unsignedBitfield()     , 1u      );
 139     BOOST_CHECK       (   derivedParser.boolBitfield()                   );
 140
 141     BOOST_CHECK_EQUAL (   derivedParser.roSignedBitfield()     , -8      );
 142     BOOST_CHECK_EQUAL (   derivedParser.roUnsignedBitfield()   , 2u      );
 143     BOOST_CHECK       ( ! derivedParser.roBoolBitfield()                 );
 144
 145     BOOST_CHECK_EQUAL (   derivedParser.overlayOfRoField()     , 0x0304  );
 146     BOOST_CHECK_EQUAL (   derivedParser.overlayOfBitfield()    , 0x83u   );
 147     BOOST_CHECK_EQUAL (   derivedParser.lowbyteOfNormalField() , 0x02u   );
 148
 149     BOOST_CHECK_EQUAL (   derivedParser.derivedField()         , 0x0708u );
 150     BOOST_CHECK_EQUAL (   derivedParser.anotherOverlay()       , 0x8384u );
 151 }
 152
 153 namespace {
 154
 155     struct VariableBaseParser : public senf::PacketParserBase
 156     {
 157 #       include SENF_PARSER()
 158
 159         SENF_PARSER_FIELD        ( normalField              , senf::UInt16Parser );
 160         SENF_PARSER_FIELD_RO     ( roField                  , senf::UInt16Parser );
 161
 162         SENF_PARSER_CUSTOM_FIELD ( customField              , int, 2, 2          ) {
 163             return parse<senf::UInt16Parser>(customField_offset());
 164         }
 165
 166         SENF_PARSER_BITFIELD      ( signedBitfield           , 4, signed          );
 167         SENF_PARSER_BITFIELD      ( unsignedBitfield         , 3, unsigned        );
 168         SENF_PARSER_BITFIELD      ( boolBitfield             , 1, bool            );
 169
 170         SENF_PARSER_BITFIELD_RO   ( roSignedBitfield         , 4, signed          );
 171         SENF_PARSER_BITFIELD_RO   ( roUnsignedBitfield       , 3, unsigned        );
 172         SENF_PARSER_BITFIELD_RO   ( roBoolBitfield           , 1, bool            );
 173
 174         SENF_PARSER_LABEL( end );
 175         SENF_PARSER_GOTO( roField );
 176
 177         SENF_PARSER_FIELD         ( overlayOfRoField         , senf::Int16Parser  );
 178         SENF_PARSER_SKIP( 2, 2 );
 179         SENF_PARSER_FIELD         ( overlayOfBitfield        , senf::UInt8Parser  );
 180
 181         SENF_PARSER_GOTO_OFFSET( 1, 1 );
 182
 183         SENF_PARSER_PRIVATE_FIELD ( privLowbyteOfNormalField , senf::UInt8Parser  );
 184
 185         unsigned lowbyteOfNormalField() {
 186             return privLowbyteOfNormalField();
 187         }
 188
 189         SENF_PARSER_GOTO( end );
 190
 191         SENF_PARSER_FINALIZE( VariableBaseParser );
 192     };
 193
 194     struct VariableDerivedParser : public VariableBaseParser
 195     {
 196 #       include SENF_PARSER()
 197
 198         SENF_PARSER_INHERIT( VariableBaseParser );
 199
 200         SENF_PARSER_FIELD        ( derivedField         , senf::UInt16Parser );
 201
 202         SENF_PARSER_LABEL( end );
 203         SENF_PARSER_GOTO( signedBitfield );
 204
 205         SENF_PARSER_FIELD        ( anotherOverlay       , senf::UInt16Parser );
 206
 207         SENF_PARSER_GOTO( end );
 208
 209         SENF_PARSER_FINALIZE( VariableDerivedParser );
 210     };
 211 }
 212
 213 SENF_AUTO_UNIT_TEST(variableParser)
 214 {
 215     unsigned char data[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x83, 0x84, 0x07, 0x08 };
 216
 217     senf::DataPacket p (senf::DataPacket::create(data));
 218
 219     VariableBaseParser baseParser (p.data().begin(), &p.data());
 220
 221     BOOST_CHECK_EQUAL ( senf::bytes(baseParser), 8u );
 222
 223     BOOST_CHECK_EQUAL (   baseParser.normalField()          , 0x0102u );
 224     BOOST_CHECK_EQUAL (   baseParser.roField()              , 0x0304u );
 225     BOOST_CHECK_EQUAL (   baseParser.customField()          , 0x0506  );
 226
 227     BOOST_CHECK_EQUAL (   baseParser.signedBitfield()       , -8      );
 228     BOOST_CHECK_EQUAL (   baseParser.unsignedBitfield()     , 1u      );
 229     BOOST_CHECK       (   baseParser.boolBitfield()                   );
 230
 231     BOOST_CHECK_EQUAL (   baseParser.roSignedBitfield()     , -8      );
 232     BOOST_CHECK_EQUAL (   baseParser.roUnsignedBitfield()   , 2u      );
 233     BOOST_CHECK       ( ! baseParser.roBoolBitfield()                 );
 234
 235     BOOST_CHECK_EQUAL (   baseParser.overlayOfRoField()     , 0x0304  );
 236     BOOST_CHECK_EQUAL (   baseParser.overlayOfBitfield()    , 0x83u   );
 237     BOOST_CHECK_EQUAL (   baseParser.lowbyteOfNormalField() , 0x02u   );
 238
 239     VariableDerivedParser derivedParser (p.data().begin(), &p.data());
 240
 241     BOOST_CHECK_EQUAL ( senf::bytes(derivedParser), 10u );
 242
 243     BOOST_CHECK_EQUAL (   derivedParser.normalField()          , 0x0102u );
 244     BOOST_CHECK_EQUAL (   derivedParser.roField()              , 0x0304u );
 245     BOOST_CHECK_EQUAL (   derivedParser.customField()          , 0x0506  );
 246
 247     BOOST_CHECK_EQUAL (   derivedParser.signedBitfield()       , -8      );
 248     BOOST_CHECK_EQUAL (   derivedParser.unsignedBitfield()     , 1u      );
 249     BOOST_CHECK       (   derivedParser.boolBitfield()                   );
 250
 251     BOOST_CHECK_EQUAL (   derivedParser.roSignedBitfield()     , -8      );
 252     BOOST_CHECK_EQUAL (   derivedParser.roUnsignedBitfield()   , 2u      );
 253     BOOST_CHECK       ( ! derivedParser.roBoolBitfield()                 );
 254
 255     BOOST_CHECK_EQUAL (   derivedParser.overlayOfRoField()     , 0x0304  );
 256     BOOST_CHECK_EQUAL (   derivedParser.overlayOfBitfield()    , 0x83u   );
 257     BOOST_CHECK_EQUAL (   derivedParser.lowbyteOfNormalField() , 0x02u   );
 258
 259     BOOST_CHECK_EQUAL (   derivedParser.derivedField()         , 0x0708u );
 260     BOOST_CHECK_EQUAL (   derivedParser.anotherOverlay()       , 0x8384u );
 261 }
 262
 263 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 264 #undef prefix_
 265
 266 \f
 267 // Local Variables:
 268 // mode: c++
 269 // fill-column: 100
 270 // comment-column: 40
 271 // c-file-style: "senf"
 272 // indent-tabs-mode: nil
 273 // ispell-local-dictionary: "american"
 274 // compile-command: "scons -u test"
 275 // End: