geo_types_test.cc File Reference

Test of geo_types.h types. More...

#include "boost/test/unit_test.hpp"
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h"
#include <type_traits>

Go to the source code of this file.

Macros
#define	GEO_TYPES_TEST_SKIP_COMPILATION_ERRORS   1
#define	BOOST_TEST_MODULE   ( geo_types_test )

Functions
template<typename T >
auto	makeConst (T &var) -> decltype(auto)
template<typename ID >
constexpr bool	assertGeoIDlevel ()
void	TestIDvalidity (geo::CryostatID const &id, bool answer)
void	TestSetIDvalidity (geo::CryostatID &id)
template<typename TESTID , typename REFID = TESTID>
void	TestCompareSmallerID (TESTID const &id, REFID const &smaller)
	Test comparison operators. More...
template<typename TESTID , typename REFID = TESTID>
void	TestCompareSameID (TESTID const &id, REFID const &same)
	Test comparison operators. More...
template<typename TESTID >
void	TestCompareSelfID (TESTID const &id)
	Test comparison operators. More...
template<typename TESTID , typename REFID = TESTID>
void	TestCompareLargerID (TESTID const &id, REFID const &larger)
	Test comparison operators. More...
template<typename TESTID , typename REFID = TESTID>
void	TestIDcomparison (TESTID const &id, REFID const &smaller, REFID const &same, REFID const &larger)
	Test comparison operators. More...
void	test_CryostatID_defaultConstructor ()
void	test_CryostatID_directConstructor ()
void	test_OpDetID_defaultConstructor ()
void	test_OpDetID_integralConstructor ()
void	test_OpDetID_nestedConstructor ()
void	test_OpDetID_directConstructor ()
void	test_TPCID_defaultConstructor ()
void	test_TPCID_integralConstructor ()
void	test_TPCID_nestedConstructor ()
void	test_TPCID_directConstructor ()
void	test_PlaneID_defaultConstructor ()
void	test_PlaneID_integralConstructor ()
void	test_PlaneID_nestedConstructor ()
void	test_PlaneID_directConstructor ()
void	test_WireID_defaultConstructor ()
void	test_WireID_integralConstructor ()
void	test_WireID_nestedConstructor ()
void	test_WireID_directConstructor ()
	BOOST_AUTO_TEST_CASE (CryostatIDtest)
	BOOST_AUTO_TEST_CASE (OpDetIDtest)
	BOOST_AUTO_TEST_CASE (TPCIDtest)
	BOOST_AUTO_TEST_CASE (PlaneIDtest)
	BOOST_AUTO_TEST_CASE (WireIDtest)

Detailed Description

Test of geo_types.h types.

Author

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

Date

May 5th, 2015

Definition in file geo_types_test.cc.

Macro Definition Documentation

#define BOOST_TEST_MODULE   ( geo_types_test )

Definition at line 24 of file geo_types_test.cc.

#define GEO_TYPES_TEST_SKIP_COMPILATION_ERRORS   1

Definition at line 11 of file geo_types_test.cc.

Function Documentation

template<typename ID >

constexpr bool assertGeoIDlevel

(

)

Definition at line 38 of file geo_types_test.cc.

  { return geo::details::geoElementLevel<ID>() == ID::Level; }

BOOST_AUTO_TEST_CASE

(

CryostatIDtest

)

Definition at line 791 of file geo_types_test.cc.

                                     {
  test_CryostatID_defaultConstructor();
  test_CryostatID_directConstructor();
}

BOOST_AUTO_TEST_CASE

(

OpDetIDtest

)

Definition at line 799 of file geo_types_test.cc.

                                  {
  test_OpDetID_defaultConstructor();
  test_OpDetID_nestedConstructor();
  test_OpDetID_directConstructor();
  test_OpDetID_integralConstructor();
}

BOOST_AUTO_TEST_CASE

(

TPCIDtest

)

Definition at line 809 of file geo_types_test.cc.

                                {
  test_TPCID_defaultConstructor();
  test_TPCID_nestedConstructor();
  test_TPCID_directConstructor();
  test_TPCID_integralConstructor();
}

BOOST_AUTO_TEST_CASE

(

PlaneIDtest

)

Definition at line 819 of file geo_types_test.cc.

                                  {
  test_PlaneID_defaultConstructor();
  test_PlaneID_nestedConstructor();
  test_PlaneID_directConstructor();
  test_PlaneID_integralConstructor();
}

BOOST_AUTO_TEST_CASE

(

WireIDtest

)

Definition at line 829 of file geo_types_test.cc.

                                 {
  test_WireID_defaultConstructor();
  test_WireID_nestedConstructor();
  test_WireID_directConstructor();
  test_WireID_integralConstructor();
}

template<typename T >

auto makeConst

(

T &

var

)

-> decltype(auto)

Definition at line 35 of file geo_types_test.cc.

{ return const_cast<T const&>(var); }

void test_CryostatID_defaultConstructor

(

)

Definition at line 214 of file geo_types_test.cc.

                                          {

  BOOST_TEST_MESSAGE("Testing default-constructed cryostat ID");

  geo::CryostatID cid;

  // a default-constructed ID is invalid:
  TestIDvalidity(cid, false);
  TestSetIDvalidity(cid);

/* // feature not added
  // test assignment from ID_t
  cid = 1;
  BOOST_TEST(cid.Cryostat == 1);
*/

  BOOST_TEST(&cid.deepestIndex() == &cid.Cryostat);
  BOOST_TEST(&makeConst(cid).deepestIndex() == &cid.Cryostat);

} // test_CryostatID_defaultConstructor()

void test_CryostatID_directConstructor

(

)

Definition at line 236 of file geo_types_test.cc.

                                         {

  BOOST_TEST_CHECKPOINT("Testing cryostat ID constructed with an integer");

  geo::CryostatID cid(1);

  // an explicitly constructed ID is valid:
  TestIDvalidity(cid, true);
  TestSetIDvalidity(cid);

  // check the ID value
  BOOST_TEST(cid.Cryostat == geo::CryostatID::CryostatID_t(1));

  // test comparison operators
  // (exercise copy constructor too)
  geo::CryostatID smaller_cid(0), same_cid(cid), larger_cid(2);

  TestIDcomparison(cid, smaller_cid, same_cid, larger_cid);

  // test setting and accessing a single index
  BOOST_TEST(cid.getIndex<0U>() == 1);
  cid.writeIndex<0U>() = 2;
  BOOST_TEST(cid.getIndex<0U>() == 2);
  

  // make sure the ID with cryostat 0 is fine (it's not a bad ID!)
  BOOST_TEST_CHECKPOINT("Testing cryostat ID constructed with an integer 0");

  geo::CryostatID first_cid(0);
  TestIDvalidity(cid, true);
  TestSetIDvalidity(cid);

  // check the ID value
  BOOST_TEST(first_cid.Cryostat == geo::CryostatID::CryostatID_t(0));

} // test_CryostatID_directConstructor()

void test_OpDetID_defaultConstructor

(

)

Definition at line 279 of file geo_types_test.cc.

                                       {

  BOOST_TEST_CHECKPOINT("Testing default-constructed optical detector ID");

  geo::OpDetID oid;

  // a default-constructed ID is invalid:
  TestIDvalidity(oid, false);
  TestSetIDvalidity(oid);

  BOOST_TEST(&oid.deepestIndex() == &oid.OpDet);
  BOOST_TEST(&makeConst(oid).deepestIndex() == &oid.OpDet);

} // test_OpDetID_defaultConstructor()

void test_OpDetID_directConstructor

(

)

Definition at line 341 of file geo_types_test.cc.

                                      {

  BOOST_TEST_CHECKPOINT("Testing optical detector ID constructed with indices");

  geo::OpDetID oid(1, 15);

  // an explicitly constructed ID is valid:
  TestIDvalidity(oid, true);
  TestSetIDvalidity(oid);

  BOOST_TEST_CHECKPOINT("Testing comparison with same cryostat ID");

  geo::OpDetID smaller_oid(1, 14), same_oid(1, 15), larger_oid(1, 16);
  TestIDcomparison(oid, smaller_oid, same_oid, larger_oid);

  BOOST_TEST_CHECKPOINT("Testing comparison with different cryostat ID");
  geo::OpDetID smaller_cid(0, 16), larger_cid(2, 14);
  TestCompareSmallerID(oid, smaller_cid);
  TestCompareLargerID(oid, larger_cid);

  // test setting and accessing a single index
  BOOST_TEST(oid.getIndex<0U>() == 1);
  oid.writeIndex<0U>() = 2;
  BOOST_TEST(oid.getIndex<0U>() == 2);
  
  BOOST_TEST(oid.getIndex<1U>() == 15);
  oid.writeIndex<1U>() = 19;
  BOOST_TEST(oid.getIndex<1U>() == 19);
  
  // make sure the ID with optical detector 0 is fine (it's not a bad ID!)
  BOOST_TEST_CHECKPOINT
    ("Testing optical detector ID constructed with OpDet #0");

  geo::OpDetID first_oid(0, 0);
  TestIDvalidity(first_oid, true);
  TestSetIDvalidity(first_oid);

  // - check the ID value
  BOOST_TEST(first_oid.Cryostat == geo::CryostatID::CryostatID_t(0));
  BOOST_TEST(first_oid.OpDet ==          geo::OpDetID::OpDetID_t(0));


} // test_OpDetID_directConstructor()

void test_OpDetID_integralConstructor

(

)

Definition at line 295 of file geo_types_test.cc.

                                        {

  BOOST_TEST_CHECKPOINT("Testing integral-constructed optical detector ID");

#if GEO_TYPES_TEST_SKIP_COMPILATION_ERRORS
  BOOST_TEST_MESSAGE("  (test skipped)");
#else
  geo::OpDetID oid(1);

  BOOST_TEST_MESSAGE("OpDetID(1) = " << std::string(oid));

  geo::OpDetID::OpDetID_t what = oid;

  BOOST_TEST_MESSAGE("int(OpDetID(1)) = " << what);

#endif // GEO_TYPES_TEST_SKIP_COMPILATION_ERRORS

} // test_OpDetID_integralConstructor()

void test_OpDetID_nestedConstructor

(

)

Definition at line 315 of file geo_types_test.cc.

                                      {

  BOOST_TEST_CHECKPOINT("Testing ID-constructed optical detector ID");

  geo::CryostatID cid(1);
  geo::OpDetID oid(cid, 15);

  // an explicitly constructed ID is valid:
  TestIDvalidity(oid, true);
  TestSetIDvalidity(oid);

  // check the ID value
  BOOST_TEST(oid.Cryostat == geo::CryostatID::CryostatID_t( 1));
  BOOST_TEST(oid.OpDet ==          geo::OpDetID::OpDetID_t(15));

  // test comparison operators (exercise copy constructor too)
  // - with optical detector ID
  BOOST_TEST_CHECKPOINT("Testing comparison with optical detector ID");
  geo::OpDetID smaller_oid(cid, oid.OpDet - 1), same_oid(oid),
    larger_oid(cid, oid.OpDet + 1);

  TestIDcomparison(oid, smaller_oid, same_oid, larger_oid);

} // test_OpDetID_nestedConstructor()

void test_PlaneID_defaultConstructor

(

)

Definition at line 503 of file geo_types_test.cc.

                                       {

  BOOST_TEST_CHECKPOINT("Testing default-constructed plane ID");

  geo::PlaneID pid;

  // a default-constructed ID is invalid:
  TestIDvalidity(pid, false);
  TestSetIDvalidity(pid);

  BOOST_TEST(&pid.deepestIndex() == &pid.Plane);
  BOOST_TEST(&makeConst(pid).deepestIndex() == &pid.Plane);

} // test_PlaneID_defaultConstructor()

void test_PlaneID_directConstructor

(

)

Definition at line 565 of file geo_types_test.cc.

                                      {

  BOOST_TEST_CHECKPOINT("Testing plane ID constructed with indices");

  geo::PlaneID pid(1, 15, 32);

  // an explicitly constructed ID is valid:
  TestIDvalidity(pid, true);
  TestSetIDvalidity(pid);

  // check the ID value
  BOOST_TEST(pid.Cryostat == geo::CryostatID::CryostatID_t( 1));
  BOOST_TEST(pid.TPC ==                geo::TPCID::TPCID_t(15));
  BOOST_TEST(pid.Plane ==          geo::PlaneID::PlaneID_t(32));

  BOOST_TEST_CHECKPOINT("Testing comparison with same TPC ID");

  geo::PlaneID
    smaller_pid(1, 15, 31), same_pid(1, 15, 32), larger_pid(1, 15, 33);
  TestIDcomparison(pid, smaller_pid, same_pid, larger_pid);

  BOOST_TEST_CHECKPOINT("Testing comparison with different TPC ID (1)");
  geo::PlaneID smaller_tid1(1, 14, 33), larger_tid1(1, 16, 31);
  TestCompareSmallerID(pid, smaller_tid1);
  TestCompareLargerID(pid, larger_tid1);
  BOOST_TEST_CHECKPOINT("Testing comparison with different TPC ID (2)");
  geo::PlaneID smaller_tid2(1, 14, 32), larger_tid2(1, 16, 32);
  TestCompareSmallerID(pid, smaller_tid2);
  TestCompareLargerID(pid, larger_tid2);

  BOOST_TEST_CHECKPOINT("Testing comparison with different cryostat ID");
  geo::PlaneID smaller_cid1(0, 15, 33), larger_cid1(2, 15, 31);
  TestCompareSmallerID(pid, smaller_cid1);
  TestCompareLargerID(pid, larger_cid1);
  BOOST_TEST_CHECKPOINT("Testing comparison with different cryostat ID (2)");
  geo::PlaneID smaller_cid2(0, 15, 32), larger_cid2(2, 15, 32);
  TestCompareSmallerID(pid, smaller_cid2);
  TestCompareLargerID(pid, larger_cid2);

  // test setting and accessing a single index
  BOOST_TEST(pid.getIndex<0U>() == 1);
  pid.writeIndex<0U>() = 2;
  BOOST_TEST(pid.getIndex<0U>() == 2);
  
  BOOST_TEST(pid.getIndex<1U>() == 15);
  pid.writeIndex<1U>() = 19;
  BOOST_TEST(pid.getIndex<1U>() == 19);
  
  BOOST_TEST(pid.getIndex<2U>() == 32);
  pid.writeIndex<2U>() = 76;
  BOOST_TEST(pid.getIndex<2U>() == 76);
  
  
  // make sure the ID with plane 0 is fine (it's not a bad ID!)
  BOOST_TEST_CHECKPOINT("Testing plane ID constructed with a plane #0");

  geo::PlaneID first_pid(0, 0, 0);
  TestIDvalidity(first_pid, true);
  TestSetIDvalidity(first_pid);

  // - check the ID value
  BOOST_TEST(first_pid.Cryostat == geo::CryostatID::CryostatID_t(0));
  BOOST_TEST(first_pid.TPC ==                geo::TPCID::TPCID_t(0));
  BOOST_TEST(first_pid.Plane ==          geo::PlaneID::PlaneID_t(0));

} // test_PlaneID_directConstructor()

void test_PlaneID_integralConstructor

(

)

Definition at line 519 of file geo_types_test.cc.

                                        {

  BOOST_TEST_CHECKPOINT("Testing integral-constructed plane ID");

#if GEO_TYPES_TEST_SKIP_COMPILATION_ERRORS
  BOOST_TEST_MESSAGE("  (test skipped)");
#else
  geo::PlaneID pid(1);

  BOOST_TEST_MESSAGE("PlaneID(1) = " << std::string(pid));

  geo::PlaneID::PlaneID_t what = pid;

  BOOST_TEST_MESSAGE("int(PlaneID(1)) = " << what);

#endif // GEO_TYPES_TEST_SKIP_COMPILATION_ERRORS

} // test_PlaneID_integralConstructor()

void test_PlaneID_nestedConstructor

(

)

Definition at line 539 of file geo_types_test.cc.

                                      {

  BOOST_TEST_CHECKPOINT("Testing ID-constructed plane ID");

  geo::TPCID tid(1, 15);
  geo::PlaneID pid(tid, 32);

  // an explicitly constructed ID is valid:
  TestIDvalidity(pid, true);
  TestSetIDvalidity(pid);

  // check the ID value
  BOOST_TEST(pid.Cryostat == geo::CryostatID::CryostatID_t( 1));
  BOOST_TEST(pid.TPC ==                geo::TPCID::TPCID_t(15));
  BOOST_TEST(pid.Plane ==          geo::PlaneID::PlaneID_t(32));

  // test comparison operators (exercise copy constructor too)
  BOOST_TEST_CHECKPOINT("Testing comparison with plane ID");
  geo::PlaneID smaller_pid(tid, pid.Plane - 1), same_pid(pid),
    larger_pid(tid, pid.Plane + 1);

  TestIDcomparison(pid, smaller_pid, same_pid, larger_pid);

} // test_PlaneID_nestedConstructor()

void test_TPCID_defaultConstructor

(

)

Definition at line 391 of file geo_types_test.cc.

                                     {

  BOOST_TEST_CHECKPOINT("Testing default-constructed TPC ID");

  geo::TPCID tid;

  // a default-constructed ID is invalid:
  TestIDvalidity(tid, false);
  TestSetIDvalidity(tid);

  BOOST_TEST(&tid.deepestIndex() == &tid.TPC);
  BOOST_TEST(&makeConst(tid).deepestIndex() == &tid.TPC);

} // test_TPCID_defaultConstructor()

void test_TPCID_directConstructor

(

)

Definition at line 453 of file geo_types_test.cc.

                                    {

  BOOST_TEST_CHECKPOINT("Testing TPC ID constructed with indices");

  geo::TPCID tid(1, 15);

  // an explicitly constructed ID is valid:
  TestIDvalidity(tid, true);
  TestSetIDvalidity(tid);

  BOOST_TEST_CHECKPOINT("Testing comparison with same cryostat ID");

  geo::TPCID smaller_tid(1, 14), same_tid(1, 15), larger_tid(1, 16);
  TestIDcomparison(tid, smaller_tid, same_tid, larger_tid);

  BOOST_TEST_CHECKPOINT("Testing comparison with different cryostat ID");
  geo::TPCID smaller_cid(0, 16), larger_cid(2, 14);
  TestCompareSmallerID(tid, smaller_cid);
  TestCompareLargerID(tid, larger_cid);

  // make sure the ID with TPC 0 is fine (it's not a bad ID!)
  BOOST_TEST_CHECKPOINT("Testing TPC ID constructed with a TPC #0");

  // test setting and accessing a single index
  BOOST_TEST(tid.getIndex<0U>() == 1);
  tid.writeIndex<0U>() = 2;
  BOOST_TEST(tid.getIndex<0U>() == 2);
  
  BOOST_TEST(tid.getIndex<1U>() == 15);
  tid.writeIndex<1U>() = 19;
  BOOST_TEST(tid.getIndex<1U>() == 19);
  
  
  geo::TPCID first_tid(0, 0);
  TestIDvalidity(first_tid, true);
  TestSetIDvalidity(first_tid);

  // - check the ID value
  BOOST_TEST(first_tid.Cryostat == geo::CryostatID::CryostatID_t(0));
  BOOST_TEST(first_tid.TPC ==                geo::TPCID::TPCID_t(0));


} // test_TPCID_directConstructor()

void test_TPCID_integralConstructor

(

)

Definition at line 407 of file geo_types_test.cc.

                                      {

  BOOST_TEST_CHECKPOINT("Testing integral-constructed TPC ID");

#if GEO_TYPES_TEST_SKIP_COMPILATION_ERRORS
  BOOST_TEST_MESSAGE("  (test skipped)");
#else
  geo::TPCID tid(1);

  BOOST_TEST_MESSAGE("TPCID(1) = " << std::string(tid));

  geo::TPCID::TPCID_t what = tid;

  BOOST_TEST_MESSAGE("int(TPCID(1)) = " << what);

#endif // GEO_TYPES_TEST_SKIP_COMPILATION_ERRORS

} // test_TPCID_integralConstructor()

void test_TPCID_nestedConstructor

(

)

Definition at line 427 of file geo_types_test.cc.

                                    {

  BOOST_TEST_CHECKPOINT("Testing ID-constructed TPC ID");

  geo::CryostatID cid(1);
  geo::TPCID tid(cid, 15);

  // an explicitly constructed ID is valid:
  TestIDvalidity(tid, true);
  TestSetIDvalidity(tid);

  // check the ID value
  BOOST_TEST(tid.Cryostat == geo::CryostatID::CryostatID_t( 1));
  BOOST_TEST(tid.TPC ==                geo::TPCID::TPCID_t(15));

  // test comparison operators (exercise copy constructor too)
  // - with TPC ID
  BOOST_TEST_CHECKPOINT("Testing comparison with TPC ID");
  geo::TPCID smaller_tid(cid, tid.TPC - 1), same_tid(tid),
    larger_tid(cid, tid.TPC + 1);

  TestIDcomparison(tid, smaller_tid, same_tid, larger_tid);

} // test_TPCID_nestedConstructor()

void test_WireID_defaultConstructor

(

)

Definition at line 638 of file geo_types_test.cc.

                                      {

  BOOST_TEST_CHECKPOINT("Testing default-constructed wire ID");

  geo::WireID wid;

  // a default-constructed ID is invalid:
  TestIDvalidity(wid, false);
  TestSetIDvalidity(wid);

  BOOST_TEST(&wid.deepestIndex() == &wid.Wire);
  BOOST_TEST(&makeConst(wid).deepestIndex() == &wid.Wire);

} // test_WireID_defaultConstructor()

void test_WireID_directConstructor

(

)

Definition at line 701 of file geo_types_test.cc.

                                     {

  BOOST_TEST_CHECKPOINT("Testing wire ID constructed with indices");

  geo::WireID wid(1, 15, 32, 27);

  // an explicitly constructed ID is valid:
  TestIDvalidity(wid, true);
  TestSetIDvalidity(wid);

  // check the ID value
  BOOST_TEST(wid.Cryostat == geo::CryostatID::CryostatID_t( 1));
  BOOST_TEST(wid.TPC ==                geo::TPCID::TPCID_t(15));
  BOOST_TEST(wid.Plane ==          geo::PlaneID::PlaneID_t(32));
  BOOST_TEST(wid.Wire ==             geo::WireID::WireID_t(27));

  BOOST_TEST_CHECKPOINT("Testing comparison with same TPC ID");

  geo::WireID
    smaller_wid(1, 15, 32, 26), same_wid(1, 15, 32, 27),
    larger_wid(1, 15, 32, 28);
  TestIDcomparison(wid, smaller_wid, same_wid, larger_wid);

  BOOST_TEST_CHECKPOINT("Testing comparison with different plane ID (1)");
  geo::WireID smaller_pid1(1, 15, 31, 28), larger_pid1(1, 15, 33, 26);
  TestCompareSmallerID(wid, smaller_pid1);
  TestCompareLargerID(wid, larger_pid1);
  BOOST_TEST_CHECKPOINT("Testing comparison with different plane ID (2)");
  geo::WireID smaller_pid2(1, 15, 31, 27), larger_pid2(1, 15, 33, 27);
  TestCompareSmallerID(wid, smaller_pid2);
  TestCompareLargerID(wid, larger_pid2);

  BOOST_TEST_CHECKPOINT("Testing comparison with different TPC ID (1)");
  geo::WireID smaller_tid1(1, 14, 32, 28), larger_tid1(1, 16, 32, 26);
  TestCompareSmallerID(wid, smaller_tid1);
  TestCompareLargerID(wid, larger_tid1);
  BOOST_TEST_CHECKPOINT("Testing comparison with different TPC ID (2)");
  geo::WireID smaller_tid2(1, 14, 32, 27), larger_tid2(1, 16, 32, 27);
  TestCompareSmallerID(wid, smaller_tid2);
  TestCompareLargerID(wid, larger_tid2);

  BOOST_TEST_CHECKPOINT("Testing comparison with different cryostat ID");
  geo::WireID smaller_cid1(0, 15, 32, 28), larger_cid1(2, 15, 32, 26);
  TestCompareSmallerID(wid, smaller_cid1);
  TestCompareLargerID(wid, larger_cid1);
  BOOST_TEST_CHECKPOINT("Testing comparison with different cryostat ID (2)");
  geo::WireID smaller_cid2(0, 15, 32, 27), larger_cid2(2, 15, 32, 27);
  TestCompareSmallerID(wid, smaller_cid2);
  TestCompareLargerID(wid, larger_cid2);

  // make sure the ID with wire 0 is fine (it's not a bad ID!)
  BOOST_TEST_CHECKPOINT("Testing wire ID constructed with a wire #0");
  
  // test setting and accessing a single index
  BOOST_TEST(wid.getIndex<0U>() == 1);
  wid.writeIndex<0U>() = 2;
  BOOST_TEST(wid.getIndex<0U>() == 2);
  
  BOOST_TEST(wid.getIndex<1U>() == 15);
  wid.writeIndex<1U>() = 19;
  BOOST_TEST(wid.getIndex<1U>() == 19);
  
  BOOST_TEST(wid.getIndex<2U>() == 32);
  wid.writeIndex<2U>() = 76;
  BOOST_TEST(wid.getIndex<2U>() == 76);
  
  BOOST_TEST(wid.getIndex<3U>() == 27);
  wid.writeIndex<3U>() = 45;
  BOOST_TEST(wid.getIndex<3U>() == 45);
  
  
  geo::WireID first_wid(0, 0, 0, 0);
  TestIDvalidity(first_wid, true);
  TestSetIDvalidity(first_wid);

  // - check the ID value
  BOOST_TEST(first_wid.Cryostat == geo::CryostatID::CryostatID_t(0));
  BOOST_TEST(first_wid.TPC ==                geo::TPCID::TPCID_t(0));
  BOOST_TEST(first_wid.Plane ==          geo::PlaneID::PlaneID_t(0));
  BOOST_TEST(first_wid.Wire ==             geo::WireID::WireID_t(0));

} // test_WireID_directConstructor()

void test_WireID_integralConstructor

(

)

Definition at line 654 of file geo_types_test.cc.

                                       {

  BOOST_TEST_CHECKPOINT("Testing integral-constructed wire ID");

#if GEO_TYPES_TEST_SKIP_COMPILATION_ERRORS
  BOOST_TEST_MESSAGE("  (test skipped)");
#else
  geo::WireID wid(1);

  BOOST_TEST_MESSAGE("WireID(1) = " << std::string(wid));

  geo::WireID::WireID_t what = wid;

  BOOST_TEST_MESSAGE("int(WireID(1)) = " << what);

#endif // GEO_TYPES_TEST_SKIP_COMPILATION_ERRORS
} // test_WireID_integralConstructor()

void test_WireID_nestedConstructor

(

)

Definition at line 673 of file geo_types_test.cc.

                                     {

  BOOST_TEST_CHECKPOINT("Testing ID-constructed wire ID");

  geo::PlaneID pid(1, 15, 32);
  geo::WireID wid(pid, 27);

  // an explicitly constructed ID is valid:
  TestIDvalidity(wid, true);
  TestSetIDvalidity(wid);

  // check the ID value
  BOOST_TEST(wid.Cryostat == geo::CryostatID::CryostatID_t( 1));
  BOOST_TEST(wid.TPC ==                geo::TPCID::TPCID_t(15));
  BOOST_TEST(wid.Plane ==          geo::PlaneID::PlaneID_t(32));
  BOOST_TEST(wid.Wire ==             geo::WireID::WireID_t(27));

  // test comparison operators (exercise copy constructor too)
  // - with TPC ID
  BOOST_TEST_CHECKPOINT("Testing comparison with wire ID");
  geo::WireID smaller_wid(pid, wid.Wire - 1), same_wid(wid),
    larger_wid(pid, wid.Wire + 1);

  TestIDcomparison(wid, smaller_wid, same_wid, larger_wid);

} // test_WireID_nestedConstructor()

template<typename TESTID , typename REFID = TESTID>

void TestCompareLargerID	(	TESTID const &	id,
		REFID const &	larger
	)

Test comparison operators.

Definition at line 188 of file geo_types_test.cc.

                                                                 {
  BOOST_TEST(  id     <  larger  );
  BOOST_TEST(  id     != larger  );
  BOOST_TEST(!(id     == larger) );
  BOOST_TEST(!(larger <      id) );
  BOOST_TEST(larger.cmp(id) > 0);
  BOOST_TEST(id.cmp(larger) < 0);
} // TestCompareLargerID()

template<typename TESTID , typename REFID = TESTID>

void TestCompareSameID	(	TESTID const &	id,
		REFID const &	same
	)

Test comparison operators.

Definition at line 172 of file geo_types_test.cc.

                                                             {
  BOOST_TEST(!(id      <  same) );
  BOOST_TEST(  id      == same  );
  BOOST_TEST(!(id      != same) );
  BOOST_TEST(!(same <     id) );
  BOOST_TEST(same.cmp(id) == 0);
  BOOST_TEST(id.cmp(same) == 0);
} // TestCompareSameID()

template<typename TESTID >

void TestCompareSelfID

(

TESTID const &

id

)

Test comparison operators.

Definition at line 183 of file geo_types_test.cc.

  { return TestCompareSameID(id, id); }

template<typename TESTID , typename REFID = TESTID>

void TestCompareSmallerID	(	TESTID const &	id,
		REFID const &	smaller
	)

Test comparison operators.

Definition at line 161 of file geo_types_test.cc.

                                                                   {
  BOOST_TEST(!(id      <  smaller) );
  BOOST_TEST(!(id      == smaller) );
  BOOST_TEST(  id      != smaller  );
  BOOST_TEST(  smaller <       id  );
  BOOST_TEST(smaller.cmp(id) < 0);
  BOOST_TEST(id.cmp(smaller) > 0);
} // TestCompareSmallerID()

template<typename TESTID , typename REFID = TESTID>

void TestIDcomparison	(	TESTID const &	id,
		REFID const &	smaller,
		REFID const &	same,
		REFID const &	larger
	)

Test comparison operators.

Definition at line 200 of file geo_types_test.cc.

  {
  TestCompareSmallerID(id, smaller);
  TestCompareSameID(id, same);
  TestCompareSelfID(id);
  TestCompareLargerID(id, larger);
} // TestCryostatComparison()

void TestIDvalidity	(	geo::CryostatID const &	id,
		bool	answer
	)

Definition at line 133 of file geo_types_test.cc.

                                                          {
  // - check isValid
  BOOST_TEST(id.isValid == answer);
  // - check operator!
  BOOST_TEST(!id == !answer);
  // - check operator bool
  BOOST_TEST((bool)id == answer);
} // TestIDvalidity()

void TestSetIDvalidity

(

geo::CryostatID &

id

)

Definition at line 142 of file geo_types_test.cc.

                                          {

  bool const orig = bool(id);

  id.setValidity(true);
  BOOST_TEST(bool(id));
  id.setValidity(false);
  BOOST_TEST(!id);
  id.markValid();
  BOOST_TEST(bool(id));
  id.markInvalid();
  BOOST_TEST(!id);
  id.setValidity(orig);
  BOOST_TEST(bool(id) == orig);

} // TestSetIDvalidity()