#include "TestUtils/NameSelector.h"
#include "canvas/Utilities/Exception.h"
#include <cetlib/quiet_unit_test.hpp>
#include <boost/test/test_tools.hpp>
#include <string>
#include <iostream>

Macros
#define	BOOST_TEST_MODULE ( NameSelector_test )

Functions
void	CheckNames (testing::NameSelector const &selector, std::vector< std::string > const &names)

	BOOST_AUTO_TEST_CASE (SimpleTest)

	BOOST_AUTO_TEST_CASE (MissingQuery)

	BOOST_AUTO_TEST_CASE (DefaultConstructorTest)

	BOOST_AUTO_TEST_CASE (DefaultThrowTest)

	BOOST_AUTO_TEST_CASE (DefaultRejectTest)

	BOOST_AUTO_TEST_CASE (DefaultAcceptTest)

	BOOST_AUTO_TEST_CASE (SetDefinitionTest)

	BOOST_AUTO_TEST_CASE (OverrideTest)

	BOOST_AUTO_TEST_CASE (GlobalSpecTest)

	BOOST_AUTO_TEST_CASE (ClearAllTest)

Macro Definition Documentation

#define BOOST_TEST_MODULE ( NameSelector_test )

Definition at line 15 of file NameSelector_test.cxx.

Function Documentation

BOOST_AUTO_TEST_CASE ( SimpleTest )

Definition at line 86 of file NameSelector_test.cxx.

                                  {
   
   // default answer: yes
   testing::NameSelector selector;
   
   //
   // initialize with simple elements
   //
   std::cout << "SimpleTest" << std::endl;
   selector.ParseNames("accept_one", "+accept_two");
   selector.ParseName("-reject_three");
   
   //
   // visually verify the configuration
   //
   selector.PrintConfiguration(std::cout);
   std::cout << std::endl;
   
   //
   // check all the symbols, plus one
   //
   CheckNames(selector, {
     "accept_one", "accept_two", "reject_three", "accept_unknown"
     });
   
   //
   // verify that we did not miss anything
   //
   BOOST_CHECK(selector.CheckQueryRegistry(std::cout));
   
 } // BOOST_AUTO_TEST_CASE(SimpleTest)

BOOST_AUTO_TEST_CASE ( MissingQuery )

Definition at line 122 of file NameSelector_test.cxx.

                                    {
   
   // default answer: yes
   testing::NameSelector selector;
   
   //
   // initialize with simple elements
   //
   std::cout << "MissingQuery" << std::endl;
   selector.ParseName("accept_one");
   
   //
   // verify that we did miss something
   //
   BOOST_CHECK(!selector.CheckQueryRegistry(std::cout));
   
 } // BOOST_AUTO_TEST_CASE(MissingQuery)

BOOST_AUTO_TEST_CASE ( DefaultConstructorTest )

Definition at line 144 of file NameSelector_test.cxx.

                                              {
   
   // default answer: yes
   testing::NameSelector selector;
   
   //
   // initialize with simple elements
   //
   std::cout << "DefaultConstructorTest" << std::endl;
   
   //
   // visually verify the configuration
   //
   selector.PrintConfiguration(std::cout);
   std::cout << std::endl;
   
   //
   // check all the symbols
   //
   CheckNames(selector, { "accept_one", "accept_two" });
   
 } // BOOST_AUTO_TEST_CASE(DefaultConstructorTest)

BOOST_AUTO_TEST_CASE ( DefaultThrowTest )

Definition at line 171 of file NameSelector_test.cxx.

                                        {
   
   // default answer: yes
   testing::NameSelector selector(testing::NameSelector::rsThrow);
   
   //
   // initialize with simple elements
   //
   std::cout << "DefaultThrowTest" << std::endl;
   selector.ParseNames("accept_one", "-reject_three");
   
   //
   // check all the symbols
   //
   CheckNames(selector, { "accept_one", "reject_three", "throw_two" });
   
 } // BOOST_AUTO_TEST_CASE(DefaultThrowTest)

