X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=senf%2FPPI%2FMultiConnectorMixin.test.cc;h=0c2f2206ac22641d9212eafb58fafbb4032c2ca7;hb=8a6697d11e9a6557d9a5c42b4052666fce32bc10;hp=6e05ebea0aeefd05809ef497ff85af1c2f558564;hpb=601d1f509f5bb24df167a4dd5a20da67a0af9af8;p=senf.git diff --git a/senf/PPI/MultiConnectorMixin.test.cc b/senf/PPI/MultiConnectorMixin.test.cc index 6e05ebe..0c2f220 100644 --- a/senf/PPI/MultiConnectorMixin.test.cc +++ b/senf/PPI/MultiConnectorMixin.test.cc @@ -1,24 +1,29 @@ // $Id$ // -// Copyright (C) 2009 +// Copyright (C) 2009 // Fraunhofer Institute for Open Communication Systems (FOKUS) -// Competence Center NETwork research (NET), St. Augustin, GERMANY -// Stefan Bund // -// This program is free software; you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation; either version 2 of the License, or -// (at your option) any later version. +// The contents of this file are subject to the Fraunhofer FOKUS Public License +// Version 1.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// http://senf.berlios.de/license.html // -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. +// The Fraunhofer FOKUS Public License Version 1.0 is based on, +// but modifies the Mozilla Public License Version 1.1. +// See the full license text for the amendments. // -// You should have received a copy of the GNU General Public License -// along with this program; if not, write to the -// Free Software Foundation, Inc., -// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// Software distributed under the License is distributed on an "AS IS" basis, +// WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License +// for the specific language governing rights and limitations under the License. +// +// The Original Code is Fraunhofer FOKUS code. +// +// The Initial Developer of the Original Code is Fraunhofer-Gesellschaft e.V. +// (registered association), Hansastraße 27 c, 80686 Munich, Germany. +// All Rights Reserved. +// +// Contributor(s): +// Stefan Bund /** \file \brief MultiConnectorMixin.test unit tests */ @@ -27,71 +32,162 @@ //#include "MultiConnectorMixin.test.ih" // Custom includes -#include "PPI.hh" +#include "MultiConnectorMixin.hh" +#include "DebugModules.hh" +#include "Joins.hh" +#include "AnnotationRouter.hh" -#include "../Utils/auto_unit_test.hh" +#include #include #define prefix_ -///////////////////////////////cc.p//////////////////////////////////////// +//-///////////////////////////////////////////////////////////////////////////////////////////////// +namespace ppi = senf::ppi; +namespace connector = ppi::connector; +namespace module = ppi::module; +namespace debug = module::debug; namespace { - // We only test the user-collection case, all other cases are already handled by - // existing modules + + // Primitive join + class SequenceContainerModule + : public module::Module, + public module::MultiConnectorMixin > + { + SENF_PPI_MODULE(SequenceContainerModule); + typedef module::MultiConnectorMixin > base; + + public: + connector::ActiveOutput<> output; + + using base::connectors; + + SequenceContainerModule() : count (0u) + { + noroute(output); + } + + unsigned count; + + private: + void connectorSetup(connector::PassiveInput<> & c) + { + route(c, output); + c.onRequest(boost::bind(&SequenceContainerModule::request, this, boost::ref(c))); + ++ count; + } + + void connectorDestroy(connector::PassiveInput<> const & c) + { + -- count; + } + + void request(connector::PassiveInput<> & c) + { + output(c()); + } + + friend class module::MultiConnectorMixin >; + }; // Primitive duplicator - class MyModule - : public senf::ppi::module::Module, - public senf::ppi::module::MultiConnectorMixin, - void, void> + class UserContainerModule + : public module::Module, + public module::MultiConnectorMixin, void, void> { - SENF_PPI_MODULE(MyModule); + SENF_PPI_MODULE(UserContainerModule); + typedef std::vector< boost::shared_ptr > Connectors; public: - senf::ppi::connector::PassiveInput<> input; + connector::PassiveInput<> input; - MyModule() - { - noroute(input); - input.onRequest(&MyModule::request); - } + UserContainerModule() + { + noroute(input); + input.onRequest(&UserContainerModule::request); + } + + Connectors const & connectors() const + { return connectors_; } private: void connectorSetup(std::auto_ptr c) - { - route(input, *c); - connectors_.push_back(boost::shared_ptr(c)); - } + { + route(input, *c); + connectors_.push_back(boost::shared_ptr(c)); + } + + void connectorDestroy(ConnectorType const * c) + { + Connectors::iterator i ( + std::find_if(connectors_.begin(), connectors_.end(), + boost::bind(&Connectors::value_type::get,_1) == c)); + if (i != connectors_.end()) + connectors_.erase(i); + } void request() - { - senf::Packet p (input()); - for (Connectors::iterator i (connectors_.begin()), i_end (connectors_.end()); - i != i_end; ++i) - (**i)(p); - } - - typedef std::vector< boost::shared_ptr > Connectors; + { + senf::Packet p (input()); + for (Connectors::iterator i (connectors_.begin()), i_end (connectors_.end()); + i != i_end; ++i) + (**i)(p); + } + Connectors connectors_; - - friend class senf::ppi::module::MultiConnectorMixin, - void, void>; + friend class module::MultiConnectorMixin, void, void>; + }; + + struct IntAnnotation { + int value; + bool operator<(IntAnnotation const & other) const { return value < other.value; } + IntAnnotation() {} + IntAnnotation(int v) : value(v) {} }; + + std::ostream & operator<<(std::ostream & os, IntAnnotation const & value) + { os << value.value; return os; } +} + +SENF_AUTO_UNIT_TEST(multiConnectorMixin_sequenceContainer) +{ + debug::ActiveSource source1; + debug::ActiveSource source2; + SequenceContainerModule module; + debug::PassiveSink sink; + + ppi::connect(source1, module); + ppi::connect(source2, module); + ppi::connect(module, sink); + ppi::init(); + + senf::Packet p (senf::DataPacket::create()); + + source1.submit(p); + BOOST_CHECK_EQUAL( sink.size(), 1u ); + BOOST_CHECK( sink.pop_front() == p ); + source2.submit(p); + BOOST_CHECK_EQUAL( sink.size(), 1u ); + BOOST_CHECK( sink.pop_front() == p ); + + BOOST_CHECK_EQUAL( module.connectors().size(), 2u ); + BOOST_CHECK_EQUAL( module.count, 2u ); + source1.output.disconnect(); + BOOST_CHECK_EQUAL( module.connectors().size(), 1u ); + BOOST_CHECK_EQUAL( module.count, 1u ); } -BOOST_AUTO_UNIT_TEST(multiConnectorMixin_userContainer) +SENF_AUTO_UNIT_TEST(multiConnectorMixin_userContainer) { - senf::ppi::module::debug::ActiveSource source; - MyModule module; - senf::ppi::module::debug::PassiveSink sink1; - senf::ppi::module::debug::PassiveSink sink2; + debug::ActiveSource source; + UserContainerModule module; + debug::PassiveSink sink1; + debug::PassiveSink sink2; - senf::ppi::connect(source, module); - senf::ppi::connect(module, sink1); - senf::ppi::connect(module, sink2); - senf::ppi::init(); + ppi::connect(source, module); + ppi::connect(module, sink1); + ppi::connect(module, sink2); + ppi::init(); senf::Packet p (senf::DataPacket::create()); @@ -100,10 +196,36 @@ BOOST_AUTO_UNIT_TEST(multiConnectorMixin_userContainer) BOOST_CHECK_EQUAL( sink2.size(), 1u ); BOOST_CHECK( sink1.pop_front() == p ); BOOST_CHECK( sink2.pop_front() == p ); - + + BOOST_CHECK_EQUAL( module.connectors().size(), 2u ); + sink1.input.disconnect(); + BOOST_CHECK_EQUAL( module.connectors().size(), 1u ); +} + +SENF_AUTO_UNIT_TEST(multiConnectorMixin_multipleModules) +{ + debug::ActiveSource source; + debug::PassiveSink sink; + module::PassiveJoin join1; + module::PassiveJoin join2; + module::AnnotationRouter router; + UserContainerModule module; + + ppi::connect(source, join1); + ppi::connect(join1, router); + ppi::connect(router, 1, join2); + ppi::connect(join2, module); + ppi::connect(module, sink); + + senf::Packet p (senf::DataPacket::create()); + p.annotation().value = 1; + + source.submit(p); + BOOST_CHECK_EQUAL( sink.size(), 1u ); + BOOST_CHECK( sink.pop_front() == p ); } -///////////////////////////////cc.e//////////////////////////////////////// +//-///////////////////////////////////////////////////////////////////////////////////////////////// #undef prefix_