geo_types_fhicl_test.cc File Reference

Test of larcoreobj/SimpleTypesAndConstants/geo_types_fhicl.h. More...

#include "boost/test/unit_test.hpp"
#include "larcoreobj/SimpleTypesAndConstants/geo_types_fhicl.h"
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h"
#include "fhiclcpp/types/Table.h"
#include "fhiclcpp/ParameterSet.h"
#include <iostream>
#include <string>
#include <array>
#include <type_traits>

Go to the source code of this file.

Macros
#define	BOOST_TEST_MODULE   ( geo_types_fhicl_test )

Functions
template<typename Config >
fhicl::Table< Config >	validateConfig (std::string const &configStr)
void	test_CryostatID_normal ()
void	test_CryostatID_invalid ()
void	test_OptionalCryostatID_present ()
void	test_OptionalCryostatID_omitted ()
void	test_CryostatIDsequence_normal ()
void	test_CryostatIDsequence_empty ()
void	test_OptionalCryostatIDsequence_normal ()
void	test_OptionalCryostatIDsequence_empty ()
void	test_OptionalCryostatIDsequence_omitted ()
void	test_OpDetID_normal ()
void	test_OpDetID_invalid ()
void	test_OptionalOpDetID_present ()
void	test_OptionalOpDetID_omitted ()
void	test_OpDetIDsequence_normal ()
void	test_OpDetIDsequence_empty ()
void	test_OptionalOpDetIDsequence_normal ()
void	test_OptionalOpDetIDsequence_empty ()
void	test_OptionalOpDetIDsequence_omitted ()
void	test_TPCID_normal ()
void	test_TPCID_invalid ()
void	test_OptionalTPCID_present ()
void	test_OptionalTPCID_omitted ()
void	test_TPCIDsequence_normal ()
void	test_TPCIDsequence_empty ()
void	test_OptionalTPCIDsequence_normal ()
void	test_OptionalTPCIDsequence_empty ()
void	test_OptionalTPCIDsequence_omitted ()
void	test_PlaneID_normal ()
void	test_PlaneID_invalid ()
void	test_OptionalPlaneID_present ()
void	test_OptionalPlaneID_omitted ()
void	test_PlaneIDsequence_normal ()
void	test_PlaneIDsequence_empty ()
void	test_OptionalPlaneIDsequence_normal ()
void	test_OptionalPlaneIDsequence_empty ()
void	test_OptionalPlaneIDsequence_omitted ()
void	test_WireID_normal ()
void	test_WireID_invalid ()
void	test_OptionalWireID_present ()
void	test_OptionalWireID_omitted ()
void	test_WireIDsequence_normal ()
void	test_WireIDsequence_empty ()
void	test_OptionalWireIDsequence_normal ()
void	test_OptionalWireIDsequence_empty ()
void	test_OptionalWireIDsequence_omitted ()
void	test_WireUnifiedInterface ()
void	test_groupDocumentation_example1 ()
void	test_groupDocumentation_example2 ()
	BOOST_AUTO_TEST_CASE (CryostatID_testcase)
	BOOST_AUTO_TEST_CASE (OpDetID_testcase)
	BOOST_AUTO_TEST_CASE (TPCID_testcase)
	BOOST_AUTO_TEST_CASE (PlaneID_testcase)
	BOOST_AUTO_TEST_CASE (WireID_testcase)
	BOOST_AUTO_TEST_CASE (documentation_testcase)

Detailed Description

Test of larcoreobj/SimpleTypesAndConstants/geo_types_fhicl.h.

Author

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

Date

November 25, 2019

Definition in file geo_types_fhicl_test.cc.

Macro Definition Documentation

#define BOOST_TEST_MODULE   ( geo_types_fhicl_test )

Definition at line 9 of file geo_types_fhicl_test.cc.

Function Documentation

BOOST_AUTO_TEST_CASE

(

CryostatID_testcase

)

Definition at line 1588 of file geo_types_fhicl_test.cc.

                                          {

  test_CryostatID_normal();
  test_CryostatID_invalid();

  test_OptionalCryostatID_present();
  test_OptionalCryostatID_omitted();

  test_CryostatIDsequence_normal();
  test_CryostatIDsequence_empty();

  test_OptionalCryostatIDsequence_normal();
  test_OptionalCryostatIDsequence_empty();
  test_OptionalCryostatIDsequence_omitted();

} // BOOST_AUTO_TEST_CASE(CryostatID_testcase)

BOOST_AUTO_TEST_CASE

(

OpDetID_testcase

)

Definition at line 1610 of file geo_types_fhicl_test.cc.

                                       {

  test_OpDetID_normal();
  test_OpDetID_invalid();

  test_OptionalOpDetID_present();
  test_OptionalOpDetID_omitted();

  test_OpDetIDsequence_normal();
  test_OpDetIDsequence_empty();

  test_OptionalOpDetIDsequence_normal();
  test_OptionalOpDetIDsequence_empty();
  test_OptionalOpDetIDsequence_omitted();

} // BOOST_AUTO_TEST_CASE(OpDetID_testcase)

BOOST_AUTO_TEST_CASE

(

TPCID_testcase

)

Definition at line 1632 of file geo_types_fhicl_test.cc.

                                     {

  test_TPCID_normal();
  test_TPCID_invalid();

  test_OptionalTPCID_present();
  test_OptionalTPCID_omitted();

  test_TPCIDsequence_normal();
  test_TPCIDsequence_empty();

  test_OptionalTPCIDsequence_normal();
  test_OptionalTPCIDsequence_empty();
  test_OptionalTPCIDsequence_omitted();

} // BOOST_AUTO_TEST_CASE(TPCID_testcase)

BOOST_AUTO_TEST_CASE

(

PlaneID_testcase

)

Definition at line 1654 of file geo_types_fhicl_test.cc.

                                       {

  test_PlaneID_normal();
  test_PlaneID_invalid();

  test_OptionalPlaneID_present();
  test_OptionalPlaneID_omitted();

  test_PlaneIDsequence_normal();
  test_PlaneIDsequence_empty();

  test_OptionalPlaneIDsequence_normal();
  test_OptionalPlaneIDsequence_empty();
  test_OptionalPlaneIDsequence_omitted();

} // BOOST_AUTO_TEST_CASE(PlaneID_testcase)

BOOST_AUTO_TEST_CASE

(

WireID_testcase

)

Definition at line 1676 of file geo_types_fhicl_test.cc.

                                      {

  test_WireID_normal();
  test_WireID_invalid();

  test_OptionalWireID_present();
  test_OptionalWireID_omitted();

  test_WireIDsequence_normal();
  test_WireIDsequence_empty();

  test_OptionalWireIDsequence_normal();
  test_OptionalWireIDsequence_empty();
  test_OptionalWireIDsequence_omitted();

  test_WireUnifiedInterface();

} // BOOST_AUTO_TEST_CASE(WireID_testcase)

BOOST_AUTO_TEST_CASE

(

documentation_testcase

)

Definition at line 1700 of file geo_types_fhicl_test.cc.

                                             {

  test_groupDocumentation_example1();
  test_groupDocumentation_example2();

} // BOOST_AUTO_TEST_CASE(documentation_testcase)

void test_CryostatID_invalid

(

)

Definition at line 71 of file geo_types_fhicl_test.cc.

                               {

  using ID_t = geo::CryostatID;
  struct Config { geo::fhicl::CryostatID Cryo { fhicl::Name("Cryo") }; };

  std::string const configStr { "Cryo: { isValid:false }" };
  ID_t const expectedID {};

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto const id = geo::fhicl::readID(validatedConfig.Cryo);
  static_assert(std::is_same_v<decltype(id), ID_t const>);
  BOOST_TEST(id.isValid == expectedID.isValid);
  if (expectedID.isValid) {
    BOOST_TEST(validatedConfig.Cryo().ID() == expectedID);
    BOOST_TEST(id == expectedID);
  }
} // test_CryostatID_invalid()

void test_CryostatID_normal

(

)

Definition at line 51 of file geo_types_fhicl_test.cc.

                              {

  using ID_t = geo::CryostatID;
  struct Config { geo::fhicl::CryostatID Cryo { fhicl::Name("Cryo") }; };

  std::string const configStr { "Cryo: { C:2 }" };
  ID_t const expectedID { 2U };

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto const id = geo::fhicl::readID(validatedConfig.Cryo);
  static_assert(std::is_same_v<decltype(id), ID_t const>);
  BOOST_TEST(id.isValid == expectedID.isValid);
  if (expectedID.isValid) {
    BOOST_TEST(validatedConfig.Cryo().ID() == expectedID);
    BOOST_TEST(id == expectedID);
  }
} // test_CryostatID_normal()

