RawDigit_test.cc File Reference

Simple test on a raw::RawDigit object. More...

#include <algorithm>
#include "boost/test/unit_test.hpp"
#include "larcoreobj/SimpleTypesAndConstants/RawTypes.h"
#include "lardataobj/RawData/raw.h"
#include "lardataobj/RawData/RawDigit.h"

Go to the source code of this file.

Macros
#define	BOOST_TEST_MODULE   ( rawdigit_test )

Functions
void	CheckRawDigit (raw::RawDigit const &digits, raw::ChannelID_t channel, unsigned short samples, raw::RawDigit::ADCvector_t const &uncompressed_adclist, raw::Compress_t compression)
void	RawDigitTestDefaultConstructor ()
void	RawDigitTestCustomConstructors ()
void	FibonacciCompressionTestCustomConstructor ()
	BOOST_AUTO_TEST_CASE (RawDigitDefaultConstructor)
	BOOST_AUTO_TEST_CASE (RawDigitCustomConstructors)
	BOOST_AUTO_TEST_CASE (FibonacciCompressionConstructor)

Detailed Description

Simple test on a raw::RawDigit object.

Author

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

Date

20150114

Version

1.0

This test simply creates raw::RawDigit objects and verifies that the values it can access are the right ones.

See http://www.boost.org/libs/test for the Boost test library home page.

Timing: version 1.0: <1" (debug mode)

Definition in file RawDigit_test.cc.

Macro Definition Documentation

#define BOOST_TEST_MODULE   ( rawdigit_test )

Definition at line 31 of file RawDigit_test.cc.

Function Documentation

BOOST_AUTO_TEST_CASE

(

RawDigitDefaultConstructor

)

Definition at line 192 of file RawDigit_test.cc.

                                                 {
  RawDigitTestDefaultConstructor();
}

BOOST_AUTO_TEST_CASE

(

RawDigitCustomConstructors

)

Definition at line 196 of file RawDigit_test.cc.

                                                 {
  RawDigitTestCustomConstructors();
}

BOOST_AUTO_TEST_CASE

(

FibonacciCompressionConstructor

)

Definition at line 200 of file RawDigit_test.cc.

                                                      {
  FibonacciCompressionTestCustomConstructor();
}

void CheckRawDigit	(	raw::RawDigit const &	digits,
		raw::ChannelID_t	channel,
		unsigned short	samples,
		raw::RawDigit::ADCvector_t const &	uncompressed_adclist,
		raw::Compress_t	compression
	)

Definition at line 46 of file RawDigit_test.cc.

  {

  // this is a parameters validation check
  BOOST_TEST(samples == uncompressed_adclist.size());

  // verify that the values are as expected
  // - channel ID
  BOOST_TEST(digits.Channel() == channel);

  // - compression mode
  BOOST_TEST(digits.Compression() == compression);

  // - uncompressed size
  BOOST_TEST(digits.Samples() == samples);
  BOOST_TEST(digits.Samples() == uncompressed_adclist.size());

  // - digits

  // decompress (on an already allocated buffer)
  raw::RawDigit::ADCvector_t ADCs(digits.Samples());
  raw::Uncompress(digits.ADCs(), ADCs, digits.Compression());

  BOOST_WARN(digits.NADC() <= samples); // is this always the case?
  BOOST_TEST
    (std::equal(ADCs.begin(), ADCs.end(), uncompressed_adclist.begin()));

  // - others
  BOOST_TEST(digits.GetPedestal() == 0.);
  BOOST_TEST(digits.GetSigma() == 0.);

} // CheckRawDigit()

void FibonacciCompressionTestCustomConstructor

(

)

Definition at line 155 of file RawDigit_test.cc.

                                                 {

  //
  // Part I: initialization of wire inputs
  //
  const raw::ChannelID_t channel = 12;
  const unsigned short samples = 1000;
  raw::RawDigit::ADCvector_t adclist(samples);
  for (size_t i = 0; i < samples; ++i)
    adclist[i] = (i % 3)? 0: i;
  const raw::Compress_t compression = raw::kHuffman;

// working a copy of the original data:
  std::vector<short> buffer(adclist);
  raw::Compress(buffer, compression); // compression happens in place

  //
  // Part II: constructor with signal copy
  //
  // step II.1: create a wire with the signal-copying constructor
  raw::RawDigit digits1(channel, samples, buffer, compression /*, flags */);

  // step II.2: verify that the values are as expected
  CheckRawDigit(digits1, channel, samples, adclist, compression);

} // FibonacciCompressionTestCustomConstructors()

void RawDigitTestCustomConstructors

(

)

Definition at line 110 of file RawDigit_test.cc.

                                      {

  //
  // Part I: initialization of wire inputs
  //
  const raw::ChannelID_t channel = 12;
  const unsigned short samples = 1000;
  raw::RawDigit::ADCvector_t adclist(samples);
  for (size_t i = 0; i < samples; ++i)
    adclist[i] = (i % 3)? 0: i;
  const raw::Compress_t compression = raw::kHuffman;
// raw::RawDigit::Flags_t flags;

  // working a copy of the original data:
  std::vector<short> buffer(adclist);
  raw::Compress(buffer, compression); // compression happens in place


  //
  // Part II: constructor with signal copy
  //
  // step II.1: create a wire with the signal-copying constructor
  raw::RawDigit digits1(channel, samples, buffer, compression /*, flags */);

  // step II.2: verify that the values are as expected
  CheckRawDigit(digits1, channel, samples, adclist, compression);


  //
  // Part III: constructor with signal move
  //
  // step III.1: create a wire with the signal-moving constructor
  std::vector<short> buffer_copy(buffer);
  raw::RawDigit digits2
    (channel, samples, std::move(buffer_copy), compression /*, flags */);

  // step III.2: verify that the values are as expected
  CheckRawDigit(digits2, channel, samples, adclist, compression);

  // step III.3: verify that the data was actually moved
  BOOST_TEST(buffer_copy.empty());

} // RawDigitTestCustomConstructors()

void RawDigitTestDefaultConstructor

(

)

Definition at line 85 of file RawDigit_test.cc.

                                      {

  //
  // Part I: initialization of wire inputs
  //
  // these are the values expected for a default-constructed wire
  const raw::ChannelID_t channel = raw::InvalidChannelID;
  const unsigned short samples = 0;
  raw::RawDigit::ADCvector_t adclist;
  const raw::Compress_t compression = raw::kNone;
// raw::RawDigit::Flags_t flags;

  //
  // Part II: default constructor
  //
  // step II.1: create a wire with the signal-copying constructor
  raw::RawDigit digits;


  // step II.2: verify that the values are as expected
  CheckRawDigit(digits, channel, samples, adclist, compression);

} // RawDigitTestDefaultConstructor()