SimpleChannelStatus_test.cxx File Reference

Test of SimpleChannelStatus. More...

#include "boost/test/unit_test.hpp"
#include "larevt/Filters/SimpleChannelStatus.h"
#include "larcoreobj/SimpleTypesAndConstants/RawTypes.h"
#include "fhiclcpp/ParameterSet.h"
#include "fhiclcpp/coding.h"
#include <any>
#include <iostream>
#include <ostream>
#include <set>
#include <memory>
#include <algorithm>

Go to the source code of this file.

Classes
class	StatusConfiguration

Macros
#define	BOOST_TEST_MODULE   ( simple_channel_status_test )

Functions
template<typename T >
fhicl::detail::ps_sequence_t	std::encode (std::set< T > const &s)
template<typename T >
std::ostream &	std::operator<< (std::ostream &out, std::set< T > const &s)
void	test_simple_status ()
	BOOST_AUTO_TEST_CASE (SimpleStatusTest)

Detailed Description

Test of SimpleChannelStatus.

Author

Gianluca Petrillo (petri.nosp@m.llo@.nosp@m.fnal..nosp@m.gov)

Date

July 17th, 2015

Definition in file SimpleChannelStatus_test.cxx.

Macro Definition Documentation

#define BOOST_TEST_MODULE   ( simple_channel_status_test )

Definition at line 18 of file SimpleChannelStatus_test.cxx.

Function Documentation

BOOST_AUTO_TEST_CASE

(

SimpleStatusTest

)

Definition at line 215 of file SimpleChannelStatus_test.cxx.

                                       {
  test_simple_status();
}

template<typename T >

fhicl::detail::ps_sequence_t std::encode

(

std::set< T > const &

s

)

Definition at line 41 of file SimpleChannelStatus_test.cxx.

                                                      {
    fhicl::detail::ps_sequence_t result;
    result.reserve(s.size());
    std::transform(s.begin(), s.end(), std::inserter(result, result.end()),
      [](T const& value) { return std::any(fhicl::detail::encode(value)); }
      );
    return result;
  } // encode(set<T>)

template<typename T >

std::ostream& std::operator<<	(	std::ostream &	out,
		std::set< T > const &	s
	)

Definition at line 52 of file SimpleChannelStatus_test.cxx.

                                                               {
    out << "{";
    typename std::set<T>::const_iterator begin = s.cbegin(), end = s.cend();
    if (begin != end) {
      out << " " << *begin;
      while (++begin != end) out << ", " << *begin;
      out << " ";
    } // if not empty
    out << "}";
    return out;
  } // operator<< (ostream, set<T>)

void test_simple_status

(

)

Public interface:

bool isPresent(raw::ChannelID_t channel) const

bool isGood(raw::ChannelID_t channel) const

bool isBad(raw::ChannelID_t channel) const

bool isNoisy(raw::ChannelID_t channel) const

ChannelSet_t GoodChannels() const

ChannelSet_t BadChannels() const

ChannelSet_t NoisyChannels() const

Definition at line 127 of file SimpleChannelStatus_test.cxx.

                          {

  StatusConfiguration statusCreator(
           /* MaxChannel */ 20,
    /* MaxPresentChannel */ 15,
          /* BadChannels */ { 1, 9, 13 },
        /* NoisyChannels */ { 6, 8, 10, 11, 12, 13 }
    );

  BOOST_TEST_CHECKPOINT("Creating simple status");
  std::unique_ptr<lariov::SimpleChannelStatus> StatusOwner
    = statusCreator.CreateStatus();

  lariov::SimpleChannelStatus const* pSimpleStatus = StatusOwner.get();

  // check the values of the extremes
  BOOST_TEST(pSimpleStatus->MaxChannel() == statusCreator.fMaxChannel);
  BOOST_TEST
    (pSimpleStatus->MaxChannelPresent() == statusCreator.fMaxPresentChannel);

  // downcast to the interface to test interface stuff
  lariov::ChannelStatusProvider const* pStatus = pSimpleStatus;

  /**
   *
   * Public interface:
   *
   * bool isPresent(raw::ChannelID_t channel) const
   *
   * bool isGood(raw::ChannelID_t channel) const
   *
   * bool isBad(raw::ChannelID_t channel) const
   *
   * bool isNoisy(raw::ChannelID_t channel) const
   *
   * ChannelSet_t GoodChannels() const
   *
   * ChannelSet_t BadChannels() const
   *
   * ChannelSet_t NoisyChannels() const
   *
   */

  // ChannelStatusBaseInterface::BadChannels()
  std::set<raw::ChannelID_t> StatusBadChannels = pStatus->BadChannels();
  BOOST_TEST
    (StatusBadChannels.size() == statusCreator.fBadChannels.size());
  BOOST_TEST(StatusBadChannels == statusCreator.fBadChannels);

  // ChannelStatusBaseInterface::NoisyChannels()
  std::set<raw::ChannelID_t> StatusNoisyChannels = pStatus->NoisyChannels();
  BOOST_TEST
    (StatusNoisyChannels.size() == statusCreator.fNoisyChannels.size());
  BOOST_TEST(StatusNoisyChannels == statusCreator.fNoisyChannels);

  std::set<raw::ChannelID_t> GoodChannels;

  for (raw::ChannelID_t channel = 0; channel <= statusCreator.fMaxChannel;
    ++channel
  ) {

    const bool bPresent = raw::isValidChannelID(channel)
      && (channel <= statusCreator.fMaxPresentChannel);
    const bool bBad = (statusCreator.fBadChannels.count(channel) > 0);
    const bool bNoisy = (statusCreator.fNoisyChannels.count(channel) > 0);
    const bool bGood = bPresent && !bBad && !bNoisy;

    if (bGood) GoodChannels.insert(channel);

    BOOST_TEST(pStatus->IsPresent(channel) == bPresent);
    BOOST_TEST(pStatus->IsBad(channel) == bBad);
    BOOST_TEST(pStatus->IsNoisy(channel) == bNoisy);

    BOOST_TEST(pStatus->IsGood(channel) == bGood);

  } // for channel

  // ChannelStatusBaseInterface::GoodChannels()
  std::set<raw::ChannelID_t> StatusGoodChannels = pStatus->GoodChannels();
  BOOST_TEST(StatusGoodChannels.size() == GoodChannels.size());
  BOOST_TEST(StatusGoodChannels == GoodChannels);

} // test_simple_status()