void test_CryostatIDsequence_empty

(

)

Definition at line 164 of file geo_types_fhicl_test.cc.

                                     {

  using ID_t = geo::CryostatID;
  struct Config
    { geo::fhicl::CryostatIDsequence Cryos { fhicl::Name("Cryos") }; };

  std::string const configStr { "Cryos: []" };

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readIDsequence(validatedConfig.Cryos);
  static_assert(std::is_same_v<decltype(ids), std::vector<ID_t>>);

  BOOST_TEST(ids.size() == 0U);

} // test_CryostatIDsequence_empty()

void test_CryostatIDsequence_normal

(

)

Definition at line 133 of file geo_types_fhicl_test.cc.

                                      {

  using ID_t = geo::CryostatID;
  struct Config
    { geo::fhicl::CryostatIDsequence Cryos { fhicl::Name("Cryos") }; };

  std::string const configStr { "Cryos: [ { C:0 }, { C:2 } ]" };
  // BUG the double brace syntax is required to work around clang bug 21629
//  std::array<ID_t, 2U> const expectedIDs { ID_t{ 0U }, ID_t{ 2U } };
  std::array<ID_t, 2U> const expectedIDs {{ ID_t{ 0U }, ID_t{ 2U } }};

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readIDsequence(validatedConfig.Cryos);
  static_assert(std::is_same_v<decltype(ids), std::vector<ID_t>>);

  BOOST_TEST(ids.size() == expectedIDs.size());
  auto const n = std::min(ids.size(), expectedIDs.size());
  for (std::size_t i = 0; i < n; ++i) {
    auto const& id = ids[i];
    ID_t const& expectedID = expectedIDs[i];

    BOOST_TEST_CONTEXT("Item [" << i << "]") {
      BOOST_TEST(id.isValid == expectedID.isValid);
      if (expectedID.isValid) BOOST_TEST(id == expectedID);
    } // BOOST_TEST_CONTEXT
  } // for

} // test_CryostatIDsequence_normal()

void test_groupDocumentation_example1

(

)

Definition at line 1411 of file geo_types_fhicl_test.cc.

                                        {
  /*
   * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
   * struct Config {
   *
   *   geo::fhicl::PlaneIDsequence Planes {
   *     fhicl::Name("Planes"),
   *     fhicl::Comment("anode planes to process")
   *     };
   *
   *   geo::fhicl::OptionalPlaneID ReferencePlane {
   *     fhicl::Name("ReferencePlane"),
   *     fhicl::Comment("reference anode plane (first one by default)")
   *     };
   *
   * }; // struct Config
   * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   * which can be configured as:
   * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   * Planes: [
   *   { C:0 T:1 P:0 },
   *   { C:0 T:1 P:1 },
   *   { C:0 T:1 P:2 }
   *   ]
   * ReferencePlane: { C:0 T:1 P:2 }
   * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   * and read as:
   * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
   * void readParams(art::EDProducer::Table<Config> const& config) {
   *
   *   std::vector<geo::PlaneID> planes
   *     = geo::fhicl::readIDsequence(config().Planes);
   *   if (planes.empty()) {
   *     throw art::Exception(art::errors::Configuration)
   *       << "At least one plane is needed.\n";
   *   }
   *
   *   geo::PlaneID refPlane; // invalid by default
   *   if (!config().ReferencePlane(refPlane)) refPlane = planes.front();
   *
   * } // readParams()
   *
   */

  //
  // code (adapted to non-art context)
  //
  struct Config {

    geo::fhicl::PlaneIDsequence Planes {
      fhicl::Name("Planes"),
      fhicl::Comment("anode planes to process")
      };

    geo::fhicl::OptionalPlaneID ReferencePlane {
      fhicl::Name("ReferencePlane"),
      fhicl::Comment("reference anode plane (first one by default)")
      };

  }; // struct Config

  std::string const configStr = {
      "Planes: ["
    "\n  { C:0 T:1 P:0 },"
    "\n  { C:0 T:1 P:1 },"
    "\n  { C:0 T:1 P:2 }"
    "\n  ]"
    "\nReferencePlane: { C:0 T:1 P:2 }"
    "\n"
    };


  fhicl::Table<Config> config = validateConfig<Config>(configStr);

  std::vector<geo::PlaneID> const planes
    = geo::fhicl::readIDsequence(config().Planes);
  if (planes.empty()) {
    throw std::runtime_error("At least one plane is needed.");
  }

  geo::PlaneID const refPlane
    = geo::fhicl::readOptionalID(config().ReferencePlane)
      .value_or(planes.front())
    ;

  //
  // test
  //
  BOOST_TEST(planes.size() == 3U);
  BOOST_TEST(planes[0U] == geo::PlaneID(0U, 1U, 0U));
  BOOST_TEST(planes[1U] == geo::PlaneID(0U, 1U, 1U));
  BOOST_TEST(planes[2U] == geo::PlaneID(0U, 1U, 2U));

  BOOST_TEST(refPlane == geo::PlaneID(0U, 1U, 2U));

} // test_groupDocumentation_example1()

void test_groupDocumentation_example2

(

)

Definition at line 1510 of file geo_types_fhicl_test.cc.

                                        {
  /*
   * struct Config {
   *
   *   geo::fhicl::OptionalPlaneIDsequence Planes {
   *     fhicl::Name("Planes"),
   *     fhicl::Comment("anode planes to process (omit or empty processes all)")
   *     };
   *
   * }; // struct Config
   * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   * reading as:
   * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
   * void readParams(art::EDProducer::Table<Config> const& config) {
   *
   *   std::vector<geo::PlaneID> planes
   *     = geo::fhicl::readOptionalIDsequence(config().Planes, {});
   *
   * } // readParams()
   *
   */

  //
  // code (adapted to non-art context)
  //
  struct Config {

    geo::fhicl::OptionalPlaneIDsequence Planes {
      fhicl::Name("Planes"),
      fhicl::Comment("anode planes to process (omit or empty processes all)")
      };

  }; // struct Config

  //
  // test A
  //
  std::string const configStrA = {
      "Planes: ["
    "\n  { C:0 T:1 P:0 },"
    "\n  { C:0 T:1 P:1 },"
    "\n  { C:0 T:1 P:2 }"
    "\n  ]"
    "\n"
    };

  fhicl::Table<Config> configA = validateConfig<Config>(configStrA);

  std::vector<geo::PlaneID> planes
    = geo::fhicl::readOptionalIDsequence(configA().Planes, {});

  BOOST_TEST(planes.size() == 3U);
  BOOST_TEST(planes[0U] == geo::PlaneID(0U, 1U, 0U));
  BOOST_TEST(planes[1U] == geo::PlaneID(0U, 1U, 1U));
  BOOST_TEST(planes[2U] == geo::PlaneID(0U, 1U, 2U));

  //
  // test B
  //
  std::string const configStrB = { "" };

  fhicl::Table<Config> configB = validateConfig<Config>(configStrB);

  planes = geo::fhicl::readOptionalIDsequence(configB().Planes, {});

  BOOST_TEST(planes.empty());


} // test_groupDocumentation_example2()

void test_OpDetID_invalid

(

)

Definition at line 307 of file geo_types_fhicl_test.cc.

                            {

  using ID_t = geo::OpDetID;
  struct Config { geo::fhicl::OpDetID OpDet { fhicl::Name("OpDet") }; };

  std::string const configStr { "OpDet: { isValid:false }" };
  ID_t const expectedID {};

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto const id = geo::fhicl::readID(validatedConfig.OpDet);
  static_assert(std::is_same_v<decltype(id), ID_t const>);
  BOOST_TEST(id.isValid == expectedID.isValid);
  if (expectedID.isValid) {
    BOOST_TEST(validatedConfig.OpDet().ID() == expectedID);
    BOOST_TEST(id == expectedID);
  }
} // test_OpDetID_invalid()

void test_OpDetID_normal

(

)

Definition at line 287 of file geo_types_fhicl_test.cc.

                           {

  using ID_t = geo::OpDetID;
  struct Config { geo::fhicl::OpDetID OpDet { fhicl::Name("OpDet") }; };

  std::string const configStr { "OpDet: { C:2 O:3 }" };
  ID_t const expectedID { 2U, 3U };

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto const id = geo::fhicl::readID(validatedConfig.OpDet);
  static_assert(std::is_same_v<decltype(id), ID_t const>);
  BOOST_TEST(id.isValid == expectedID.isValid);
  if (expectedID.isValid) {
    BOOST_TEST(validatedConfig.OpDet().ID() == expectedID);
    BOOST_TEST(id == expectedID);
  }
} // test_OpDetID_normal()

void test_OpDetIDsequence_empty

(

)

Definition at line 400 of file geo_types_fhicl_test.cc.

                                  {

  using ID_t = geo::OpDetID;
  struct Config
    { geo::fhicl::OpDetIDsequence OpDets { fhicl::Name("OpDets") }; };

  std::string const configStr { "OpDets: []" };

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readIDsequence(validatedConfig.OpDets);
  static_assert(std::is_same_v<decltype(ids), std::vector<ID_t>>);

  BOOST_TEST(ids.size() == 0U);

} // test_OpDetIDsequence_empty()

void test_OpDetIDsequence_normal

(

)

Definition at line 369 of file geo_types_fhicl_test.cc.

                                   {

  using ID_t = geo::OpDetID;
  struct Config
    { geo::fhicl::OpDetIDsequence OpDets { fhicl::Name("OpDets") }; };

  std::string const configStr { "OpDets: [ { C:0 O:1 }, { C:2 O:3 } ]" };
  // BUG the double brace syntax is required to work around clang bug 21629
//  std::array<ID_t, 2U> const expectedIDs { ID_t{ 0U, 1U }, ID_t{ 2U, 3U } };
  std::array<ID_t, 2U> const expectedIDs {{ ID_t{ 0U, 1U }, ID_t{ 2U, 3U } }};

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readIDsequence(validatedConfig.OpDets);
  static_assert(std::is_same_v<decltype(ids), std::vector<ID_t>>);

  BOOST_TEST(ids.size() == expectedIDs.size());
  auto const n = std::min(ids.size(), expectedIDs.size());
  for (std::size_t i = 0; i < n; ++i) {
    auto const& id = ids[i];
    ID_t const& expectedID = expectedIDs[i];

    BOOST_TEST_CONTEXT("Item [" << i << "]") {
      BOOST_TEST(id.isValid == expectedID.isValid);
      if (expectedID.isValid) BOOST_TEST(id == expectedID);
    } // BOOST_TEST_CONTEXT
  } // for

} // test_OpDetIDsequence_normal()

void test_OptionalCryostatID_omitted

(

)

Definition at line 111 of file geo_types_fhicl_test.cc.

                                       {

  using ID_t = geo::CryostatID;
  struct Config { geo::fhicl::OptionalCryostatID Cryo { fhicl::Name("Cryo") }; };

  std::string const configStr { "" };

  std::optional<ID_t> const expectedID;

  auto validatedConfig = validateConfig<Config>(configStr)();

  std::optional<ID_t> const id
    = geo::fhicl::readOptionalID(validatedConfig.Cryo);
  BOOST_TEST(id.has_value() == expectedID.has_value());
  if (expectedID.has_value()) {
    BOOST_TEST(id->isValid == expectedID->isValid);
    if (expectedID->isValid) BOOST_TEST(id.value() == expectedID.value());
  }

} // test_OptionalCryostatID_omitted()

void test_OptionalCryostatID_present

(

)

Definition at line 91 of file geo_types_fhicl_test.cc.

                                       {

  using ID_t = geo::CryostatID;
  struct Config { geo::fhicl::OptionalCryostatID Cryo { fhicl::Name("Cryo") }; };

  std::string const configStr { "Cryo: { C:1 }" };
  auto const expectedID = std::make_optional<ID_t>(1U);

  auto validatedConfig = validateConfig<Config>(configStr)();

  std::optional<ID_t> const id = readOptionalID(validatedConfig.Cryo);
  BOOST_TEST(id.has_value() == expectedID.has_value());
  if (expectedID.has_value()) {
    BOOST_TEST(id->isValid == expectedID->isValid);
    if (expectedID->isValid) BOOST_TEST(id.value() == expectedID.value());
  }

} // test_OptionalCryostatID_present()

void test_OptionalCryostatIDsequence_empty

(

)

Definition at line 216 of file geo_types_fhicl_test.cc.

                                             {

  using ID_t = geo::CryostatID;
  struct Config
    { geo::fhicl::OptionalCryostatIDsequence Cryos { fhicl::Name("Cryos") }; };

  std::string const configStr { "Cryos: []" };
  std::optional<std::vector<ID_t>> const expectedIDs(std::in_place);

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readOptionalIDsequence(validatedConfig.Cryos);
  static_assert
    (std::is_same_v<decltype(ids), std::optional<std::vector<ID_t>>>);

  BOOST_TEST(ids.has_value() == expectedIDs.has_value());
  if (expectedIDs.has_value()) {
    BOOST_TEST(ids->size() == expectedIDs->size());
    auto const n = std::min(ids->size(), expectedIDs->size());
    for (std::size_t i = 0; i < n; ++i) {
      auto const& id = ids.value()[i];
      ID_t const& expectedID = expectedIDs.value()[i];

      BOOST_TEST_CONTEXT("Item [" << i << "]") {
        BOOST_TEST(id.isValid == expectedID.isValid);
        if (expectedID.isValid) BOOST_TEST(id == expectedID);
      } // BOOST_TEST_CONTEXT
    } // for
  }

} // test_OptionalCryostatIDsequence_empty()

void test_OptionalCryostatIDsequence_normal

(

)

Definition at line 182 of file geo_types_fhicl_test.cc.

                                              {

  using ID_t = geo::CryostatID;
  struct Config
    { geo::fhicl::OptionalCryostatIDsequence Cryos { fhicl::Name("Cryos") }; };

  std::string const configStr { "Cryos: [ { C:0 }, { C:2 } ]" };
  std::optional<std::vector<ID_t>> const expectedIDs
    (std::in_place, { ID_t{ 0U }, ID_t{ 2U } });

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readOptionalIDsequence(validatedConfig.Cryos);
  static_assert
    (std::is_same_v<decltype(ids), std::optional<std::vector<ID_t>>>);

  BOOST_TEST(ids.has_value() == expectedIDs.has_value());
  if (expectedIDs.has_value()) {
    BOOST_TEST(ids->size() == expectedIDs->size());
    auto const n = std::min(ids->size(), expectedIDs->size());
    for (std::size_t i = 0; i < n; ++i) {
      auto const& id = ids.value()[i];
      ID_t const& expectedID = expectedIDs.value()[i];

      BOOST_TEST_CONTEXT("Item [" << i << "]") {
        BOOST_TEST(id.isValid == expectedID.isValid);
        if (expectedID.isValid) BOOST_TEST(id == expectedID);
      } // BOOST_TEST_CONTEXT
    } // for
  }

} // test_OptionalCryostatIDsequence_normal()

void test_OptionalCryostatIDsequence_omitted

(

)

Definition at line 249 of file geo_types_fhicl_test.cc.

                                               {

  using ID_t = geo::CryostatID;
  struct Config
    { geo::fhicl::OptionalCryostatIDsequence Cryos { fhicl::Name("Cryos") }; };

  std::string const configStr { "" };
  std::optional<std::vector<ID_t>> const expectedIDs(std::nullopt);

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readOptionalIDsequence(validatedConfig.Cryos);
  static_assert
    (std::is_same_v<decltype(ids), std::optional<std::vector<ID_t>>>);

  BOOST_TEST(ids.has_value() == expectedIDs.has_value());
  if (expectedIDs.has_value()) {
    BOOST_TEST(ids->size() == expectedIDs->size());
    auto const n = std::min(ids->size(), expectedIDs->size());
    for (std::size_t i = 0; i < n; ++i) {
      auto const& id = ids.value()[i];
      ID_t const& expectedID = expectedIDs.value()[i];

      BOOST_TEST_CONTEXT("Item [" << i << "]") {
        BOOST_TEST(id.isValid == expectedID.isValid);
        if (expectedID.isValid) BOOST_TEST(id == expectedID);
      } // BOOST_TEST_CONTEXT
    } // for
  }

} // test_OptionalCryostatIDsequence_omitted()

void test_OptionalOpDetID_omitted

(

)

Definition at line 347 of file geo_types_fhicl_test.cc.

                                    {

  using ID_t = geo::OpDetID;
  struct Config { geo::fhicl::OptionalOpDetID OpDet { fhicl::Name("OpDet") }; };

  std::string const configStr { "" };

  std::optional<ID_t> const expectedID { std::nullopt };

  auto validatedConfig = validateConfig<Config>(configStr)();

  std::optional<ID_t> const id
    = geo::fhicl::readOptionalID(validatedConfig.OpDet);
  BOOST_TEST(id.has_value() == expectedID.has_value());
  if (expectedID.has_value()) {
    BOOST_TEST(id->isValid == expectedID->isValid);
    if (expectedID->isValid) BOOST_TEST(id.value() == expectedID.value());
  }

} // test_OptionalOpDetID_omitted()

void test_OptionalOpDetID_present

(

)

Definition at line 327 of file geo_types_fhicl_test.cc.

                                    {

  using ID_t = geo::OpDetID;
  struct Config { geo::fhicl::OptionalOpDetID OpDet { fhicl::Name("OpDet") }; };

  std::string const configStr { "OpDet: { C:1 O:2 }" };
  std::optional<ID_t> const expectedID { std::in_place, 1U, 2U };

  auto validatedConfig = validateConfig<Config>(configStr)();

  std::optional<ID_t> const id = readOptionalID(validatedConfig.OpDet);
  BOOST_TEST(id.has_value() == expectedID.has_value());
  if (expectedID.has_value()) {
    BOOST_TEST(id->isValid == expectedID->isValid);
    if (expectedID->isValid) BOOST_TEST(id.value() == expectedID.value());
  }

} // test_OptionalOpDetID_present()

void test_OptionalOpDetIDsequence_empty

(

)

Definition at line 452 of file geo_types_fhicl_test.cc.

                                          {

  using ID_t = geo::OpDetID;
  struct Config
    { geo::fhicl::OptionalOpDetIDsequence OpDets { fhicl::Name("OpDets") }; };

  std::string const configStr { "OpDets: []" };
  std::optional<std::vector<ID_t>> const expectedIDs(std::in_place);

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readOptionalIDsequence(validatedConfig.OpDets);
  static_assert
    (std::is_same_v<decltype(ids), std::optional<std::vector<ID_t>>>);

  BOOST_TEST(ids.has_value() == expectedIDs.has_value());
  if (expectedIDs.has_value()) {
    BOOST_TEST(ids->size() == expectedIDs->size());
    auto const n = std::min(ids->size(), expectedIDs->size());
    for (std::size_t i = 0; i < n; ++i) {
      auto const& id = ids.value()[i];
      ID_t const& expectedID = expectedIDs.value()[i];

      BOOST_TEST_CONTEXT("Item [" << i << "]") {
        BOOST_TEST(id.isValid == expectedID.isValid);
        if (expectedID.isValid) BOOST_TEST(id == expectedID);
      } // BOOST_TEST_CONTEXT
    } // for
  }

} // test_OptionalOpDetIDsequence_empty()

void test_OptionalOpDetIDsequence_normal

(

)

Definition at line 418 of file geo_types_fhicl_test.cc.

                                           {

  using ID_t = geo::OpDetID;
  struct Config
    { geo::fhicl::OptionalOpDetIDsequence OpDets { fhicl::Name("OpDets") }; };

  std::string const configStr { "OpDets: [ { C:0 O:1 }, { C:2 O:3 } ]" };
  std::optional<std::vector<ID_t>> const expectedIDs
    (std::in_place, { ID_t{ 0U, 1U }, ID_t{ 2U, 3U } });

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readOptionalIDsequence(validatedConfig.OpDets);
  static_assert
    (std::is_same_v<decltype(ids), std::optional<std::vector<ID_t>>>);

  BOOST_TEST(ids.has_value() == expectedIDs.has_value());
  if (expectedIDs.has_value()) {
    BOOST_TEST(ids->size() == expectedIDs->size());
    auto const n = std::min(ids->size(), expectedIDs->size());
    for (std::size_t i = 0; i < n; ++i) {
      auto const& id = ids.value()[i];
      ID_t const& expectedID = expectedIDs.value()[i];

      BOOST_TEST_CONTEXT("Item [" << i << "]") {
        BOOST_TEST(id.isValid == expectedID.isValid);
        if (expectedID.isValid) BOOST_TEST(id == expectedID);
      } // BOOST_TEST_CONTEXT
    } // for
  }

} // test_OptionalOpDetIDsequence_normal()

void test_OptionalOpDetIDsequence_omitted

(

)

Definition at line 485 of file geo_types_fhicl_test.cc.

                                            {

  using ID_t = geo::OpDetID;
  struct Config
    { geo::fhicl::OptionalOpDetIDsequence OpDets { fhicl::Name("OpDets") }; };

  std::string const configStr { "" };
  std::optional<std::vector<ID_t>> const expectedIDs(std::nullopt);

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readOptionalIDsequence(validatedConfig.OpDets);
  static_assert
    (std::is_same_v<decltype(ids), std::optional<std::vector<ID_t>>>);

  BOOST_TEST(ids.has_value() == expectedIDs.has_value());
  if (expectedIDs.has_value()) {
    BOOST_TEST(ids->size() == expectedIDs->size());
    auto const n = std::min(ids->size(), expectedIDs->size());
    for (std::size_t i = 0; i < n; ++i) {
      auto const& id = ids.value()[i];
      ID_t const& expectedID = expectedIDs.value()[i];

      BOOST_TEST_CONTEXT("Item [" << i << "]") {
        BOOST_TEST(id.isValid == expectedID.isValid);
        if (expectedID.isValid) BOOST_TEST(id == expectedID);
      } // BOOST_TEST_CONTEXT
    } // for
  }

} // test_OptionalOpDetIDsequence_omitted()

void test_OptionalPlaneID_omitted

(

)

Definition at line 817 of file geo_types_fhicl_test.cc.

                                    {

  using ID_t = geo::PlaneID;
  struct Config { geo::fhicl::OptionalPlaneID Plane { fhicl::Name("Plane") }; };

  std::string const configStr { "" };

  std::optional<ID_t> const expectedID { std::nullopt };

  auto validatedConfig = validateConfig<Config>(configStr)();

  std::optional<ID_t> const id
    = geo::fhicl::readOptionalID(validatedConfig.Plane);
  BOOST_TEST(id.has_value() == expectedID.has_value());
  if (expectedID.has_value()) {
    BOOST_TEST(id->isValid == expectedID->isValid);
    if (expectedID->isValid) BOOST_TEST(id.value() == expectedID.value());
  }

} // test_OptionalPlaneID_omitted()

void test_OptionalPlaneID_present

(

)

Definition at line 797 of file geo_types_fhicl_test.cc.

                                    {

  using ID_t = geo::PlaneID;
  struct Config { geo::fhicl::OptionalPlaneID Plane { fhicl::Name("Plane") }; };

  std::string const configStr { "Plane: { C:1 T:2 P:1 }" };
  std::optional<ID_t> const expectedID { std::in_place, 1U, 2U, 1U };

  auto validatedConfig = validateConfig<Config>(configStr)();

  std::optional<ID_t> const id = readOptionalID(validatedConfig.Plane);
  BOOST_TEST(id.has_value() == expectedID.has_value());
  if (expectedID.has_value()) {
    BOOST_TEST(id->isValid == expectedID->isValid);
    if (expectedID->isValid) BOOST_TEST(id.value() == expectedID.value());
  }

} // test_OptionalPlaneID_present()

void test_OptionalPlaneIDsequence_empty

(

)

Definition at line 925 of file geo_types_fhicl_test.cc.

                                          {

  using ID_t = geo::PlaneID;
  struct Config
    { geo::fhicl::OptionalPlaneIDsequence Planes { fhicl::Name("Planes") }; };

  std::string const configStr { "Planes: []" };
  std::optional<std::vector<ID_t>> const expectedIDs(std::in_place);

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readOptionalIDsequence(validatedConfig.Planes);
  static_assert
    (std::is_same_v<decltype(ids), std::optional<std::vector<ID_t>>>);

  BOOST_TEST(ids.has_value() == expectedIDs.has_value());
  if (expectedIDs.has_value()) {
    BOOST_TEST(ids->size() == expectedIDs->size());
    auto const n = std::min(ids->size(), expectedIDs->size());
    for (std::size_t i = 0; i < n; ++i) {
      auto const& id = ids.value()[i];
      ID_t const& expectedID = expectedIDs.value()[i];

      BOOST_TEST_CONTEXT("Item [" << i << "]") {
        BOOST_TEST(id.isValid == expectedID.isValid);
        if (expectedID.isValid) BOOST_TEST(id == expectedID);
      } // BOOST_TEST_CONTEXT
    } // for
  }

} // test_OptionalPlaneIDsequence_empty()

void test_OptionalPlaneIDsequence_normal

(

)

Definition at line 890 of file geo_types_fhicl_test.cc.

                                           {

  using ID_t = geo::PlaneID;
  struct Config
    { geo::fhicl::OptionalPlaneIDsequence Planes { fhicl::Name("Planes") }; };

  std::string const configStr
    { "Planes: [ { C:0 T:1 P:1 }, { C:2 T:3 P:0 } ]" };
  std::optional<std::vector<ID_t>> const expectedIDs
    (std::in_place, { ID_t{ 0U, 1U, 1U }, ID_t{ 2U, 3U, 0U } });

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readOptionalIDsequence(validatedConfig.Planes);
  static_assert
    (std::is_same_v<decltype(ids), std::optional<std::vector<ID_t>>>);

  BOOST_TEST(ids.has_value() == expectedIDs.has_value());
  if (expectedIDs.has_value()) {
    BOOST_TEST(ids->size() == expectedIDs->size());
    auto const n = std::min(ids->size(), expectedIDs->size());
    for (std::size_t i = 0; i < n; ++i) {
      auto const& id = ids.value()[i];
      ID_t const& expectedID = expectedIDs.value()[i];

      BOOST_TEST_CONTEXT("Item [" << i << "]") {
        BOOST_TEST(id.isValid == expectedID.isValid);
        if (expectedID.isValid) BOOST_TEST(id == expectedID);
      } // BOOST_TEST_CONTEXT
    } // for
  }

} // test_OptionalPlaneIDsequence_normal()

void test_OptionalPlaneIDsequence_omitted

(

)

Definition at line 958 of file geo_types_fhicl_test.cc.

                                            {

  using ID_t = geo::PlaneID;
  struct Config
    { geo::fhicl::OptionalPlaneIDsequence Planes { fhicl::Name("Planes") }; };

  std::string const configStr { "" };
  std::optional<std::vector<ID_t>> const expectedIDs(std::nullopt);

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readOptionalIDsequence(validatedConfig.Planes);
  static_assert
    (std::is_same_v<decltype(ids), std::optional<std::vector<ID_t>>>);

  BOOST_TEST(ids.has_value() == expectedIDs.has_value());
  if (expectedIDs.has_value()) {
    BOOST_TEST(ids->size() == expectedIDs->size());
    auto const n = std::min(ids->size(), expectedIDs->size());
    for (std::size_t i = 0; i < n; ++i) {
      auto const& id = ids.value()[i];
      ID_t const& expectedID = expectedIDs.value()[i];

      BOOST_TEST_CONTEXT("Item [" << i << "]") {
        BOOST_TEST(id.isValid == expectedID.isValid);
        if (expectedID.isValid) BOOST_TEST(id == expectedID);
      } // BOOST_TEST_CONTEXT
    } // for
  }

} // test_OptionalPlaneIDsequence_omitted()

void test_OptionalTPCID_omitted

(

)

Definition at line 582 of file geo_types_fhicl_test.cc.

                                  {

  using ID_t = geo::TPCID;
  struct Config { geo::fhicl::OptionalTPCID TPC { fhicl::Name("TPC") }; };

  std::string const configStr { "" };

  std::optional<ID_t> const expectedID { std::nullopt };

  auto validatedConfig = validateConfig<Config>(configStr)();

  std::optional<ID_t> const id
    = geo::fhicl::readOptionalID(validatedConfig.TPC);
  BOOST_TEST(id.has_value() == expectedID.has_value());
  if (expectedID.has_value()) {
    BOOST_TEST(id->isValid == expectedID->isValid);
    if (expectedID->isValid) BOOST_TEST(id.value() == expectedID.value());
  }

} // test_OptionalTPCID_omitted()

void test_OptionalTPCID_present

(

)

Definition at line 562 of file geo_types_fhicl_test.cc.

                                  {

  using ID_t = geo::TPCID;
  struct Config { geo::fhicl::OptionalTPCID TPC { fhicl::Name("TPC") }; };

  std::string const configStr { "TPC: { C:1 T:2 }" };
  std::optional<ID_t> const expectedID { std::in_place, 1U, 2U };

  auto validatedConfig = validateConfig<Config>(configStr)();

  std::optional<ID_t> const id = readOptionalID(validatedConfig.TPC);
  BOOST_TEST(id.has_value() == expectedID.has_value());
  if (expectedID.has_value()) {
    BOOST_TEST(id->isValid == expectedID->isValid);
    if (expectedID->isValid) BOOST_TEST(id.value() == expectedID.value());
  }

} // test_OptionalTPCID_present()

void test_OptionalTPCIDsequence_empty

(

)

Definition at line 687 of file geo_types_fhicl_test.cc.

                                        {

  using ID_t = geo::TPCID;
  struct Config
    { geo::fhicl::OptionalTPCIDsequence TPCs { fhicl::Name("TPCs") }; };

  std::string const configStr { "TPCs: []" };
  std::optional<std::vector<ID_t>> const expectedIDs(std::in_place);

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readOptionalIDsequence(validatedConfig.TPCs);
  static_assert
    (std::is_same_v<decltype(ids), std::optional<std::vector<ID_t>>>);

  BOOST_TEST(ids.has_value() == expectedIDs.has_value());
  if (expectedIDs.has_value()) {
    BOOST_TEST(ids->size() == expectedIDs->size());
    auto const n = std::min(ids->size(), expectedIDs->size());
    for (std::size_t i = 0; i < n; ++i) {
      auto const& id = ids.value()[i];
      ID_t const& expectedID = expectedIDs.value()[i];

      BOOST_TEST_CONTEXT("Item [" << i << "]") {
        BOOST_TEST(id.isValid == expectedID.isValid);
        if (expectedID.isValid) BOOST_TEST(id == expectedID);
      } // BOOST_TEST_CONTEXT
    } // for
  }

} // test_OptionalTPCIDsequence_empty()

void test_OptionalTPCIDsequence_normal

(

)

Definition at line 653 of file geo_types_fhicl_test.cc.

                                         {

  using ID_t = geo::TPCID;
  struct Config
    { geo::fhicl::OptionalTPCIDsequence TPCs { fhicl::Name("TPCs") }; };

  std::string const configStr { "TPCs: [ { C:0 T:1 }, { C:2 T:3 } ]" };
  std::optional<std::vector<ID_t>> const expectedIDs
    (std::in_place, { ID_t{ 0U, 1U }, ID_t{ 2U, 3U } });

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readOptionalIDsequence(validatedConfig.TPCs);
  static_assert
    (std::is_same_v<decltype(ids), std::optional<std::vector<ID_t>>>);

  BOOST_TEST(ids.has_value() == expectedIDs.has_value());
  if (expectedIDs.has_value()) {
    BOOST_TEST(ids->size() == expectedIDs->size());
    auto const n = std::min(ids->size(), expectedIDs->size());
    for (std::size_t i = 0; i < n; ++i) {
      auto const& id = ids.value()[i];
      ID_t const& expectedID = expectedIDs.value()[i];

      BOOST_TEST_CONTEXT("Item [" << i << "]") {
        BOOST_TEST(id.isValid == expectedID.isValid);
        if (expectedID.isValid) BOOST_TEST(id == expectedID);
      } // BOOST_TEST_CONTEXT
    } // for
  }

} // test_OptionalTPCIDsequence_normal()

void test_OptionalTPCIDsequence_omitted

(

)

Definition at line 720 of file geo_types_fhicl_test.cc.

                                          {

  using ID_t = geo::TPCID;
  struct Config
    { geo::fhicl::OptionalTPCIDsequence TPCs { fhicl::Name("TPCs") }; };

  std::string const configStr { "" };
  std::optional<std::vector<ID_t>> const expectedIDs(std::nullopt);

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readOptionalIDsequence(validatedConfig.TPCs);
  static_assert
    (std::is_same_v<decltype(ids), std::optional<std::vector<ID_t>>>);

  BOOST_TEST(ids.has_value() == expectedIDs.has_value());
  if (expectedIDs.has_value()) {
    BOOST_TEST(ids->size() == expectedIDs->size());
    auto const n = std::min(ids->size(), expectedIDs->size());
    for (std::size_t i = 0; i < n; ++i) {
      auto const& id = ids.value()[i];
      ID_t const& expectedID = expectedIDs.value()[i];

      BOOST_TEST_CONTEXT("Item [" << i << "]") {
        BOOST_TEST(id.isValid == expectedID.isValid);
        if (expectedID.isValid) BOOST_TEST(id == expectedID);
      } // BOOST_TEST_CONTEXT
    } // for
  }

} // test_OptionalTPCIDsequence_omitted()

