senf/Packets/PacketRegistry.test.cc

   1 // $Id$
   2 //
   3 // Copyright (C) 2006
   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 PacketRegistry unit tests */
  30
  31 //#include "PacketRegistry.test.hh"
  32 //#include "PacketRegistry.test.ih"
  33
  34 // Custom includes
  35 #include <string>
  36 #include <sstream>
  37 #include "Packets.hh"
  38
  39 #include <senf/Utils/auto_unit_test.hh>
  40 #include <boost/test/test_tools.hpp>
  41
  42 #define prefix_
  43 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  44
  45 namespace {
  46
  47     using namespace senf;
  48
  49     struct BaseTag {
  50         typedef unsigned key_t;
  51     };
  52
  53     struct StringTag {
  54         typedef std::string key_t;
  55     };
  56
  57     struct FooPacketType : public PacketTypeBase {};
  58     typedef senf::ConcretePacket<FooPacketType> FooPacket;
  59     struct BarPacketType : public PacketTypeBase {};
  60     typedef senf::ConcretePacket<BarPacketType> BarPacket;
  61     struct OtherPacketType : public PacketTypeBase {};
  62     typedef senf::ConcretePacket<OtherPacketType> OtherPacket;
  63
  64     bool contains(std::string a, std::string b)
  65     { return a.find(b) != std::string::npos; }
  66
  67     bool contains_not(std::string a, std::string b)
  68     { return a.find(b) == std::string::npos; }
  69
  70 }
  71
  72 SENF_PACKET_REGISTRY_REGISTER(StringTag, "foo", OtherPacket);
  73 SENF_PACKET_REGISTRY_REGISTER_PRIORITY(StringTag, "foo", 1, FooPacket);
  74
  75 SENF_AUTO_UNIT_TEST(packetRegistry_test)
  76 {
  77     {
  78         PacketRegistry<StringTag>::registerPacket<BarPacket>("bar");
  79         PacketRegistry<BaseTag>::registerPacket<FooPacket>(1u);
  80         senf::PacketRegistry<BaseTag>::ScopedRegistrationProxy<BarPacket> registerBarInBase (2u);
  81
  82         BOOST_CHECK_EQUAL( PacketRegistry<BaseTag>::key<FooPacket>(), 1u );
  83         BOOST_CHECK_EQUAL( PacketRegistry<BaseTag>::key<BarPacket>(), 2u );
  84         BOOST_CHECK_THROW( PacketRegistry<BaseTag>::key<OtherPacket>(),
  85                            PacketTypeNotRegisteredException );
  86
  87         BOOST_CHECK_EQUAL( PacketRegistry<StringTag>::key<FooPacket>(), "foo" );
  88         BOOST_CHECK( PacketRegistry<StringTag>::lookup("foo").type() == typeid(FooPacket) );
  89         BOOST_CHECK( ! PacketRegistry<StringTag>::lookup("blub", senf::nothrow) );
  90         BOOST_CHECK( PacketRegistry<BaseTag>::lookup(1u, senf::nothrow) );
  91
  92         unsigned elts1[] = { 1u, 2u };
  93         BOOST_CHECK_EQUAL_COLLECTIONS(
  94             boost::make_transform_iterator(
  95                 PacketRegistry<BaseTag>::begin(),
  96                 boost::multi_index::member<senf::PacketRegistry<BaseTag>::Entry, unsigned,
  97                                            &senf::PacketRegistry<BaseTag>::Entry::key>()),
  98             boost::make_transform_iterator(
  99                 PacketRegistry<BaseTag>::end(),
 100                 boost::multi_index::member<senf::PacketRegistry<BaseTag>::Entry, unsigned,
 101                                            &senf::PacketRegistry<BaseTag>::Entry::key>()),
 102             elts1+0, elts1+sizeof(elts1)/sizeof(elts1[0]) );
 103
 104         std::string elts2[] = { "bar", "foo", "foo" };
 105         BOOST_CHECK_EQUAL_COLLECTIONS(
 106             boost::make_transform_iterator(
 107                 PacketRegistry<StringTag>::begin(),
 108                 boost::multi_index::member<senf::PacketRegistry<StringTag>::Entry, std::string,
 109                                            &senf::PacketRegistry<StringTag>::Entry::key>()),
 110             boost::make_transform_iterator(
 111                 PacketRegistry<StringTag>::end(),
 112                 boost::multi_index::member<senf::PacketRegistry<StringTag>::Entry, std::string,
 113                                            &senf::PacketRegistry<StringTag>::Entry::key>()),
 114             elts2+0, elts2+sizeof(elts2)/sizeof(elts2[0]) );
 115
 116         std::stringstream s;
 117         senf::dumpPacketRegistries(s);
 118         BOOST_CHECK_PREDICATE(
 119             contains,
 120             (s.str())
 121             ("(anonymous namespace)::BaseTag:\n"
 122              "  0x00000001 (         1) (....)      0 (anonymous namespace)::FooPacketType\n"
 123              "  0x00000002 (         2) (....)      0 (anonymous namespace)::BarPacketType\n"
 124              "\n"));
 125         BOOST_CHECK_PREDICATE(
 126             contains,
 127             (s.str())
 128             ("(anonymous namespace)::StringTag:\n"
 129              "  bar                   0 (anonymous namespace)::BarPacketType\n"
 130              "  foo                   1 (anonymous namespace)::FooPacketType\n"
 131              "  foo                   0 (anonymous namespace)::OtherPacketType\n"
 132              "\n" ));
 133     }
 134
 135     {
 136         std::stringstream s;
 137         senf::dumpPacketRegistries(s);
 138         BOOST_CHECK_PREDICATE(
 139             contains,
 140             (s.str())
 141             ("(anonymous namespace)::BaseTag:\n"
 142              "  0x00000001 (         1) (....)      0 (anonymous namespace)::FooPacketType\n"
 143              "\n"));
 144         BOOST_CHECK_PREDICATE(
 145             contains,
 146             (s.str())
 147             ("(anonymous namespace)::StringTag:\n"
 148              "  bar                   0 (anonymous namespace)::BarPacketType\n"
 149              "  foo                   1 (anonymous namespace)::FooPacketType\n"
 150              "  foo                   0 (anonymous namespace)::OtherPacketType\n"
 151              "\n" ));
 152
 153         SENF_CHECK_NO_THROW( PacketRegistry<BaseTag>::unregisterPacket(1u) );
 154         SENF_CHECK_NO_THROW( PacketRegistry<StringTag>::unregisterPacket<BarPacket>() );
 155
 156         s.str("");
 157         senf::dumpPacketRegistries(s);
 158         BOOST_CHECK_PREDICATE(
 159             contains_not,
 160             (s.str())
 161             ("(anonymous namespace)::BaseTag:\n"));
 162         BOOST_CHECK_PREDICATE(
 163             contains,
 164             (s.str())
 165             ("(anonymous namespace)::StringTag:\n"
 166              "  foo                   1 (anonymous namespace)::FooPacketType\n"
 167              "  foo                   0 (anonymous namespace)::OtherPacketType\n"
 168              "\n" ));
 169     }
 170 }
 171
 172 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 173 #undef prefix_
 174
 175 \f
 176 // Local Variables:
 177 // mode: c++
 178 // fill-column: 100
 179 // c-file-style: "senf"
 180 // indent-tabs-mode: nil
 181 // ispell-local-dictionary: "american"
 182 // compile-command: "scons -u test"
 183 // comment-column: 40
 184 // End: