PPI: Complete connector implementation
[senf.git] / PPI / Connectors.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 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 <boost/test/auto_unit_test.hpp>
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::ActivePacketSource source;
53     debug::PassivePacketSink 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::ActivePacketSource source;
67     debug::PassivePacketSink target;
68
69     ppi::connect(source.output,target.input);
70     ppi::init();
71
72     // onRequest is implicitly tested within the PassivePacketSink 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::ActivePacketSource source;
96     debug::PassivePacketSink 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::ActivePacketSource source;
128     debug::PassivePacketSink target;
129
130     ppi::connect(source.output,target.input);
131     ppi::init();
132
133     // operator() is implicitly tested within the Active/PassivePacketSink implementation which is
134     // tested in DebugModules.test.cc
135
136     // peek() is implicitly tested within the Active/PassivePacketSink 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::ActivePacketSource source;
148     debug::PassivePacketSink target;
149
150     ppi::connect(source.output,target.input);
151     ppi::init();
152
153     // operator() is implicitly tested within the Active/PassivePacketSource 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 PassiveInputTest
162         : public ppi::module::Module
163     {
164     public:
165         ppi::connector::PassiveInput input;
166
167         PassiveInputTest() : counter() {
168             noroute(input);
169             input.onRequest(&PassiveInputTest::request);
170         }
171
172         void request() {
173             ++ counter;
174         }
175
176         unsigned counter;
177     };
178 }
179
180 BOOST_AUTO_UNIT_TEST(passiveInput)
181 {
182     debug::ActivePacketSource source;
183     PassiveInputTest target;
184
185     ppi::connect(source.output,target.input);
186     ppi::init();
187
188     BOOST_CHECK_EQUAL( & target.input.peer(), & source.output );
189     
190     target.input.throttle();
191     senf::Packet p (senf::DataPacket::create());
192     source.submit(p);
193     
194     BOOST_CHECK_EQUAL( target.counter, 0u );
195     BOOST_CHECK( target.input );
196     BOOST_CHECK_EQUAL( target.input.queueSize(), 1u );
197     target.input.unthrottle();
198     BOOST_CHECK( target.input );
199     BOOST_CHECK_EQUAL( target.counter, 1u );
200     
201     BOOST_CHECK( target.input() == p );
202     BOOST_CHECK( ! target.input );
203     
204     source.submit(p);
205     
206     BOOST_CHECK_EQUAL( target.counter, 2u );
207     BOOST_CHECK( target.input.throttled() );
208     BOOST_CHECK( target.input() == p );
209     BOOST_CHECK( ! target.input.throttled() );
210
211     target.input.qdisc(ppi::ThresholdQueueing(2,0));
212
213     source.submit(p);
214     BOOST_CHECK ( ! target.input.throttled() );
215     source.submit(p);
216     BOOST_CHECK( target.input.throttled() );
217     target.input();
218     BOOST_CHECK( target.input.throttled() );
219     target.input();
220     BOOST_CHECK( ! target.input.throttled() );
221 }
222
223 BOOST_AUTO_UNIT_TEST(passiveOutput)
224 {
225     debug::PassivePacketSource source;
226     debug::ActivePacketSink target;
227
228     ppi::connect(source.output,target.input);
229     ppi::init();
230
231     senf::Packet p (senf::DataPacket::create());
232     source.submit(p);
233
234     BOOST_CHECK_EQUAL( & source.output.peer(), & target.input );
235
236     BOOST_CHECK( source.output );
237
238     source.submit(p);
239     BOOST_CHECK( target.request() == p );
240     
241     // connect() is tested indirectly via ppi::connect
242 }
243
244 BOOST_AUTO_UNIT_TEST(activeInput)
245 {
246     debug::PassivePacketSource source;
247     debug::ActivePacketSink target;
248
249     ppi::connect(source.output,target.input);
250     ppi::init();
251
252     BOOST_CHECK_EQUAL( & target.input.peer(), & source.output );
253
254     BOOST_CHECK ( ! target.input );
255
256     senf::Packet p (senf::DataPacket::create());
257     source.submit(p);
258
259     BOOST_CHECK( target.input );
260     BOOST_CHECK( target.request() == p );
261
262     source.submit(p);
263     target.input.request();
264     BOOST_CHECK_EQUAL( target.input.queueSize(), 1u );
265     BOOST_CHECK( target.input );
266     BOOST_CHECK( target.request() == p );
267 }
268
269 BOOST_AUTO_UNIT_TEST(activeOutput)
270 {
271     debug::ActivePacketSource source;
272     debug::PassivePacketSink target;
273
274     ppi::connect(source.output,target.input);
275     ppi::init();
276     
277     BOOST_CHECK_EQUAL( & source.output.peer(), & target.input );
278     BOOST_CHECK( source.output );
279     target.input.throttle();
280     BOOST_CHECK( ! source.output );
281
282     // connect() is tested indirectly via ppi::connect
283 }
284
285
286 ///////////////////////////////cc.e////////////////////////////////////////
287 #undef prefix_
288
289 \f
290 // Local Variables:
291 // mode: c++
292 // fill-column: 100
293 // comment-column: 40
294 // c-file-style: "senf"
295 // indent-tabs-mode: nil
296 // ispell-local-dictionary: "american"
297 // compile-command: "scons -u test"
298 // End: