PPI/Connectors.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 Connectors.test unit tests */
  25
  26 //#include "Connectors.test.hh"
  27 //#include "Connectors.test.ih"
  28
  29 // Custom includes
  30 #include "Connectors.hh"
  31 #include "DebugModules.hh"
  32 #include "Setup.hh"
  33
  34 #include "../Utils/auto_unit_test.hh"
  35 #include <boost/test/test_tools.hpp>
  36
  37 #define prefix_
  38 ///////////////////////////////cc.p////////////////////////////////////////
  39
  40 namespace ppi = senf::ppi;
  41 namespace debug = ppi::module::debug;
  42
  43 // For each type of connector we use the corresponding debug module. Additionally, we always need
  44 // the corresponding connected module since otherwise the connectors cannot be connected anywhere
  45 // and will be unusable.
  46
  47 BOOST_AUTO_UNIT_TEST(connector)
  48 {
  49     // It doesn't matter, which type of connectors we use here since they are all based on
  50     // Connector.
  51
  52     debug::ActiveSource source;
  53     debug::PassiveSink target;
  54
  55     ppi::connect(source.output,target.input);
  56     ppi::init();
  57
  58     BOOST_CHECK_EQUAL( & source.output.module(), & source );
  59     BOOST_CHECK_EQUAL( & target.input.module(), & target );
  60     BOOST_CHECK_EQUAL( & source.output.peer(), & target.input );
  61     BOOST_CHECK_EQUAL( & target.input.peer(), & source.output );
  62 }
  63
  64 BOOST_AUTO_UNIT_TEST(passiveConnector)
  65 {
  66     debug::ActiveSource source;
  67     debug::PassiveSink target;
  68
  69     ppi::connect(source.output,target.input);
  70     ppi::init();
  71
  72     // onRequest is implicitly tested within the PassiveSink implementation which is tested
  73     // in DebugModules.test.cc
  74
  75     target.input.throttle();
  76     BOOST_CHECK( target.input.throttled() );
  77     BOOST_CHECK( target.input.nativeThrottled() );
  78
  79     target.input.unthrottle();
  80     BOOST_CHECK( ! target.input.throttled() );
  81     BOOST_CHECK( ! target.input.nativeThrottled() );
  82
  83     BOOST_CHECK_EQUAL( & target.input.peer(), & source.output );
  84 }
  85
  86 namespace {
  87
  88     bool called = false;
  89
  90     void handler() { called = true; }
  91 }
  92
  93 BOOST_AUTO_UNIT_TEST(activeConnector)
  94 {
  95     debug::ActiveSource source;
  96     debug::PassiveSink target;
  97
  98     ppi::connect(source.output,target.input);
  99     ppi::init();
 100
 101     source.output.onThrottle(handler);
 102     BOOST_CHECK( ! called );
 103     target.input.throttle();
 104     BOOST_CHECK( called );
 105     called = false;
 106     target.input.unthrottle();
 107     BOOST_CHECK( ! called );
 108     source.output.onThrottle();
 109     source.output.onUnthrottle(handler);
 110     BOOST_CHECK( ! called );
 111     target.input.throttle();
 112     BOOST_CHECK( ! called );
 113     target.input.unthrottle();
 114     BOOST_CHECK( called );
 115     source.output.onUnthrottle();
 116     called = false;
 117     BOOST_CHECK( ! called );
 118     target.input.throttle();
 119     target.input.unthrottle();
 120     BOOST_CHECK( ! called );
 121
 122     BOOST_CHECK_EQUAL( & source.output.peer(), & target.input );
 123 }
 124
 125 BOOST_AUTO_UNIT_TEST(inputConnector)
 126 {
 127     debug::ActiveSource source;
 128     debug::PassiveSink target;
 129
 130     ppi::connect(source.output,target.input);
 131     ppi::init();
 132
 133     // operator() is implicitly tested within the Active/PassiveSink implementation which is
 134     // tested in DebugModules.test.cc
 135
 136     // peek() is implicitly tested within the Active/PassiveSink implementation
 137
 138     BOOST_CHECK_EQUAL ( & target.input.peer(), & source.output );
 139
 140     BOOST_CHECK( target.input.begin() == target.input.end() );
 141     BOOST_CHECK_EQUAL( target.input.queueSize(), 0u );
 142     BOOST_CHECK( target.input.empty() );
 143 }
 144
 145 BOOST_AUTO_UNIT_TEST(outputConnector)
 146 {
 147     debug::ActiveSource source;
 148     debug::PassiveSink target;
 149
 150     ppi::connect(source.output,target.input);
 151     ppi::init();
 152
 153     // operator() is implicitly tested within the Active/PassiveSource implementation which is
 154     // tested in DebugModules.test.cc
 155
 156     BOOST_CHECK_EQUAL( & source.output.peer(), & target.input );
 157 }
 158
 159 namespace {
 160
 161     class GenericPassiveInputTest
 162         : public ppi::module::Module
 163     {
 164         SENF_PPI_MODULE(GenericPassiveInputTest);
 165
 166     public:
 167         ppi::connector::GenericPassiveInput input;
 168
 169         GenericPassiveInputTest() : counter() {
 170             noroute(input);
 171             input.onRequest(&GenericPassiveInputTest::request);
 172         }
 173
 174         void request() {
 175             ++ counter;
 176         }
 177
 178         unsigned counter;
 179     };
 180 }
 181
 182 BOOST_AUTO_UNIT_TEST(passiveInput)
 183 {
 184     debug::ActiveSource source;
 185     GenericPassiveInputTest target;
 186
 187     ppi::connect(source,target);
 188     ppi::init();
 189
 190     BOOST_CHECK_EQUAL( & target.input.peer(), & source.output );
 191
 192     target.input.throttle();
 193     senf::Packet p (senf::DataPacket::create());
 194     source.submit(p);
 195
 196     BOOST_CHECK_EQUAL( target.counter, 0u );
 197     BOOST_CHECK( target.input );
 198     BOOST_CHECK_EQUAL( target.input.queueSize(), 1u );
 199     target.input.unthrottle();
 200     BOOST_CHECK( target.input );
 201     BOOST_CHECK_EQUAL( target.counter, 1u );
 202
 203     BOOST_CHECK( target.input() == p );
 204     BOOST_CHECK( ! target.input );
 205
 206     source.submit(p);
 207
 208     BOOST_CHECK_EQUAL( target.counter, 2u );
 209     BOOST_CHECK( target.input.throttled() );
 210     BOOST_CHECK( target.input() == p );
 211     BOOST_CHECK( ! target.input.throttled() );
 212
 213     target.input.qdisc(ppi::ThresholdQueueing(2,0));
 214
 215     source.submit(p);
 216     BOOST_CHECK ( ! target.input.throttled() );
 217     source.submit(p);
 218     BOOST_CHECK( target.input.throttled() );
 219     target.input();
 220     BOOST_CHECK( target.input.throttled() );
 221     target.input();
 222     BOOST_CHECK( ! target.input.throttled() );
 223 }
 224
 225 BOOST_AUTO_UNIT_TEST(passiveOutput)
 226 {
 227     debug::PassiveSource source;
 228     debug::ActiveSink target;
 229
 230     ppi::connect(source,target);
 231     ppi::init();
 232
 233     senf::Packet p (senf::DataPacket::create());
 234     source.submit(p);
 235
 236     BOOST_CHECK_EQUAL( & source.output.peer(), & target.input );
 237
 238     BOOST_CHECK( source.output );
 239
 240     source.submit(p);
 241     BOOST_CHECK( target.request() == p );
 242
 243     // connect() is tested indirectly via ppi::connect
 244 }
 245
 246 BOOST_AUTO_UNIT_TEST(activeInput)
 247 {
 248     debug::PassiveSource source;
 249     debug::ActiveSink target;
 250
 251     ppi::connect(source,target);
 252     ppi::init();
 253
 254     BOOST_CHECK_EQUAL( & target.input.peer(), & source.output );
 255
 256     BOOST_CHECK ( ! target.input );
 257
 258     senf::Packet p (senf::DataPacket::create());
 259     source.submit(p);
 260
 261     BOOST_CHECK( target.input );
 262     BOOST_CHECK( target.request() == p );
 263
 264     source.submit(p);
 265     target.input.request();
 266     BOOST_CHECK_EQUAL( target.input.queueSize(), 1u );
 267     BOOST_CHECK( target.input );
 268     BOOST_CHECK( target.request() == p );
 269 }
 270
 271 BOOST_AUTO_UNIT_TEST(activeOutput)
 272 {
 273     debug::ActiveSource source;
 274     debug::PassiveSink target;
 275
 276     ppi::connect(source,target);
 277     ppi::init();
 278
 279     BOOST_CHECK_EQUAL( & source.output.peer(), & target.input );
 280     BOOST_CHECK( source.output );
 281     target.input.throttle();
 282     BOOST_CHECK( ! source.output );
 283
 284     // connect() is tested indirectly via ppi::connect
 285 }
 286
 287
 288 ///////////////////////////////cc.e////////////////////////////////////////
 289 #undef prefix_
 290
 291 \f
 292 // Local Variables:
 293 // mode: c++
 294 // fill-column: 100
 295 // comment-column: 40
 296 // c-file-style: "senf"
 297 // indent-tabs-mode: nil
 298 // ispell-local-dictionary: "american"
 299 // compile-command: "scons -u test"
 300 // End: