WaveformOperations_test.cc File Reference

Unit test for waveform operations. More...

#include <boost/test/unit_test.hpp>
#include "icarusalg/Utilities/WaveformOperations.h"

Go to the source code of this file.

Macros
#define	BOOST_TEST_MODULE   WaveformOperationsTest

Functions
void	NegativePolarityTest ()
void	PositivePolarityTest ()
	BOOST_AUTO_TEST_CASE (AllTests)

Detailed Description

Unit test for waveform operations.

Date

June 27, 2019

Author

Gianluca Petrillo (petri.nosp@m.llo@.nosp@m.slac..nosp@m.stan.nosp@m.ford..nosp@m.edu)

See Also

icarusalg/Utilities/WaveformOperations.h

Definition in file WaveformOperations_test.cc.

Macro Definition Documentation

#define BOOST_TEST_MODULE   WaveformOperationsTest

Definition at line 10 of file WaveformOperations_test.cc.

Function Documentation

BOOST_AUTO_TEST_CASE

(

AllTests

)

Definition at line 128 of file WaveformOperations_test.cc.

                                 {
  
  NegativePolarityTest();
  PositivePolarityTest();
  
} // BOOST_AUTO_TEST_CASE( AllTests )

void NegativePolarityTest

(

)

Definition at line 18 of file WaveformOperations_test.cc.

                            {
  
  using Sample_t = signed short int;
  
  using NegOp = icarus::waveform_operations::NegativePolarityOperations<Sample_t>;
  
  // negative polarity waveform with baseline +8000
  constexpr NegOp op(+8000);
  
  //
  // "absolute" operations
  //
  
  static_assert(NegOp::distance(+8000, +7000) == +1000);
  static_assert(NegOp::distance(+8000, +9000) == -1000);
  
  static_assert(NegOp::shiftBy(+8000, +1000) == +7000);
  static_assert(NegOp::shiftBy(+8000, -1000) == +9000);
  
  static_assert(NegOp::subtractBaseline(+7000, +8000) == +1000);
  static_assert(NegOp::subtractBaseline(+9000, +8000) == -1000);
  
  //
  // comparisons
  //
  
  static_assert( (NegOp::lessThan     (+8000, +7000)));
  static_assert(!(NegOp::lessThan     (+8000, +8000)));
  static_assert(!(NegOp::lessThan     (+8000, +9000)));
  static_assert(!(NegOp::greaterThan  (+8000, +7000)));
  static_assert(!(NegOp::greaterThan  (+8000, +8000)));
  static_assert( (NegOp::greaterThan  (+8000, +9000)));
  static_assert(!(NegOp::noLessThan   (+8000, +7000)));
  static_assert( (NegOp::noLessThan   (+8000, +8000)));
  static_assert( (NegOp::noLessThan   (+8000, +9000)));
  static_assert( (NegOp::noGreaterThan(+8000, +7000)));
  static_assert( (NegOp::noGreaterThan(+8000, +8000)));
  static_assert(!(NegOp::noGreaterThan(+8000, +9000)));
  
  //
  // operations relative to the baseline
  //
  
  static_assert(op.shiftFromBaseline(+1000) == +7000);
  static_assert(op.shiftFromBaseline(-1000) == +9000);
  
  static_assert(op.subtractBaseline(+7000) == +1000);
  static_assert(op.subtractBaseline(+9000) == -1000);
  
  
} // void NegativePolarityTest()

void PositivePolarityTest

(

)

Definition at line 72 of file WaveformOperations_test.cc.

                            {
  
  using Sample_t = signed short int;
  
  using PosOp = icarus::waveform_operations::PositivePolarityOperations<Sample_t>;
  
  // negative polarity waveform with baseline +8000
  constexpr PosOp op(+8000);
  
  //
  // "absolute" operations
  //
  
  static_assert(PosOp::distance(+8000, +9000) == +1000);
  static_assert(PosOp::distance(+8000, +7000) == -1000);
  
  static_assert(PosOp::shiftBy(+8000, +1000) == +9000);
  static_assert(PosOp::shiftBy(+8000, -1000) == +7000);
  
  static_assert(PosOp::subtractBaseline(+9000, +8000) == +1000);
  static_assert(PosOp::subtractBaseline(+7000, +8000) == -1000);
  
  //
  // comparisons
  //
  
  static_assert(!(PosOp::lessThan     (+8000, +7000)));
  static_assert(!(PosOp::lessThan     (+8000, +8000)));
  static_assert( (PosOp::lessThan     (+8000, +9000)));
  static_assert( (PosOp::greaterThan  (+8000, +7000)));
  static_assert(!(PosOp::greaterThan  (+8000, +8000)));
  static_assert(!(PosOp::greaterThan  (+8000, +9000)));
  static_assert( (PosOp::noLessThan   (+8000, +7000)));
  static_assert( (PosOp::noLessThan   (+8000, +8000)));
  static_assert(!(PosOp::noLessThan   (+8000, +9000)));
  static_assert(!(PosOp::noGreaterThan(+8000, +7000)));
  static_assert( (PosOp::noGreaterThan(+8000, +8000)));
  static_assert( (PosOp::noGreaterThan(+8000, +9000)));
  
  //
  // operations relative to the baseline
  //
  
  static_assert(op.shiftFromBaseline(+1000) == +9000);
  static_assert(op.shiftFromBaseline(-1000) == +7000);
  
  static_assert(op.subtractBaseline(+9000) == +1000);
  static_assert(op.subtractBaseline(+7000) == -1000);
  
  
} // void PositivePolarityTest()