TestUtilities.hpp

Go to the documentation of this file.

//
// Created by Wesley Ketchum on 10/28/24.
//
 
#ifndef DATAHANDLINGLIBS_INCLUDE_DATAHANDLINGLIBS_TESTUTILS_TESTUTILITIES_HPP
#define DATAHANDLINGLIBS_INCLUDE_DATAHANDLINGLIBS_TESTUTILS_TESTUTILITIES_HPP
 
#include "datahandlinglibs/FrameErrorRegistry.hpp"
#include "datahandlinglibs/concepts/LatencyBufferConcept.hpp"
#include "datahandlinglibs/models/DefaultRequestHandlerModel.hpp"
 
#include "boost/test/unit_test.hpp"
 
#include <cmath>
#include <iterator>
#include <memory>
#include <set>
#include <sstream>
 
namespace dunedaq {
namespace datahandlinglibs {
namespace test {
 
// general test buffer struct that can be reused
template<template<class> class BufferType, class TypeAdapter>
void
fill_buffer(std::shared_ptr<BufferType<TypeAdapter>>& buffer,
            uint64_t const init_timestamp = 0,
            size_t const n_obj = 10,
            std::set<size_t> const obj_to_skip = {})
{
 
  // allocate mem in buffer
  buffer->allocate_memory(n_obj);
 
  // some accounting
  size_t i = 0, i_obj = 0;
  uint64_t next_timestamp = init_timestamp;
 
  // while we want to add to the buffer
  while (i_obj < n_obj) {
 
    // create a frame with appropriate timestamp
    TypeAdapter frame;
    frame.fake_timestamps(next_timestamp);
 
    // increment to the next timestamp
    next_timestamp += uint64_t(frame.get_num_frames() * TypeAdapter::expected_tick_difference);
 
    // only write in buffer if not in the skip list
    if (obj_to_skip.count(i) == 0) {
      buffer->write(std::move(frame));
      ++i_obj;
    }
    ++i;
  } // end while(obj_in_buffer<n_obj)
} // end fill_buffer
 
template<template<class> class BufferType, class TypeAdapter>
void
print_buffer(std::shared_ptr<BufferType<TypeAdapter>>& buffer, std::string desc = "")
{
  std::stringstream ss;
  ss << "Buffer (" << desc << "): ";
  typename BufferType<TypeAdapter>::Iterator iter = buffer->begin();
  while (iter != buffer->end()) {
    ss << iter->get_timestamp() << " ";
    ++iter;
  }
  BOOST_TEST_MESSAGE(ss.str());
} // end print_buffer
 
template<template<class> class BufferType, class TypeAdapter>
void
test_queue_model()
{
  // some testing vars
  TypeAdapter test_element;
  uint64_t ticks_between = TypeAdapter::expected_tick_difference * test_element.get_num_frames();
 
  auto test_lower_bound = [&](std::shared_ptr<BufferType<TypeAdapter>> buffer,
                              uint64_t test_ts,
                              uint32_t expected_idx,
                              bool with_errors = false) {
    BOOST_TEST_MESSAGE("\ttesting ts=" << test_ts);
 
    TypeAdapter test_element;
    test_element.set_timestamp(test_ts);
    typename BufferType<TypeAdapter>::Iterator expected_el = buffer->begin();
    for (size_t i = 0; i < expected_idx; ++i) {
      ++expected_el;
    }
 
    // get our lower_bound call
    auto return_el = buffer->lower_bound(test_element, with_errors);
 
    // loop through to get the previous element to return_el
    typename BufferType<TypeAdapter>::Iterator scan_el = buffer->begin();
    typename BufferType<TypeAdapter>::Iterator prev_el = buffer->begin();
    while (scan_el != return_el) {
      ++scan_el;
      if (scan_el == return_el)
        break;
      ++prev_el;
    }
 
    // check that expected and return timestamps agree
    BOOST_CHECK_MESSAGE(expected_el->get_timestamp() == return_el->get_timestamp(),
                        "Expected ts{" << expected_el->get_timestamp() << "} == return ts{"
                                       << return_el->get_timestamp() << "} for test_ts=" << test_ts);
 
    // check that we satisfy the lower bound condition
    BOOST_CHECK_MESSAGE(return_el->get_timestamp() >= test_ts,
                        "Returned ts{" << return_el->get_timestamp() << "} is >= test_ts{" << test_ts << "}");
    BOOST_CHECK_MESSAGE((prev_el->get_timestamp() < test_ts || return_el == buffer->begin()),
                        "Prev ts{" << prev_el->get_timestamp() << "} is < test_ts{" << test_ts
                                   << "} (or lower bound is begin of buffer)");
  }; // end test_lower_bounds
 
  /*
   * Unskipped buffer should have elements with index [0, 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ]
   *                                   and timestamps [0,1*T,2*T,3*T,4*T,5*T,6*T,7*T,8*T,9*T]
   * where T = DTS ticks between successive elements (tick_diff_per_frame * n_frames_per_obj_in_buffer)
   */
  BOOST_TEST_MESSAGE("Testing buffer without skips...");
  auto buffer_noskip = std::make_shared<BufferType<TypeAdapter>>();
  fill_buffer<BufferType, TypeAdapter>(buffer_noskip, 0, 10);
  print_buffer<BufferType, TypeAdapter>(buffer_noskip, "noskip");
 
  // get lower bound on aligned element
  // should return the exact value
  test_lower_bound(buffer_noskip, ticks_between * 2, 2);
 
  if (ticks_between > 1) // unaligned tests don't make sense if ticks_between < 1
  {
    // get lower bound when maximally unaligned
    // should get the next element up
    test_lower_bound(buffer_noskip, ticks_between * 5 / 2, 3);
 
    // get lower bound when minimally unaligned, next instance
    test_lower_bound(buffer_noskip, ticks_between + 1, 2);
  }
 
  /*
   * Skipped buffer should have elements with index [0, 1 , 2 , 3 , 4 , 5 , 6 , 7 ,  8 ,  9 ]
   *                                 and timestamps [0,1*T,4*T,5*T,6*T,7*T,8*T,9*T,10*T,11*T]
   * where T = DTS ticks between successive elements (tick_diff_per_frame * n_frames_per_obj_in_buffer)
   */
  BOOST_TEST_MESSAGE("Testing buffer with skips...");
  std::set<size_t> obj_to_skip = { 2, 3 };
  auto buffer_skip = std::make_shared<BufferType<TypeAdapter>>();
  fill_buffer<BufferType, TypeAdapter>(buffer_skip, 0, 10, obj_to_skip);
  print_buffer<BufferType, TypeAdapter>(buffer_skip, "skip");
 
  // get lower bound on aligned but skipped element
  // should return next available
  test_lower_bound(buffer_skip, ticks_between * 2, 2, true);
  test_lower_bound(buffer_skip, ticks_between * 3, 2, true);
  // should be unaffected
  test_lower_bound(buffer_skip, ticks_between, 1, true);
  test_lower_bound(buffer_skip, ticks_between * 4, 2, true);
 
  if (ticks_between > 1) // unaligned tests don't make sense if ticks_between < 1
  {
    // get lower bound when maximally unaligned
    test_lower_bound(buffer_skip, ticks_between * 3 / 2, 2, true);
    test_lower_bound(buffer_skip, ticks_between * 5 / 2, 2, true);
    test_lower_bound(buffer_skip, ticks_between * 7 / 2, 2, true);
    // should be unaffected
    test_lower_bound(buffer_skip, ticks_between * 1 / 2, 1, true);
    test_lower_bound(buffer_skip, ticks_between * 9 / 2, 3, true);
    test_lower_bound(buffer_skip, ticks_between * 11 / 2, 4, true);
 
    // get lower bound when minimally unaligned, next instance
    test_lower_bound(buffer_skip, ticks_between + 1, 2, true);
    test_lower_bound(buffer_skip, ticks_between * 2 + 1, 2, true);
    // should be unaffected
    test_lower_bound(buffer_skip, 1, 1, true);
  }
 
} // end test_queue_model
 
template<class ReadoutType, class LatencyBufferType>
class TestDefaultRequestHandlerModel
  : public dunedaq::datahandlinglibs::DefaultRequestHandlerModel<ReadoutType, LatencyBufferType>
{
public:
  TestDefaultRequestHandlerModel(std::shared_ptr<LatencyBufferType>& latency_buffer,
                                 std::unique_ptr<dunedaq::datahandlinglibs::FrameErrorRegistry>& error_registry)
    : dunedaq::datahandlinglibs::DefaultRequestHandlerModel<ReadoutType, LatencyBufferType>(latency_buffer,
                                                                                            error_registry)
  {
  }
  using dunedaq::datahandlinglibs::DefaultRequestHandlerModel<ReadoutType, LatencyBufferType>::get_fragment_pieces;
};
 
template<template<class> class BufferType, class TypeAdapter>
void
test_request_model()
{
 
  using DefaultRequestHandler = TestDefaultRequestHandlerModel<TypeAdapter, BufferType<TypeAdapter>>;
 
  // some testing vars
  TypeAdapter test_element;
  uint64_t n_frames = test_element.get_num_frames();
  uint64_t ticks_per_frame = TypeAdapter::expected_tick_difference;
  uint64_t ticks_between = ticks_per_frame * n_frames;
 
  // function for testing get_fragment_pieces in cases where there are no skips in the buffer
  auto test_req_bounds = [&](std::shared_ptr<BufferType<TypeAdapter>> buffer,
                             uint64_t start_win,
                             uint64_t end_win,
                             std::set<size_t> objects_skipped = {}) {
    BOOST_TEST_MESSAGE("\ttesting [start_win{" << start_win << "}, end_win{" << end_win << "})");
 
    // make the error registry we need
    auto errorRegistry = std::make_unique<dunedaq::datahandlinglibs::FrameErrorRegistry>();
 
    // create the request handler
    DefaultRequestHandler requestHandler(buffer, errorRegistry);
 
    // call the get_fragment_pieces
    auto dfmessage = dunedaq::dfmessages::DataRequest();
    auto req_res =
      typename DefaultRequestHandler::RequestResult(DefaultRequestHandler::ResultCode::kUnknown, dfmessage);
    auto ret = requestHandler.get_fragment_pieces(start_win, end_win, req_res);
 
    // check that the return code is correct.
    BOOST_CHECK_EQUAL(req_res.result_code, DefaultRequestHandler::ResultCode::kFound);
 
    // check that the first and last returned blocks are not empty
    BOOST_REQUIRE_GT(ret.front().second, 0);
    BOOST_REQUIRE_GT(ret.back().second, 0);
 
    // grab the (first) timestamps of the first and last frames
    uint64_t first_ts = reinterpret_cast<const TypeAdapter::FrameType*>(ret.front().first)->get_timestamp();
 
    // if n_frames is 1, then all payloads are just one frame, and we can grab the timestamp directly
    // this is particularly useful for not having to deal with wrapper objects, as those complicate things a bunch
    // if not, then we really hope that sizeof(TypeAdapter::FrameType) is what we want ...
    uint64_t last_ts = 0;
    if (n_frames == 1)
      last_ts = reinterpret_cast<const TypeAdapter::FrameType*>(ret.back().first)->get_timestamp();
    else
      last_ts = reinterpret_cast<const TypeAdapter::FrameType*>((char*)(ret.back().first) + (ret.back().second) -
                                                                sizeof(typename TypeAdapter::FrameType))
                  ->get_timestamp();
 
    // general check:
    //  first_ts <= start_win < first_ts + ticks_per_frame
    //  last_ts < end_win <= last_ts + ticks_per_frame
    if (objects_skipped.size() == 0)
      BOOST_CHECK_MESSAGE(first_ts <= start_win,
                          "first_frame_ts{" << first_ts << "} <= start_win{" << start_win << "}");
    BOOST_CHECK_MESSAGE(start_win < first_ts + ticks_per_frame,
                        "start_win{" << start_win << "} < first_frame_ts+ticks_per_frame{" << first_ts + ticks_per_frame
                                     << "}");
    BOOST_CHECK_MESSAGE(last_ts < end_win, "Check last_frame_ts{" << last_ts << "} < end_win{" << end_win << "}");
    if (objects_skipped.size() == 0)
      BOOST_CHECK_MESSAGE(end_win <= last_ts + ticks_per_frame,
                          "end_win{" << end_win << "} <= last_frame_ts+ticks_per_frame{" << last_ts + ticks_per_frame
                                     << "}");
 
    // expected timestamps for begin of fragment and 'end' of fragment, assuming no skipping
    auto expected_start =
      TypeAdapter::expected_tick_difference * (uint64_t)std::floor((float)(start_win) / (float)(ticks_per_frame));
    auto expected_end =
      TypeAdapter::expected_tick_difference * (uint64_t)std::ceil((float)(end_win) / (float)(ticks_per_frame));
 
    // correct for the cases there that object has been skipped
    auto expected_start_obj = expected_start - expected_start % ticks_between;
    while (objects_skipped.count(expected_start_obj / ticks_between) > 0 && expected_start < expected_end) {
      expected_start += ticks_per_frame;
      expected_start_obj = expected_start - expected_start % ticks_between;
    }
 
    auto expected_end_obj = expected_end - ticks_per_frame - (expected_end - ticks_per_frame) % ticks_between;
    while (objects_skipped.count(expected_end_obj / ticks_between) > 0 &&
           expected_end > (expected_start + ticks_per_frame)) {
      expected_end -= ticks_per_frame;
      expected_start_obj = expected_end - ticks_per_frame - (expected_end - ticks_per_frame) % ticks_between;
    }
 
    // specfic check: are values for this request what we expect
    BOOST_CHECK_MESSAGE(first_ts == expected_start,
                        "Fragment start ts {" << first_ts << "} is expected value {" << expected_start << "}");
    BOOST_CHECK_MESSAGE((last_ts + TypeAdapter::expected_tick_difference) == expected_end,
                        "Fragment 'end' ts {" << last_ts + TypeAdapter::expected_tick_difference
                                              << "} is expected value {" << expected_end << "}");
  }; // end test_req_bounds
 
  /*
   * Unskipped buffer should have elements with index [0, 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ]
   *                                   and timestamps [0,1*T,2*T,3*T,4*T,5*T,6*T,7*T,8*T,9*T]
   * where T = DTS ticks between successive elements (tick_diff_per_frame * n_frames_per_obj_in_buffer)
   */
  BOOST_TEST_MESSAGE("Testing buffer without skips...");
  auto buffer_noskip = std::make_shared<BufferType<TypeAdapter>>();
  fill_buffer<BufferType, TypeAdapter>(buffer_noskip, 0, 10);
  print_buffer<BufferType, TypeAdapter>(buffer_noskip, "noskip");
 
  test_req_bounds(buffer_noskip, ticks_between * 2, ticks_between * 5);
  test_req_bounds(buffer_noskip, ticks_between * 3 / 2, ticks_between * 9 / 2);
  test_req_bounds(buffer_noskip, ticks_between * 11 / 5, ticks_between * 21 / 5);
  test_req_bounds(buffer_noskip, ticks_between * 2 + 1, ticks_between * 5 + 1);
 
  /*
   * Skipped buffer should have elements with index [0, 1 , 2 , 3 , 4 , 5 , 6 , 7 ,  8 ,  9 ]
   *                                 and timestamps [0,1*T,4*T,5*T,6*T,7*T,8*T,9*T,10*T,11*T]
   * where T = DTS ticks between successive elements (tick_diff_per_frame * n_frames_per_obj_in_buffer)
   */
  BOOST_TEST_MESSAGE("Testing buffer with skips...");
  std::set<size_t> obj_to_skip = { 2, 3 };
  auto buffer_skip = std::make_shared<BufferType<TypeAdapter>>();
  fill_buffer<BufferType, TypeAdapter>(buffer_skip, 0, 10, obj_to_skip);
  print_buffer<BufferType, TypeAdapter>(buffer_skip, "skip");
 
  test_req_bounds(buffer_skip, ticks_between * 2, ticks_between * 5, obj_to_skip);
  test_req_bounds(buffer_skip, ticks_between * 3 / 2, ticks_between * 9 / 2, obj_to_skip);
  if ((ticks_between * 21 / 5) > 4 * ticks_between) // protect in cases where ticks_between is very small (e.g. 1)
    test_req_bounds(buffer_skip, ticks_between * 11 / 5, ticks_between * 21 / 5, obj_to_skip);
  test_req_bounds(buffer_skip, ticks_between * 2 + 1, ticks_between * 5 + 1, obj_to_skip);
 
} // end test_request_model
 
} // namespace test
} // namespace datahandlinglibs
} // namespace dunedaq
 
#endif // DATAHANDLINGLIBS_INCLUDE_DATAHANDLINGLIBS_TESTUTILS_TESTUTILITIES_HPP