void test_OptionalWireID_omitted

(

)

Definition at line 1055 of file geo_types_fhicl_test.cc.

                                   {

  using ID_t = geo::WireID;
  struct Config { geo::fhicl::OptionalWireID Wire { fhicl::Name("Wire") }; };

  std::string const configStr { "" };

  std::optional<ID_t> const expectedID { std::nullopt };

  auto validatedConfig = validateConfig<Config>(configStr)();

  std::optional<ID_t> const id
    = geo::fhicl::readOptionalID(validatedConfig.Wire);
  BOOST_TEST(id.has_value() == expectedID.has_value());
  if (expectedID.has_value()) {
    BOOST_TEST(id->isValid == expectedID->isValid);
    if (expectedID->isValid) BOOST_TEST(id.value() == expectedID.value());
  }

} // test_OptionalWireID_omitted()

void test_OptionalWireID_present

(

)

Definition at line 1035 of file geo_types_fhicl_test.cc.

                                   {

  using ID_t = geo::WireID;
  struct Config { geo::fhicl::OptionalWireID Wire { fhicl::Name("Wire") }; };

  std::string const configStr { "Wire: { C:1 T:2 P:1 W:9 }" };
  std::optional<ID_t> const expectedID { std::in_place, 1U, 2U, 1U, 9U };

  auto validatedConfig = validateConfig<Config>(configStr)();

  std::optional<ID_t> const id = readOptionalID(validatedConfig.Wire);
  BOOST_TEST(id.has_value() == expectedID.has_value());
  if (expectedID.has_value()) {
    BOOST_TEST(id->isValid == expectedID->isValid);
    if (expectedID->isValid) BOOST_TEST(id.value() == expectedID.value());
  }

} // test_OptionalWireID_present()

void test_OptionalWireIDsequence_empty

(

)

Definition at line 1163 of file geo_types_fhicl_test.cc.

                                         {

  using ID_t = geo::WireID;
  struct Config
    { geo::fhicl::OptionalWireIDsequence Wires { fhicl::Name("Wires") }; };

  std::string const configStr { "Wires: []" };
  std::optional<std::vector<ID_t>> const expectedIDs(std::in_place);

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readOptionalIDsequence(validatedConfig.Wires);
  static_assert
    (std::is_same_v<decltype(ids), std::optional<std::vector<ID_t>>>);

  BOOST_TEST(ids.has_value() == expectedIDs.has_value());
  if (expectedIDs.has_value()) {
    BOOST_TEST(ids->size() == expectedIDs->size());
    auto const n = std::min(ids->size(), expectedIDs->size());
    for (std::size_t i = 0; i < n; ++i) {
      auto const& id = ids.value()[i];
      ID_t const& expectedID = expectedIDs.value()[i];

      BOOST_TEST_CONTEXT("Item [" << i << "]") {
        BOOST_TEST(id.isValid == expectedID.isValid);
        if (expectedID.isValid) BOOST_TEST(id == expectedID);
      } // BOOST_TEST_CONTEXT
    } // for
  }

} // test_OptionalWireIDsequence_empty()

void test_OptionalWireIDsequence_normal

(

)

Definition at line 1128 of file geo_types_fhicl_test.cc.

                                          {

  using ID_t = geo::WireID;
  struct Config
    { geo::fhicl::OptionalWireIDsequence Wires { fhicl::Name("Wires") }; };

  std::string const configStr
    { "Wires: [ { C:0 T:1 P:1 W:9 }, { C:2 T:3 P:0 W:7 } ]" };
  std::optional<std::vector<ID_t>> const expectedIDs
    (std::in_place, { ID_t{ 0U, 1U, 1U, 9U }, ID_t{ 2U, 3U, 0U, 7U } });

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readOptionalIDsequence(validatedConfig.Wires);
  static_assert
    (std::is_same_v<decltype(ids), std::optional<std::vector<ID_t>>>);

  BOOST_TEST(ids.has_value() == expectedIDs.has_value());
  if (expectedIDs.has_value()) {
    BOOST_TEST(ids->size() == expectedIDs->size());
    auto const n = std::min(ids->size(), expectedIDs->size());
    for (std::size_t i = 0; i < n; ++i) {
      auto const& id = ids.value()[i];
      ID_t const& expectedID = expectedIDs.value()[i];

      BOOST_TEST_CONTEXT("Item [" << i << "]") {
        BOOST_TEST(id.isValid == expectedID.isValid);
        if (expectedID.isValid) BOOST_TEST(id == expectedID);
      } // BOOST_TEST_CONTEXT
    } // for
  }

} // test_OptionalWireIDsequence_normal()

void test_OptionalWireIDsequence_omitted

(

)

Definition at line 1196 of file geo_types_fhicl_test.cc.

                                           {

  using ID_t = geo::WireID;
  struct Config
    { geo::fhicl::OptionalWireIDsequence Wires { fhicl::Name("Wires") }; };

  std::string const configStr { "" };
  std::optional<std::vector<ID_t>> const expectedIDs(std::nullopt);

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readOptionalIDsequence(validatedConfig.Wires);
  static_assert
    (std::is_same_v<decltype(ids), std::optional<std::vector<ID_t>>>);

  BOOST_TEST(ids.has_value() == expectedIDs.has_value());
  if (expectedIDs.has_value()) {
    BOOST_TEST(ids->size() == expectedIDs->size());
    auto const n = std::min(ids->size(), expectedIDs->size());
    for (std::size_t i = 0; i < n; ++i) {
      auto const& id = ids.value()[i];
      ID_t const& expectedID = expectedIDs.value()[i];

      BOOST_TEST_CONTEXT("Item [" << i << "]") {
        BOOST_TEST(id.isValid == expectedID.isValid);
        if (expectedID.isValid) BOOST_TEST(id == expectedID);
      } // BOOST_TEST_CONTEXT
    } // for
  }

} // test_OptionalWireIDsequence_omitted()

void test_PlaneID_invalid

(

)

Definition at line 777 of file geo_types_fhicl_test.cc.

                            {

  using ID_t = geo::PlaneID;
  struct Config { geo::fhicl::PlaneID Plane { fhicl::Name("Plane") }; };

  std::string const configStr { "Plane: { isValid:false }" };
  ID_t const expectedID {};

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto const id = geo::fhicl::readID(validatedConfig.Plane);
  static_assert(std::is_same_v<decltype(id), ID_t const>);
  BOOST_TEST(id.isValid == expectedID.isValid);
  if (expectedID.isValid) {
    BOOST_TEST(validatedConfig.Plane().ID() == expectedID);
    BOOST_TEST(id == expectedID);
  }
} // test_PlaneID_invalid()

void test_PlaneID_normal

(

)

Definition at line 757 of file geo_types_fhicl_test.cc.

                           {

  using ID_t = geo::PlaneID;
  struct Config { geo::fhicl::PlaneID Plane { fhicl::Name("Plane") }; };

  std::string const configStr { "Plane: { C:2 T:3 P:1 }" };
  ID_t const expectedID { 2U, 3U, 1U };

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto const id = geo::fhicl::readID(validatedConfig.Plane);
  static_assert(std::is_same_v<decltype(id), ID_t const>);
  BOOST_TEST(id.isValid == expectedID.isValid);
  if (expectedID.isValid) {
    BOOST_TEST(validatedConfig.Plane().ID() == expectedID);
    BOOST_TEST(id == expectedID);
  }
} // test_PlaneID_normal()

void test_PlaneIDsequence_empty

(

)

Definition at line 872 of file geo_types_fhicl_test.cc.

                                  {

  using ID_t = geo::PlaneID;
  struct Config
    { geo::fhicl::PlaneIDsequence Planes { fhicl::Name("Planes") }; };

  std::string const configStr { "Planes: []" };

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readIDsequence(validatedConfig.Planes);
  static_assert(std::is_same_v<decltype(ids), std::vector<ID_t>>);

  BOOST_TEST(ids.size() == 0U);

} // test_PlaneIDsequence_empty()

void test_PlaneIDsequence_normal

(

)

Definition at line 839 of file geo_types_fhicl_test.cc.

                                   {

  using ID_t = geo::PlaneID;
  struct Config
    { geo::fhicl::PlaneIDsequence Planes { fhicl::Name("Planes") }; };

  std::string const configStr
    { "Planes: [ { C:0 T:1 P:1 }, { C:2 T:3 P:0 } ]" };
  std::array<ID_t, 2U> const expectedIDs
  // BUG the double brace syntax is required to work around clang bug 21629
//    { ID_t{ 0U, 1U, 1U }, ID_t{ 2U, 3U, 0U } };
    {{ ID_t{ 0U, 1U, 1U }, ID_t{ 2U, 3U, 0U } }};

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readIDsequence(validatedConfig.Planes);
  static_assert(std::is_same_v<decltype(ids), std::vector<ID_t>>);

  BOOST_TEST(ids.size() == expectedIDs.size());
  auto const n = std::min(ids.size(), expectedIDs.size());
  for (std::size_t i = 0; i < n; ++i) {
    auto const& id = ids[i];
    ID_t const& expectedID = expectedIDs[i];

    BOOST_TEST_CONTEXT("Item [" << i << "]") {
      BOOST_TEST(id.isValid == expectedID.isValid);
      if (expectedID.isValid) BOOST_TEST(id == expectedID);
    } // BOOST_TEST_CONTEXT
  } // for

} // test_PlaneIDsequence_normal()

void test_TPCID_invalid

(

)

Definition at line 542 of file geo_types_fhicl_test.cc.

                          {

  using ID_t = geo::TPCID;
  struct Config { geo::fhicl::TPCID TPC { fhicl::Name("TPC") }; };

  std::string const configStr { "TPC: { isValid:false }" };
  ID_t const expectedID {};

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto const id = geo::fhicl::readID(validatedConfig.TPC);
  static_assert(std::is_same_v<decltype(id), ID_t const>);
  BOOST_TEST(id.isValid == expectedID.isValid);
  if (expectedID.isValid) {
    BOOST_TEST(validatedConfig.TPC().ID() == expectedID);
    BOOST_TEST(id == expectedID);
  }
} // test_TPCID_invalid()

void test_TPCID_normal

(

)

Definition at line 522 of file geo_types_fhicl_test.cc.

                         {

  using ID_t = geo::TPCID;
  struct Config { geo::fhicl::TPCID TPC { fhicl::Name("TPC") }; };

  std::string const configStr { "TPC: { C:2 T:3 }" };
  ID_t const expectedID { 2U, 3U };

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto const id = geo::fhicl::readID(validatedConfig.TPC);
  static_assert(std::is_same_v<decltype(id), ID_t const>);
  BOOST_TEST(id.isValid == expectedID.isValid);
  if (expectedID.isValid) {
    BOOST_TEST(validatedConfig.TPC().ID() == expectedID);
    BOOST_TEST(id == expectedID);
  }
} // test_TPCID_normal()

void test_TPCIDsequence_empty

(

)

Definition at line 635 of file geo_types_fhicl_test.cc.

                                {

  using ID_t = geo::TPCID;
  struct Config
    { geo::fhicl::TPCIDsequence TPCs { fhicl::Name("TPCs") }; };

  std::string const configStr { "TPCs: []" };

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readIDsequence(validatedConfig.TPCs);
  static_assert(std::is_same_v<decltype(ids), std::vector<ID_t>>);

  BOOST_TEST(ids.size() == 0U);

} // test_TPCIDsequence_empty()

void test_TPCIDsequence_normal

(

)

Definition at line 604 of file geo_types_fhicl_test.cc.

                                 {

  using ID_t = geo::TPCID;
  struct Config
    { geo::fhicl::TPCIDsequence TPCs { fhicl::Name("TPCs") }; };

  std::string const configStr { "TPCs: [ { C:0 T:1 }, { C:2 T:3 } ]" };
  // BUG the double brace syntax is required to work around clang bug 21629
//  std::array<ID_t, 2U> const expectedIDs { ID_t{ 0U, 1U }, ID_t{ 2U, 3U } };
  std::array<ID_t, 2U> const expectedIDs {{ ID_t{ 0U, 1U }, ID_t{ 2U, 3U } }};

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readIDsequence(validatedConfig.TPCs);
  static_assert(std::is_same_v<decltype(ids), std::vector<ID_t>>);

  BOOST_TEST(ids.size() == expectedIDs.size());
  auto const n = std::min(ids.size(), expectedIDs.size());
  for (std::size_t i = 0; i < n; ++i) {
    auto const& id = ids[i];
    ID_t const& expectedID = expectedIDs[i];

    BOOST_TEST_CONTEXT("Item [" << i << "]") {
      BOOST_TEST(id.isValid == expectedID.isValid);
      if (expectedID.isValid) BOOST_TEST(id == expectedID);
    } // BOOST_TEST_CONTEXT
  } // for

} // test_TPCIDsequence_normal()

void test_WireID_invalid

(

)

Definition at line 1015 of file geo_types_fhicl_test.cc.

                           {

  using ID_t = geo::WireID;
  struct Config { geo::fhicl::WireID Wire { fhicl::Name("Wire") }; };

  std::string const configStr { "Wire: { isValid:false }" };
  ID_t const expectedID {};

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto const id = geo::fhicl::readID(validatedConfig.Wire);
  static_assert(std::is_same_v<decltype(id), ID_t const>);
  BOOST_TEST(id.isValid == expectedID.isValid);
  if (expectedID.isValid) {
    BOOST_TEST(validatedConfig.Wire().ID() == expectedID);
    BOOST_TEST(id == expectedID);
  }
} // test_WireID_invalid()

void test_WireID_normal

(

)

Definition at line 995 of file geo_types_fhicl_test.cc.

                          {

  using ID_t = geo::WireID;
  struct Config { geo::fhicl::WireID Wire { fhicl::Name("Wire") }; };

  std::string const configStr { "Wire: { C:2 T:3 P:1 W:9 }" };
  ID_t const expectedID { 2U, 3U, 1U, 9U };

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto const id = geo::fhicl::readID(validatedConfig.Wire);
  static_assert(std::is_same_v<decltype(id), ID_t const>);
  BOOST_TEST(id.isValid == expectedID.isValid);
  if (expectedID.isValid) {
    BOOST_TEST(validatedConfig.Wire().ID() == expectedID);
    BOOST_TEST(id == expectedID);
  }
} // test_WireID_normal()

void test_WireIDsequence_empty

(

)

Definition at line 1110 of file geo_types_fhicl_test.cc.

                                 {

  using ID_t = geo::WireID;
  struct Config
    { geo::fhicl::WireIDsequence Wires { fhicl::Name("Wires") }; };

  std::string const configStr { "Wires: []" };

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readIDsequence(validatedConfig.Wires);
  static_assert(std::is_same_v<decltype(ids), std::vector<ID_t>>);

  BOOST_TEST(ids.size() == 0U);

} // test_WireIDsequence_empty()

void test_WireIDsequence_normal

(

)

Definition at line 1077 of file geo_types_fhicl_test.cc.

                                  {

  using ID_t = geo::WireID;
  struct Config
    { geo::fhicl::WireIDsequence Wires { fhicl::Name("Wires") }; };

  std::string const configStr
    { "Wires: [ { C:0 T:1 P:1 W:9 }, { C:2 T:3 P:0 W:7 } ]" };
  std::array<ID_t, 2U> const expectedIDs
  // BUG the double brace syntax is required to work around clang bug 21629
//    { ID_t{ 0U, 1U, 1U, 9U }, ID_t{ 2U, 3U, 0U, 7U } };
    {{ ID_t{ 0U, 1U, 1U, 9U }, ID_t{ 2U, 3U, 0U, 7U } }};

  auto validatedConfig = validateConfig<Config>(configStr)();

  auto ids = geo::fhicl::readIDsequence(validatedConfig.Wires);
  static_assert(std::is_same_v<decltype(ids), std::vector<ID_t>>);

  BOOST_TEST(ids.size() == expectedIDs.size());
  auto const n = std::min(ids.size(), expectedIDs.size());
  for (std::size_t i = 0; i < n; ++i) {
    auto const& id = ids[i];
    ID_t const& expectedID = expectedIDs[i];

    BOOST_TEST_CONTEXT("Item [" << i << "]") {
      BOOST_TEST(id.isValid == expectedID.isValid);
      if (expectedID.isValid) BOOST_TEST(id == expectedID);
    } // BOOST_TEST_CONTEXT
  } // for

} // test_WireIDsequence_normal()

void test_WireUnifiedInterface

(

)

Definition at line 1229 of file geo_types_fhicl_test.cc.

                                 {

  using ID_t = geo::WireID;
  struct Config {

    geo::fhicl::WireID Wire { fhicl::Name("Wire") };

    geo::fhicl::OptionalWireID MaybeWire { fhicl::Name("MaybeWire") };

    geo::fhicl::OptionalWireID NoWire { fhicl::Name("NoWire") };

    geo::fhicl::WireIDsequence Wires { fhicl::Name("Wires") };

    geo::fhicl::OptionalWireIDsequence MaybeWires { fhicl::Name("MaybeWires") };

    geo::fhicl::OptionalWireIDsequence NoWires { fhicl::Name("NoWires") };

  }; // struct Config

  std::string const configStr {
      "Wire:       { C:1 T:5 P:2 W:9 }"
    "\nMaybeWire:  { C:1 T:5 P:2 W:8 }"
    "\n# NoWire:     @nil"
    "\n"
    "\nWires:      [ { C:1 T:5 P:2 W:7 }, { C:1 T:5 P:2 W:6 } ] "
    "\nMaybeWires: [ { C:1 T:5 P:2 W:5 } ] "
    "\n# NoWires:    @nil"
    "\n"
    };

  auto const& config = validateConfig<Config>(configStr);

  ID_t const expected1                { 1U, 5U, 2U, 9U };
  ID_t const expected2                { 1U, 5U, 2U, 8U };
  std::array<ID_t, 2U> const expected4
  // BUG the double brace syntax is required to work around clang bug 21629
//    { ID_t{ 1U, 5U, 2U, 7U }, ID_t{ 1U, 5U, 2U, 6U } };
    {{ ID_t{ 1U, 5U, 2U, 7U }, ID_t{ 1U, 5U, 2U, 6U } }};
  std::array<ID_t, 1U> const expected5
  // BUG the double brace syntax is required to work around clang bug 21629
//     { ID_t{ 1U, 5U, 2U, 5U } };
    {{ ID_t{ 1U, 5U, 2U, 5U } }};

  ID_t const default3 { 1U, 5U, 0U, 9U };
  auto default3value = default3;

  std::vector<ID_t> const default6({
    ID_t{ 1U, 5U, 0U, 4U }, ID_t{ 1U, 5U, 0U, 3U }, ID_t{ 1U, 5U, 0U, 2U }
    });
  auto default6value = default6;

  //
  // read simple atom
  //
  auto id11 = geo::fhicl::readParameter(config().Wire);
  static_assert(std::is_same_v<decltype(id11), ID_t>);
  BOOST_TEST(id11 == expected1);

  //
  // read optional atom
  //

  // this one is present (default values should be ignored):
  auto id21 = geo::fhicl::readParameter(config().MaybeWire);
  static_assert(std::is_same_v<decltype(id21), std::optional<ID_t>>);
  BOOST_TEST(id21.has_value());
  if (id21.has_value()) BOOST_TEST(id21.value() == expected2);

  default3value = default3;
  auto id22 = geo::fhicl::readParameter(config().MaybeWire, default3);
  static_assert(std::is_same_v<decltype(id22), ID_t>);
  BOOST_TEST(id22 == expected2);
  BOOST_TEST(default3value == default3);

  default3value = default3;
  auto id23
    = geo::fhicl::readParameter(config().MaybeWire, std::move(default3));
  static_assert(std::is_same_v<decltype(id23), ID_t>);
  BOOST_TEST(id23 == expected2);
  BOOST_TEST(default3value == default3);

  // this one is omitted:
  auto id31 = geo::fhicl::readParameter(config().NoWire);
  static_assert(std::is_same_v<decltype(id31), std::optional<ID_t>>);
  BOOST_TEST(!id31.has_value());

  default3value = default3;
  auto id32 = geo::fhicl::readParameter(config().NoWire, default3);
  static_assert(std::is_same_v<decltype(id32), ID_t>);
  BOOST_TEST(id32 == default3);
  BOOST_TEST(default3value == default3);

  default3value = default3;
  auto id33 = geo::fhicl::readParameter(config().NoWire, std::move(default3));
  static_assert(std::is_same_v<decltype(id33), ID_t>);
  BOOST_TEST(id33 == default3);

  // test for compilation
  auto id34 = geo::fhicl::readParameter(config().NoWire, { 1U, 3U, 6U, 9U });
  BOOST_TEST(id34 == (geo::WireID{ 1U, 3U, 6U, 9U }));


  //
  // read sequence
  //
  auto id41 = geo::fhicl::readParameter(config().Wires);
  static_assert(std::is_same_v<decltype(id41), std::vector<ID_t>>);
  BOOST_TEST(id41.size() == expected4.size());
  std::size_t max41 = std::max(id41.size(), expected4.size());
  for (std::size_t i = 0U; i < max41; ++i) BOOST_TEST_CONTEXT("element " << i) {
    BOOST_TEST(id41[i] == expected4[i]);
  }

  //
  // read optional sequence
  //
  // this one is present (default values should be ignored):
  auto id51 = geo::fhicl::readParameter(config().MaybeWires);
  static_assert
    (std::is_same_v<decltype(id51), std::optional<std::vector<ID_t>>>);
  BOOST_TEST(id51.has_value());
  if (id51.has_value()) {
    BOOST_CHECK_EQUAL_COLLECTIONS
      (id51->begin(), id51->end(), expected5.begin(), expected5.end());
  }

  default6value = default6;
  auto id52 = geo::fhicl::readParameter(config().MaybeWires, default6value);
  static_assert(std::is_same_v<decltype(id52), std::vector<ID_t>>);
  BOOST_CHECK_EQUAL_COLLECTIONS
    (id52.begin(), id52.end(), expected5.begin(), expected5.end());
  BOOST_CHECK_EQUAL_COLLECTIONS(
    default6value.begin(), default6value.end(),
    default6.begin(), default6.end()
    );

  default6value = default6;
  auto id53
    = geo::fhicl::readParameter(config().MaybeWires, std::move(default6value));
  static_assert(std::is_same_v<decltype(id53), std::vector<ID_t>>);
  BOOST_CHECK_EQUAL_COLLECTIONS
    (id53.begin(), id53.end(), expected5.begin(), expected5.end());
  BOOST_CHECK_EQUAL_COLLECTIONS(
    default6value.begin(), default6value.end(),
    default6.begin(), default6.end()
    );

  // this one is omitted:
  auto id61 = geo::fhicl::readParameter(config().NoWires);
  static_assert
    (std::is_same_v<decltype(id61), std::optional<std::vector<ID_t>>>);
  BOOST_TEST(!id61.has_value());

  default6value = default6;
  auto id62 = geo::fhicl::readParameter(config().NoWires, default6value);
  static_assert(std::is_same_v<decltype(id62), std::vector<ID_t>>);
  BOOST_CHECK_EQUAL_COLLECTIONS
    (id62.begin(), id62.end(), default6.begin(), default6.end());
  BOOST_CHECK_EQUAL_COLLECTIONS(
    default6value.begin(), default6value.end(),
    default6.begin(), default6.end()
    );

  default6value = default6;
  auto id63
    = geo::fhicl::readParameter(config().NoWires, std::move(default6value));
  static_assert(std::is_same_v<decltype(id63), std::vector<ID_t>>);
  BOOST_CHECK_EQUAL_COLLECTIONS
    (id63.begin(), id63.end(), default6.begin(), default6.end());
  // this is a bit out of standard, since after moving an object is guaranteed
  // only to be good for destruction; yet usually implementations of std::vector
  // leave it as a fully valid empty vector:
  BOOST_TEST(default6value.empty());

} // test_WireUnifiedInterface()

template<typename Config >

fhicl::Table<Config> validateConfig

(

std::string const &

configStr

)

Definition at line 30 of file geo_types_fhicl_test.cc.

                                                              {
  fhicl::ParameterSet pset;
  pset = fhicl::ParameterSet::make(configStr);
  fhicl::Table<Config> validatedConfig { fhicl::Name("validatedConfig") };

  std::cout << std::string(80, '-') << std::endl;
  std::cout << "===> FHiCL configuration:";
  if (configStr.empty()) std::cout << " <empty>";
  else                   std::cout << "\n" << configStr;
  std::cout << std::endl;
  validatedConfig.print_allowed_configuration
    (std::cout << "===> Expected configuration: ");
  std::cout << std::endl;

  validatedConfig.validate_ParameterSet(pset);
  return validatedConfig;
} // validateConfig()