BOOST_AUTO_TEST_CASE ( DefaultRejectTest )

Definition at line 193 of file NameSelector_test.cxx.

                                         {
   
   // default answer: yes
   testing::NameSelector selector(testing::NameSelector::rsRejected);
   
   //
   // initialize with simple elements
   //
   std::cout << "DefaultRejectTest" << std::endl;
   selector.ParseNames("accept_one", "-reject_three");
   
   //
   // check all the symbols, plus one
   //
   CheckNames(selector, { "accept_one", "reject_two", "reject_unknown" });
   
 } // BOOST_AUTO_TEST_CASE(DefaultRejectTest)

BOOST_AUTO_TEST_CASE ( DefaultAcceptTest )

Definition at line 215 of file NameSelector_test.cxx.

                                         {
   
   // default answer: yes
   testing::NameSelector selector(testing::NameSelector::rsAccepted);
   
   //
   // initialize with simple elements
   //
   std::cout << "DefaultAcceptTest" << std::endl;
   selector.ParseNames("accept_one", "-reject_three");
   
   //
   // check all the symbols, plus one
   //
   CheckNames(selector, { "accept_one", "accept_two", "accept_unknown" });
   
 } // BOOST_AUTO_TEST_CASE(DefaultAcceptTest)

BOOST_AUTO_TEST_CASE ( SetDefinitionTest )

Definition at line 237 of file NameSelector_test.cxx.

                                         {
   
   // default answer: yes
   testing::NameSelector selector;
   
   // set 2 does not follow the naming convention because it will be subtracted
   selector.AddToDefinition
     ("set1", "accept_set1_one", "+accept_set1_two", "-reject_set1_three");
   selector.AddToDefinition
     ("set2", "-accept_set2_one", "-accept_set2_two", "+reject_set2_three");
   selector.Define("set3", std::vector<std::string>
     { "accept_set3_one", "+accept_set3_two", "-reject_set3_three" }
     );
   
   //
   // initialize with simple elements
   //
   std::cout << "SetDefinitionTest" << std::endl;
   selector.ParseNames("accept_one", "set1", "-@set2", "+set3", "-reject_two");
   
   //
   // visually verify the configuration
   //
   selector.PrintConfiguration(std::cout);
   std::cout << std::endl;
   
   //
   // check all the symbols, plus one
   //
   CheckNames(selector, {
     "accept_set1_one", "accept_set1_two", "reject_set1_three",
     "accept_set2_one", "accept_set2_two", "reject_set2_three",
     "accept_one", "reject_two", "accept_unknown"
     });
   
 } // BOOST_AUTO_TEST_CASE(SetDefinitionTest)

BOOST_AUTO_TEST_CASE ( OverrideTest )

Definition at line 278 of file NameSelector_test.cxx.

                                    {
   
   // default answer: yes
   testing::NameSelector selector;
   
   // set does not follow the naming convention because it will be subtracted
   selector.AddToDefinition("default",
     "accept_one", "-accept_two", "+reject_three"
     );
   
   //
   // initialize with simple elements
   //
   std::cout << "OverrideTest" << std::endl;
   selector.ParseNames("+reject_three", "-default", "accept_one", "accept_four");
   
   //
   // visually verify the configuration
   //
   selector.PrintConfiguration(std::cout);
   std::cout << std::endl;
   
   //
   // check all the symbols
   //
   CheckNames(selector, {
     "accept_one", "accept_two", "reject_three", "accept_four"
     });
   
 } // BOOST_AUTO_TEST_CASE(OverrideTest)

BOOST_AUTO_TEST_CASE ( GlobalSpecTest )

Definition at line 313 of file NameSelector_test.cxx.

                                      {
   
   // default answer: yes
   testing::NameSelector selector;
   
   // set 2 does not follow the naming convention because it will be subtracted
   selector.AddToDefinition("default",
     "accept_one", "-accept_two", "+reject_three"
     );
   
   //
   // initialize with simple elements
   //
   std::cout << "GlobalSpecTest" << std::endl;
   selector.ParseNames("accept_one", "-*", "-reject_three", "accept_four");
   
   //
   // visually verify the configuration
   //
   selector.PrintConfiguration(std::cout);
   std::cout << std::endl;
   
   //
   // check all the symbols, plus one
   //
   CheckNames(selector, {
     "accept_one", "reject_unknown", "reject_three", "accept_four"
     });
   
 } // BOOST_AUTO_TEST_CASE(GlobalSpecTest)

BOOST_AUTO_TEST_CASE ( ClearAllTest )

Definition at line 348 of file NameSelector_test.cxx.

                                    {
   
   // default answer: yes
   testing::NameSelector selector(testing::NameSelector::rsThrow);
   
   //
   // initialize
   //
   std::cout << "ClearAllTest" << std::endl;
   selector.ParseNames("throw_lost", "!", "-reject_three", "accept_four");
   
   //
   // visually verify the configuration
   //
   selector.PrintConfiguration(std::cout);
   std::cout << std::endl;
   
   //
   // check all the symbols, plus one
   //
   CheckNames(selector, {
     "throw_lost", "throw_unknown", "reject_three", "accept_four"
     });
   
 } // BOOST_AUTO_TEST_CASE(ClearAllTest)

void CheckNames	(	testing::NameSelector const &	selector,
		std::vector< std::string > const &	names
	)

In the following tests, the names are conventionally called "acceptXXX" if the final result of the query is expected to be acceptance, "rejectXXX" if the final result of the query is expected to be rejection, or "throwXXX" if the final result of the query is expected to be the throw of an exception.

If an error does happen, run the test with '–log_level=all' to get enough information to track the error location:

for an unexpected exception (even without '–log_level=all'):

.../NameSelector_test.cxx(53): error in "DefaultThrowTest": check selector.Query(name) == testing::NameSelector::rsAccepted failed [2 != 1] unknown location(0): fatal error in "DefaultThrowTest": std::exception: -— Configuration BEGIN NameSelector: name 'accept_unknown' not configured. -— Configuration END

Boost error points to the test name ("DefaultThrowTest") and to the check that failed (line 53), while the message of the exception fills in with the name being checked
for a wrong result, running with '–log_level=all':

Testing 'accept_unknown' ../NameSelector_test.cxx(53): error in "DefaultRejectTest": check selector.Query(name) == testing::NameSelector::rsAccepted failed [0 != 1]

Boost points to the test and the failed check as before, while BOOST_TEST_MESSAGE informs about which name was being tested.

Definition at line 53 of file NameSelector_test.cxx.

 {
   
   for (std::string const& name: names) {
     BOOST_TEST_MESSAGE("Testing '" << name << "'");
     if (name.find("throw") == 0U) {
       BOOST_CHECK_EQUAL(selector.Query(name), testing::NameSelector::rsThrow);
       BOOST_CHECK_THROW(selector(name), art::Exception);
       BOOST_CHECK_THROW(selector.Accepted(name), art::Exception);
       BOOST_CHECK_THROW(selector.Rejected(name), art::Exception);
     }
     else if (name.find("reject") == 0U) {
       BOOST_CHECK_EQUAL
         (selector.Query(name), testing::NameSelector::rsRejected);
       BOOST_CHECK(!selector(name));
       BOOST_CHECK(!selector.Accepted(name));
       BOOST_CHECK(selector.Rejected(name));
     }
     else { // accept
       BOOST_CHECK_EQUAL
         (selector.Query(name), testing::NameSelector::rsAccepted);
       BOOST_CHECK(selector(name));
       BOOST_CHECK(selector.Accepted(name));
       BOOST_CHECK(!selector.Rejected(name));
     }
   } // for
   
 } // CheckNames()

Macros

Functions

Macro Definition Documentation

Function Documentation