tests/test_comm-manager.cpp

   1 /*
   2  *  Copyright (c) 2000 - 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Licensed under the Apache License, Version 2.0 (the "License");
   5  *  you may not use this file except in compliance with the License.
   6  *  You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an "AS IS" BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License
  15  */
  16 /*
  17  * @file       test_comm-manager.cpp
  18  * @author     Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
  19  * @version    1.0
  20  */
  21
  22 #include <boost/test/unit_test.hpp>
  23 #include <boost/test/results_reporter.hpp>
  24 #include <communication-manager.h>
  25 #include <string>
  26 #include <random>
  27 #include <chrono>
  28
  29 namespace {
  30 struct MessageA {
  31     MessageA(int ai) : i(ai) {}
  32     int i;
  33 };
  34
  35 struct MessageB {
  36     MessageB(char ac) : c(ac) {}
  37     char c;
  38 };
  39
  40 struct MessageC {
  41     MessageC(const std::string& astr) : str(astr) {}
  42     std::string str;
  43 };
  44
  45 struct Listener {
  46     Listener() : i(0) {}
  47
  48     void Handle(const MessageA& msg) {
  49         i = msg.i;
  50     }
  51
  52     void Handle(const MessageC& msg) {
  53         str = msg.str;
  54     }
  55
  56     int i;
  57     std::string str;
  58 };
  59
  60 } // namespace anonymous
  61
  62 BOOST_AUTO_TEST_SUITE(MESSAGE_MANAGER_TEST)
  63
  64 BOOST_AUTO_TEST_CASE(TMM_0010_NoListener) {
  65     CKM::CommunicationManager<MessageA> mgr;
  66     //int reci = 0;
  67     mgr.SendMessage(MessageA(22));
  68 }
  69
  70 BOOST_AUTO_TEST_CASE(TMM_0020_Basic) {
  71     CKM::CommunicationManager<MessageA> mgr;
  72     int received = 0;
  73     mgr.Register<MessageA>([&](const MessageA& msg){ received = msg.i; });
  74     mgr.SendMessage(MessageA(4));
  75     BOOST_REQUIRE_MESSAGE(received != 0, "Message not received");
  76     BOOST_REQUIRE_MESSAGE(received == 4, "Wrong message received i=" << received);
  77 }
  78
  79 BOOST_AUTO_TEST_CASE(TMM_0030_MultipleMessages) {
  80     CKM::CommunicationManager<MessageA, MessageB> mgr;
  81     int reci = 0;
  82     char recc = 0;
  83     mgr.Register<MessageA>([&](const MessageA& msg){ reci = msg.i; });
  84     mgr.Register<MessageB>([&](const MessageB& msg){ recc = msg.c; });
  85     mgr.SendMessage(MessageB('c'));
  86     BOOST_REQUIRE_MESSAGE(reci == 0, "Unexpected message received");
  87     BOOST_REQUIRE_MESSAGE(recc != 0, "Message not received");
  88     BOOST_REQUIRE_MESSAGE(recc == 'c', "Wrong message received c=" << recc);
  89
  90     mgr.SendMessage(MessageA(42));
  91     BOOST_REQUIRE_MESSAGE(reci!= 0, "Message not received");
  92     BOOST_REQUIRE_MESSAGE(reci == 42, "Wrong message received i=" << reci);
  93     BOOST_REQUIRE_MESSAGE(recc == 'c', "Previous message overwritten c=" << recc);
  94 }
  95
  96 BOOST_AUTO_TEST_CASE(TMM_0040_Listener) {
  97     CKM::CommunicationManager<MessageA, MessageB, MessageC> mgr;
  98     Listener l;
  99     mgr.Register<MessageC>([&](const MessageC& msg){ l.Handle(msg); });
 100     mgr.Register<MessageA>([&](const MessageA& msg){ l.Handle(msg); });
 101
 102     mgr.SendMessage(MessageC("lorem ipsum"));
 103     BOOST_REQUIRE_MESSAGE(l.i == 0, "Unexpected message received");
 104     BOOST_REQUIRE_MESSAGE(!l.str.empty(), "Message not received");
 105     BOOST_REQUIRE_MESSAGE(l.str == "lorem ipsum", "Wrong message received c=" << l.str);
 106
 107     mgr.SendMessage(MessageA(3));
 108     BOOST_REQUIRE_MESSAGE(l.i!= 0, "Message not received");
 109     BOOST_REQUIRE_MESSAGE(l.i == 3, "Wrong message received i=" << l.i);
 110     BOOST_REQUIRE_MESSAGE(l.str == "lorem ipsum", "Previous message overwritten str=" << l.str);
 111 }
 112
 113 BOOST_AUTO_TEST_CASE(TMM_0050_2Listeners) {
 114     CKM::CommunicationManager<MessageA> mgr;
 115     bool called[2];
 116     called[0] = false;
 117     called[1] = false;
 118     mgr.Register<MessageA>([&](const MessageA& msg){
 119         BOOST_REQUIRE_MESSAGE(msg.i == 5, "Unexpected message received i=" << msg.i);
 120         called[0] = true;
 121     });
 122     mgr.Register<MessageA>([&](const MessageA& msg){
 123         BOOST_REQUIRE_MESSAGE(msg.i == 5, "Unexpected message received i=" << msg.i);
 124         called[1] = true;
 125     });
 126
 127     mgr.SendMessage(MessageA(5));
 128     BOOST_REQUIRE_MESSAGE(called[0], "First listener not called");
 129     BOOST_REQUIRE_MESSAGE(called[1], "Second listener not called");
 130 }
 131
 132 BOOST_AUTO_TEST_CASE(TMM_0060_Stress) {
 133     CKM::CommunicationManager<MessageA, MessageB, MessageC> mgr;
 134
 135     std::default_random_engine generator(std::chrono::system_clock::now().time_since_epoch().count());
 136     std::uniform_int_distribution<size_t> message_dist(0,2);
 137     std::uniform_int_distribution<size_t> count_dist(1,10);
 138
 139     size_t a = 0;
 140     size_t b = 0;
 141     size_t c = 0;
 142     mgr.Register<MessageA>([&](const MessageA& msg) {
 143         BOOST_REQUIRE_MESSAGE(msg.i == 42, "Wrong message: " << msg.i);
 144         a++;
 145     });
 146     mgr.Register<MessageB>([&](const MessageB& msg) {
 147         BOOST_REQUIRE_MESSAGE(msg.c == 'c', "Wrong message: " << msg.c);
 148         b++;
 149     });
 150     mgr.Register<MessageC>([&](const MessageC& msg) {
 151         BOOST_REQUIRE_MESSAGE(msg.str == "lorem ipsum", "Wrong message: " << msg.str);
 152         c++;
 153     });
 154
 155     for (size_t i=0; i < 1000; i++)
 156     {
 157         size_t cnt = count_dist(generator);
 158         for (size_t s = 0; s < cnt; s++) {
 159             switch(message_dist(generator))
 160             {
 161             case 0:
 162                 mgr.SendMessage(MessageA(42));
 163                 a--;
 164                 break;
 165             case 1:
 166                 mgr.SendMessage(MessageB('c'));
 167                 b--;
 168                 break;
 169             case 2:
 170                 mgr.SendMessage(MessageC("lorem ipsum"));
 171                 c--;
 172                 break;
 173             default:
 174                 BOOST_FAIL("Unexpected message type");
 175             }
 176         }
 177     }
 178     BOOST_REQUIRE_MESSAGE(a == 0, "Unexpected number of MessageA: " << a);
 179     BOOST_REQUIRE_MESSAGE(b == 0, "Unexpected number of MessageB: " << b);
 180     BOOST_REQUIRE_MESSAGE(c == 0, "Unexpected number of MessageC: " << c);
 181 }
 182
 183 BOOST_AUTO_TEST_SUITE_END()
 184
 185