senf/Packets/VectorParser.test.cc

   1 // $Id$
   2 //
   3 // Copyright (C) 2006
   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 VectorParser unit tests */
  25
  26 //#include "VectorParser.test.hh"
  27 //#include "VectorParser.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 #include <boost/assign.hpp>
  35
  36 #define prefix_
  37 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  38
  39 namespace {
  40     struct VoidPacket : public senf::PacketTypeBase
  41     {};
  42 }
  43
  44 SENF_AUTO_UNIT_TEST(VectorParser)
  45 {
  46     unsigned char data[] = { 0x03,                                   // size
  47                              0x10, 0x11,  0x12, 0x13,  0x14, 0x15,   // data
  48                              0x20, 0x21,  0x22, 0x23,  0x24, 0x25 };
  49     senf::PacketInterpreterBase::ptr p (senf::PacketInterpreter<VoidPacket>::create(data));
  50     typedef senf::VectorParser<
  51         senf::UInt16Parser,
  52         senf::detail::FixedAuxParserPolicy<senf::UInt8Parser, 1u>
  53         > UInt16VectorParser;
  54
  55     {
  56         UInt16VectorParser v (boost::next(p->data().begin(), 1), &p->data());
  57
  58         BOOST_CHECK_EQUAL( v[0], 0x1011 );
  59         BOOST_CHECK_EQUAL( v[2], 0x1415 );
  60         BOOST_CHECK_EQUAL( v.size(), 3u );
  61         BOOST_CHECK_EQUAL( v.bytes(), 6u );
  62         BOOST_CHECK( ! v.empty() );
  63         p->data()[0] = 0x06;
  64         BOOST_CHECK_EQUAL( v.size(), 6u );
  65         BOOST_CHECK_EQUAL( v.bytes(), 12u );
  66
  67         UInt16VectorParser::iterator b (v.begin());
  68         UInt16VectorParser::iterator e (v.end());
  69         BOOST_CHECK_EQUAL(std::distance(b,e), UInt16VectorParser::difference_type(v.size()));
  70     }
  71
  72     // Warning: Each of the following operations invalidate the parser -> we need to recreate it at
  73     // each step
  74
  75     // And since all these members directly call the corresponding members in the container wrapper,
  76     // we don't need to check them again below ...
  77
  78     {
  79 #       define v UInt16VectorParser(boost::next(p->data().begin(),1),&p->data())
  80
  81         v.push_back(0xf0f1u,2);
  82         BOOST_CHECK_EQUAL( v.size(), 8u );
  83         BOOST_CHECK_EQUAL( v[7], 0xf0f1u );
  84
  85         v.push_back_space() = 37u;
  86         BOOST_CHECK_EQUAL( v.size(), 9u );
  87         BOOST_CHECK_EQUAL( v[8], 37u );
  88
  89         v.push_front(0xf3f4u);
  90         BOOST_CHECK_EQUAL( v.size(), 10u );
  91         BOOST_CHECK_EQUAL( v[0], 0xf3f4u );
  92         BOOST_CHECK_EQUAL( v[1], 0x1011u );
  93
  94         v.push_front_space(2);
  95         BOOST_CHECK_EQUAL( v.size(), 12u );
  96         BOOST_CHECK_EQUAL( v[0], 0u );
  97         BOOST_CHECK_EQUAL( v[1], 0u );
  98         BOOST_CHECK_EQUAL( v[2], 0xf3f4u );
  99         BOOST_CHECK_EQUAL( p->data().size(), 25u );
 100
 101         v.resize(4);
 102         BOOST_CHECK_EQUAL( v.size(), 4u );
 103         BOOST_CHECK_EQUAL( p->data().size(), 9u );
 104         BOOST_CHECK_EQUAL( v[3], 0x1011u );
 105
 106         v.resize(6);
 107         BOOST_CHECK_EQUAL( v.size(), 6u );
 108         BOOST_CHECK_EQUAL( v[5], 0u );
 109
 110         v.resize(8,0xffff);
 111         BOOST_CHECK_EQUAL( v.size(), 8u );
 112         BOOST_CHECK_EQUAL( p->data().size(), 17u );
 113         BOOST_CHECK_EQUAL( v[6], 0xffffu );
 114
 115 #       undef v
 116     }
 117 }
 118
 119 SENF_AUTO_UNIT_TEST(VectorParser_wrapper)
 120 {
 121     unsigned char data[] = { 0x03,                                   // size
 122                              0x10, 0x11,  0x12, 0x13,  0x14, 0x15,   // data
 123                              0x20, 0x21,  0x22, 0x23,  0x24, 0x25 };
 124     senf::PacketInterpreterBase::ptr p (senf::PacketInterpreter<VoidPacket>::create(data));
 125     typedef senf::VectorParser<
 126         senf::UInt16Parser,
 127         senf::detail::FixedAuxParserPolicy<senf::UInt8Parser, 1u>
 128         > UInt16VectorParser;
 129     UInt16VectorParser v (boost::next(p->data().begin(),1), &p->data());
 130     UInt16VectorParser::container w (v);
 131
 132     BOOST_CHECK_EQUAL( w[0], 0x1011 );
 133     BOOST_CHECK_EQUAL( w[2], 0x1415 );
 134     BOOST_CHECK_EQUAL( w.size(), 3u );
 135     p->data()[0] = 0x06;
 136     BOOST_CHECK_EQUAL( w.size(), 6u );
 137     BOOST_CHECK_EQUAL( std::distance(w.begin(),w.end()),
 138                        UInt16VectorParser::difference_type(w.size()) );
 139
 140     w.shift(w.begin()+1);
 141     BOOST_CHECK_EQUAL( w.size(), 7u );
 142     BOOST_CHECK_EQUAL( w[0], 0x1011 );
 143     BOOST_CHECK_EQUAL( w[1], 0 );
 144     BOOST_CHECK_EQUAL( w[2], 0x1213 );
 145
 146     w.insert(w.begin()+3, 2u, 0xfffe);
 147     BOOST_CHECK_EQUAL( w.size(), 9u );
 148     BOOST_CHECK_EQUAL( w[2], 0x1213 );
 149     BOOST_CHECK_EQUAL( w[3], 0xfffe );
 150     BOOST_CHECK_EQUAL( w[4], 0xfffe );
 151     BOOST_CHECK_EQUAL( w[5], 0x1415 );
 152
 153     w.erase(w.begin()+3, w.begin()+5);
 154     BOOST_CHECK_EQUAL( w.size(), 7u );
 155
 156     w.erase(w.begin()+1);
 157     BOOST_CHECK_EQUAL( w.size(), 6u );
 158
 159     {
 160         senf::PacketData::iterator i (p->data().begin()+1);
 161         UInt16VectorParser::iterator j (w.begin());
 162         UInt16VectorParser::iterator e (w.end());
 163         for (;j!=e;++j, i+=2)
 164             BOOST_CHECK_EQUAL( senf::UInt16Parser(i,&p->data()), *j );
 165         BOOST_CHECK_EQUAL(p->data().end()-i, 0);
 166     }
 167
 168     w.clear();
 169     BOOST_CHECK_EQUAL( w.size(), 0u );
 170     BOOST_CHECK( w.begin() == w.end() );
 171     BOOST_CHECK_EQUAL( p->data().size(), 1u );
 172
 173     BOOST_CHECK_EQUAL( w.parser().size(), 0u );
 174 }
 175
 176 SENF_AUTO_UNIT_TEST(dynamicPolicyVector)
 177 {
 178     unsigned char data[] = { 0x03,                                   // size
 179                              0x10, 0x11,  0x12, 0x13,  0x14, 0x15,   // data
 180                              0x20, 0x21,  0x22, 0x23,  0x24, 0x25 };
 181     senf::PacketInterpreterBase::ptr p (senf::PacketInterpreter<VoidPacket>::create(data));
 182
 183     typedef senf::VectorParser<
 184         senf::UInt16Parser,
 185         senf::detail::DynamicAuxParserPolicy<senf::UInt8Parser>
 186         > UInt16VectorParser;
 187
 188     UInt16VectorParser v (senf::UInt8Parser(p->data().begin(), &p->data()),
 189                           boost::next(p->data().begin(),1), &p->data());
 190     UInt16VectorParser::container w (v);
 191
 192     BOOST_CHECK_EQUAL( v.size(), 3u );
 193     BOOST_CHECK_EQUAL( w.size(), 3u );
 194
 195     BOOST_CHECK_EQUAL( v[0], 0x1011 );
 196     BOOST_CHECK_EQUAL( v[2], 0x1415 );
 197
 198     BOOST_CHECK_EQUAL( w[0], 0x1011 );
 199     BOOST_CHECK_EQUAL( w[2], 0x1415 );
 200 }
 201
 202 namespace {
 203
 204     struct TestTransform
 205     {
 206         typedef unsigned value_type;
 207         static unsigned get(unsigned v) { return v-2; }
 208         static unsigned set(unsigned v) { return v+2; }
 209     };
 210
 211     struct TestVectorParser
 212         : public senf::PacketParserBase
 213     {
 214 #       include SENF_PARSER()
 215
 216         SENF_PARSER_PRIVATE_FIELD ( size1 , senf::UInt8Parser );
 217         SENF_PARSER_PRIVATE_FIELD ( size2 , senf::UInt8Parser );
 218         SENF_PARSER_FIELD         ( dummy , senf::UInt32Parser );
 219         SENF_PARSER_VECTOR        ( vec1  , transform(TestTransform, size1) , senf::UInt16Parser );
 220         SENF_PARSER_VECTOR        ( vec2  , bytes(size2) , senf::UInt16Parser );
 221
 222         SENF_PARSER_FINALIZE( TestVectorParser );
 223     };
 224
 225     struct TestVectorPacketType
 226         : public senf::PacketTypeBase,
 227           public senf::PacketTypeMixin<TestVectorPacketType>
 228     {
 229         typedef senf::PacketTypeMixin<TestVectorPacketType> mixin;
 230         typedef TestVectorParser parser;
 231
 232         using mixin::nextPacketRange;
 233         using mixin::init;
 234         using mixin::initSize;
 235     };
 236     typedef senf::ConcretePacket<TestVectorPacketType> TestVectorPacket;
 237
 238 }
 239
 240 SENF_AUTO_UNIT_TEST(vectorMacro_parse)
 241 {
 242     unsigned char data[] = { 0x05,                   // size1
 243                              0x04,                   // size2
 244                              0x01, 0x02, 0x03, 0x04, // dummy
 245                              0x05, 0x06,             // vec1[0]
 246                              0x07, 0x08,             // vec1[1]
 247                              0x09, 0x0A,             // vec1[2]
 248                              0x0B, 0x0C,             // vec2[0]
 249                              0x0D, 0x0E };           // vec2[1]
 250
 251     senf::DataPacket p (senf::DataPacket::create(data));
 252     TestVectorParser parser (p.data().begin(), &p.data());
 253
 254     BOOST_CHECK_EQUAL( parser.vec1().size(), 3u );
 255     BOOST_CHECK_EQUAL( parser.vec2().size(), 2u );
 256     BOOST_CHECK_EQUAL( parser.dummy(), 0x01020304u );
 257     BOOST_CHECK_EQUAL( parser.vec1()[0], 0x0506u );
 258     BOOST_CHECK_EQUAL( parser.vec1()[1], 0x0708u );
 259     BOOST_CHECK_EQUAL( parser.vec1()[2], 0x090Au );
 260     BOOST_CHECK_EQUAL( parser.vec2()[0], 0x0B0Cu );
 261     BOOST_CHECK_EQUAL( parser.vec2()[1], 0x0D0Eu );
 262 }
 263
 264 SENF_AUTO_UNIT_TEST(vectorMacro_create)
 265 {
 266     TestVectorPacket p (TestVectorPacket::create());
 267     p->dummy() = 0x01020304u;
 268     p->vec1().push_back( 0x0506u);
 269     p->vec1().push_back( 0x0708u);
 270     p->vec1().push_back( 0x090Au);
 271     p->vec2().push_back( 0x0B0Cu);
 272     p->vec2().push_back( 0x0D0Eu);
 273     p.finalizeAll();
 274
 275     unsigned char data[] = {
 276             0x05,                   // size1
 277             0x04,                   // size2
 278             0x01, 0x02, 0x03, 0x04, // dummy
 279             0x05, 0x06,             // vec1[0]
 280             0x07, 0x08,             // vec1[1]
 281             0x09, 0x0A,             // vec1[2]
 282             0x0B, 0x0C,             // vec2[0]
 283             0x0D, 0x0E              // vec2[1]
 284     };
 285     SENF_CHECK_EQUAL_COLLECTIONS(
 286             data, data+sizeof(data), p.data().begin(), p.data().end() );
 287 }
 288
 289 namespace {
 290
 291     struct TestVectorBaseParser
 292         : public senf::PacketParserBase
 293     {
 294 #       include SENF_PARSER()
 295
 296         SENF_PARSER_PRIVATE_FIELD ( size1 , senf::UInt8Parser );
 297         SENF_PARSER_FIELD_RO      ( size2 , senf::UInt8Parser );
 298         SENF_PARSER_FIELD         ( dummy , senf::UInt32Parser );\
 299
 300         SENF_PARSER_FINALIZE( TestVectorBaseParser );
 301     };
 302
 303     struct TestVectorDerivedParser
 304         : public TestVectorBaseParser
 305     {
 306 #       include SENF_PARSER()
 307
 308         SENF_PARSER_INHERIT(TestVectorBaseParser);
 309
 310         SENF_PARSER_VECTOR        ( vec1  , transform(TestTransform, size1) , senf::UInt16Parser );
 311         SENF_PARSER_VECTOR        ( vec2  , bytes(size2) , senf::UInt16Parser );
 312
 313         SENF_PARSER_FINALIZE( TestVectorDerivedParser );
 314     };
 315
 316 }
 317
 318 SENF_AUTO_UNIT_TEST(vectorMacro_inherit)
 319 {
 320     unsigned char data[] = { 0x05,                   // size1
 321                              0x04,                   // size2
 322                              0x01, 0x02, 0x03, 0x04, // dummy
 323                              0x05, 0x06,             // vec1[0]
 324                              0x07, 0x08,             // vec1[1]
 325                              0x09, 0x0A,             // vec1[2]
 326                              0x0B, 0x0C,             // vec2[0]
 327                              0x0D, 0x0E };           // vec2[1]
 328
 329     senf::DataPacket p (senf::DataPacket::create(data));
 330     TestVectorDerivedParser parser (p.data().begin(), &p.data());
 331
 332     BOOST_CHECK_EQUAL( parser.vec1().size(), 3u );
 333     BOOST_CHECK_EQUAL( parser.vec2().size(), 2u );
 334     BOOST_CHECK_EQUAL( parser.dummy(), 0x01020304u );
 335     BOOST_CHECK_EQUAL( parser.vec1()[0], 0x0506u );
 336     BOOST_CHECK_EQUAL( parser.vec1()[1], 0x0708u );
 337     BOOST_CHECK_EQUAL( parser.vec1()[2], 0x090Au );
 338     BOOST_CHECK_EQUAL( parser.vec2()[0], 0x0B0Cu );
 339     BOOST_CHECK_EQUAL( parser.vec2()[1], 0x0D0Eu );
 340 }
 341
 342 namespace {
 343
 344     struct TestPacketSizeVectorParser
 345         : public senf::PacketParserBase
 346     {
 347 #       include SENF_PARSER()
 348
 349         SENF_PARSER_VECTOR        ( vec   , packetSize() , senf::UInt16Parser );
 350
 351         SENF_PARSER_FINALIZE( TestPacketSizeVectorParser );
 352     };
 353
 354 }
 355
 356 SENF_AUTO_UNIT_TEST(vectorMacro_packetSize)
 357 {
 358     unsigned char data[] = { 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
 359                              0x21, 0x22, 0x23, 0x24, 0x25, 0x26 };
 360
 361     senf::DataPacket p (senf::DataPacket::create(data));
 362     TestPacketSizeVectorParser parser (p.data().begin(), &p.data());
 363
 364     {
 365         BOOST_CHECK_EQUAL( parser.vec().size(), 6u );
 366         BOOST_CHECK_EQUAL( parser.vec()[0], 0x1112u );
 367         BOOST_CHECK_EQUAL( parser.vec()[1], 0x1314u );
 368         BOOST_CHECK_EQUAL( parser.vec()[5], 0x2526u );
 369     }
 370
 371     // The real functionality is already tested in AuxPolixy.test.cc ...
 372 }
 373
 374 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 375 #undef prefix_
 376
 377 \f
 378 // Local Variables:
 379 // mode: c++
 380 // fill-column: 100
 381 // c-file-style: "senf"
 382 // indent-tabs-mode: nil
 383 // ispell-local-dictionary: "american"
 384 // compile-command: "scons -u test"
 385 // comment-column: 40
 386 // End: