Line data    Source code

       1              : /**
       2              :  * @file Queue_test.cxx Queue class Unit Tests
       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 "iomanager/queue/Queue.hpp"
      10              : 
      11              : #define BOOST_TEST_MODULE Queue_test // NOLINT
      12              : 
      13              : #include "boost/test/unit_test.hpp"
      14              : 
      15              : #include <memory>
      16              : #include <string>
      17              : #include <type_traits>
      18              : 
      19              : BOOST_AUTO_TEST_SUITE(Queue_test)
      20              : 
      21              : using namespace dunedaq::iomanager;
      22              : 
      23              : namespace queuetest {
      24              : template<class T>
      25              : class TestQueue : public Queue<T>
      26              : {
      27              : public:
      28            1 :   explicit TestQueue(const std::string& name)
      29            1 :     : Queue<T>(name)
      30              :   {
      31            1 :   }
      32              : 
      33            3 :   void push(T&& push, const std::chrono::milliseconds& tmo) override
      34              :   {
      35            3 :     if (elem_count == 0) {
      36            2 :       elem = push;
      37            2 :       elem_count = 1;
      38            2 :       return;
      39              :     }
      40            1 :     throw QueueTimeoutExpired(ERS_HERE, "TestQueue", "push", tmo.count());
      41              :   }
      42            3 :   void pop(T& pop, const std::chrono::milliseconds& tmo) override
      43              :   {
      44            3 :     if (elem_count == 1) {
      45            2 :       pop = elem;
      46            2 :       elem_count = 0;
      47            2 :       return;
      48              :     }
      49            1 :     throw QueueTimeoutExpired(ERS_HERE, "TestQueue", "pop", tmo.count());
      50              :   }
      51            2 :   bool try_push(T&& push, const std::chrono::milliseconds&) override
      52              :   {
      53            2 :     if (elem_count == 0) {
      54            1 :       elem = push;
      55            1 :       elem_count = 1;
      56            1 :       return true;
      57              :     }
      58              :     return false;
      59              :   }
      60            2 :   bool try_pop(T& pop, const std::chrono::milliseconds&) override
      61              :   {
      62            2 :     if (elem_count == 1) {
      63            1 :       pop = elem;
      64            1 :       elem_count = 0;
      65            1 :       return true;
      66              :     }
      67              :     return false;
      68              :   }
      69            8 :   size_t get_capacity() const override { return 1; }
      70           17 :   size_t get_num_elements() const override { return elem_count; }
      71              : 
      72              : private:
      73              :   T elem;
      74              :   size_t elem_count{ 0 };
      75              : };
      76              : } // namespace queuetest
      77              : 
      78            2 : BOOST_AUTO_TEST_CASE(QueueOperations)
      79              : {
      80              : 
      81            1 :   auto queue_ptr = std::shared_ptr<Queue<int>>(new queuetest::TestQueue<int>("test_queue"));
      82            1 :   BOOST_REQUIRE(queue_ptr != nullptr);
      83              : 
      84            1 :   BOOST_REQUIRE_EQUAL(queue_ptr->get_capacity(), 1);
      85            1 :   BOOST_REQUIRE_EQUAL(queue_ptr->get_num_elements(), 0);
      86              : 
      87            1 :   BOOST_REQUIRE(queue_ptr->can_push());
      88            1 :   BOOST_REQUIRE(!queue_ptr->can_pop());
      89              : 
      90            1 :   queue_ptr->push(15, std::chrono::milliseconds(1));
      91              : 
      92            1 :   BOOST_REQUIRE(!queue_ptr->can_push());
      93            1 :   BOOST_REQUIRE(queue_ptr->can_pop());
      94            1 :   BOOST_REQUIRE_EQUAL(queue_ptr->get_num_elements(), 1);
      95              : 
      96            1 :   int pop_value = 0;
      97            1 :   queue_ptr->pop(pop_value, std::chrono::milliseconds(1));
      98            1 :   BOOST_REQUIRE_EQUAL(pop_value, 15);
      99              : 
     100            1 :   BOOST_REQUIRE(queue_ptr->can_push());
     101            1 :   BOOST_REQUIRE(!queue_ptr->can_pop());
     102            1 :   BOOST_REQUIRE_EQUAL(queue_ptr->get_num_elements(), 0);
     103              : 
     104            3 :   BOOST_REQUIRE_EXCEPTION(queue_ptr->pop(pop_value, std::chrono::milliseconds(1)),
     105              :                           QueueTimeoutExpired,
     106              :                           [](QueueTimeoutExpired const&) { return true; });
     107            1 :   queue_ptr->push(16, std::chrono::milliseconds(1));
     108              : 
     109            1 :   BOOST_REQUIRE(!queue_ptr->can_push());
     110            1 :   BOOST_REQUIRE(queue_ptr->can_pop());
     111              : 
     112            3 :   BOOST_REQUIRE_EXCEPTION(queue_ptr->push(17, std::chrono::milliseconds(1)),
     113              :                           QueueTimeoutExpired,
     114              :                           [](QueueTimeoutExpired const&) { return true; });
     115            1 :   queue_ptr->pop(pop_value, std::chrono::milliseconds(1));
     116            1 :   BOOST_REQUIRE_EQUAL(pop_value, 16);
     117              : 
     118            1 :   BOOST_REQUIRE(queue_ptr->can_push());
     119            1 :   BOOST_REQUIRE(!queue_ptr->can_pop());
     120              : 
     121            1 :   auto ret = queue_ptr->try_pop(pop_value, std::chrono::milliseconds(1));
     122            1 :   BOOST_REQUIRE(ret == false);
     123            1 :   ret = queue_ptr->try_push(18, std::chrono::milliseconds(1));
     124              : 
     125            1 :   BOOST_REQUIRE(ret);
     126            1 :   BOOST_REQUIRE(!queue_ptr->can_push());
     127            1 :   BOOST_REQUIRE(queue_ptr->can_pop());
     128              : 
     129            1 :   ret = queue_ptr->try_push(19, std::chrono::milliseconds(1));
     130            1 :   BOOST_REQUIRE(ret == false);
     131            1 :   ret = queue_ptr->try_pop(pop_value, std::chrono::milliseconds(1));
     132            1 :   BOOST_REQUIRE_EQUAL(pop_value, 18);
     133            1 :   BOOST_REQUIRE(ret);
     134            1 :   BOOST_REQUIRE(queue_ptr->can_push());
     135            1 :   BOOST_REQUIRE(!queue_ptr->can_pop());
     136            1 : }
     137              : 
     138              : BOOST_AUTO_TEST_SUITE_END()