Line data    Source code

       1              : /**
       2              :  * @file ZmqSendReceive_test.cxx Test ZmqSender to ZmqReceiver transfer
       3              :  *
       4              :  * This is part of the DUNE DAQ Application Framework, copyright 2020.
       5              :  * Licensing/copyright details are in the COPYING file that you should have
       6              :  * received with this code.
       7              :  */
       8              : 
       9              : #include "ipm/Receiver.hpp"
      10              : #include "ipm/Sender.hpp"
      11              : 
      12              : #define BOOST_TEST_MODULE ZmqSendReceive_test // NOLINT
      13              : 
      14              : #include "boost/test/unit_test.hpp"
      15              : 
      16              : #include <string>
      17              : #include <vector>
      18              : 
      19              : using namespace dunedaq::ipm;
      20              : 
      21              : BOOST_AUTO_TEST_SUITE(ZmqSendReceive_test)
      22              : 
      23            2 : BOOST_AUTO_TEST_CASE(SendReceiveTest)
      24              : {
      25            1 :   auto the_receiver = make_ipm_receiver("ZmqReceiver");
      26            1 :   BOOST_REQUIRE(the_receiver != nullptr);
      27            1 :   BOOST_REQUIRE(!the_receiver->can_receive());
      28              : 
      29            1 :   auto the_sender = make_ipm_sender("ZmqSender");
      30            1 :   BOOST_REQUIRE(the_sender != nullptr);
      31            1 :   BOOST_REQUIRE(!the_sender->can_send());
      32              : 
      33            1 :   nlohmann::json empty_json = nlohmann::json::object();
      34            1 :   the_receiver->connect_for_receives(empty_json);
      35            1 :   the_sender->connect_for_sends(empty_json);
      36              : 
      37            1 :   BOOST_REQUIRE(the_receiver->can_receive());
      38            1 :   BOOST_REQUIRE(the_sender->can_send());
      39              : 
      40            1 :   std::vector<char> test_data{ 'T', 'E', 'S', 'T' };
      41              : 
      42            1 :   the_sender->send(test_data.data(), test_data.size(), Sender::s_no_block);
      43            1 :   auto response = the_receiver->receive(Receiver::s_block);
      44            1 :   BOOST_REQUIRE_EQUAL(response.data.size(), 4);
      45            1 :   BOOST_REQUIRE_EQUAL(response.data[0], 'T');
      46            1 :   BOOST_REQUIRE_EQUAL(response.data[1], 'E');
      47            1 :   BOOST_REQUIRE_EQUAL(response.data[2], 'S');
      48            1 :   BOOST_REQUIRE_EQUAL(response.data[3], 'T');
      49            1 : }
      50              : 
      51            2 : BOOST_AUTO_TEST_CASE(CallbackTest)
      52              : {
      53              : 
      54            1 :   auto the_receiver = make_ipm_receiver("ZmqReceiver");
      55            1 :   BOOST_REQUIRE(the_receiver != nullptr);
      56            1 :   BOOST_REQUIRE(!the_receiver->can_receive());
      57              : 
      58            1 :   auto the_sender = make_ipm_sender("ZmqSender");
      59            1 :   BOOST_REQUIRE(the_sender != nullptr);
      60            1 :   BOOST_REQUIRE(!the_sender->can_send());
      61              : 
      62            1 :   nlohmann::json empty_json = nlohmann::json::object();
      63            1 :   the_receiver->connect_for_receives(empty_json);
      64            1 :   the_sender->connect_for_sends(empty_json);
      65              : 
      66            1 :   BOOST_REQUIRE(the_receiver->can_receive());
      67            1 :   BOOST_REQUIRE(the_sender->can_send());
      68              : 
      69            1 :   std::vector<char> test_data{ 'T', 'E', 'S', 'T' };
      70            1 :   std::atomic<bool> message_received = false;
      71              : 
      72            3 :   auto callback_fun = [&](Receiver::Response& res) {
      73            2 :     BOOST_REQUIRE_EQUAL(res.data.size(), test_data.size());
      74           18 :     for (size_t ii = 0; ii < res.data.size(); ++ii) {
      75           16 :       BOOST_REQUIRE_EQUAL(res.data[ii], test_data[ii]);
      76              :     }
      77            2 :     message_received = true;
      78            3 :   };
      79            1 :   the_receiver->register_callback(callback_fun);
      80              : 
      81            1 :   the_sender->send(test_data.data(), test_data.size(), Sender::s_no_block);
      82            2 :   while (!message_received.load()) {
      83            1 :     usleep(15000);
      84              :   }
      85              : 
      86            1 :   message_received = false;
      87            1 :   test_data = { 'A', 'N', 'O', 'T', 'H', 'E', 'R', ' ', 'T', 'E', 'S', 'T' };
      88            1 :   the_sender->send(test_data.data(), test_data.size(), Sender::s_no_block);
      89            2 :   while (!message_received.load()) {
      90            1 :     usleep(15000);
      91              :   }
      92              : 
      93            1 :   message_received = false;
      94            1 :   test_data = { 'A', ' ', 'T', 'H', 'I', 'R', 'D', ' ', 'T', 'E', 'S', 'T' };
      95            1 :   the_receiver->unregister_callback();
      96            1 :   the_sender->send(test_data.data(), test_data.size(), Sender::s_no_block);
      97              : 
      98            1 :   usleep(100000);
      99            1 :   BOOST_REQUIRE_EQUAL(message_received, false);
     100            1 : }
     101              : 
     102              : BOOST_AUTO_TEST_SUITE_END()