aggregate_t.cc File Reference

#include "boost/test/unit_test.hpp"
#include "MockRun.h"
#include "cetlib/map_vector.h"
#include <map>
#include <memory>
#include <ostream>
#include <string>
#include <tuple>
#include <vector>

Go to the source code of this file.

Macros
#define	BOOST_TEST_MODULE   (Product aggregation Test)

Functions
ostream &	std::operator<< (ostream &os, pair< string, unsigned > const &p)
ostream &	std::operator<< (ostream &os, pair< cet::map_vector_key, string > const &entry)
	BOOST_AUTO_TEST_CASE (class_type)
	BOOST_AUTO_TEST_CASE (numbers)
	BOOST_AUTO_TEST_CASE (vector)
	BOOST_AUTO_TEST_CASE (list)
	BOOST_AUTO_TEST_CASE (deque)
	BOOST_AUTO_TEST_CASE (array)
	BOOST_AUTO_TEST_CASE (map)
	BOOST_AUTO_TEST_CASE (multimap)
	BOOST_AUTO_TEST_CASE (set)
	BOOST_AUTO_TEST_CASE (pair)
	BOOST_AUTO_TEST_CASE (tuple)
	BOOST_AUTO_TEST_CASE (map_vector)
	BOOST_AUTO_TEST_CASE (string1)
	BOOST_AUTO_TEST_CASE (string2)

Macro Definition Documentation

#define BOOST_TEST_MODULE   (Product aggregation Test)

Definition at line 1 of file aggregate_t.cc.

Function Documentation

BOOST_AUTO_TEST_CASE

(

class_type

)

Definition at line 71 of file aggregate_t.cc.

{
  MockRun r1;
  r1.put<HoursPerWorker>(HoursPerWorker{"Sam", 12});
  r1.put<HoursPerWorker>(HoursPerWorker{"Sam", 14});
  auto sam = r1.get<HoursPerWorker>();
  BOOST_TEST(sam.name_ == "Sam");
  BOOST_TEST(sam.hours_ == 26u);

  MockRun r2;
  r2.put<HoursPerWorker>(HoursPerWorker{"John", 8});
  r2.put<HoursPerWorker>(HoursPerWorker{"Jim", 10});
  auto john = r2.get<HoursPerWorker>();
  BOOST_TEST(john.name_ == "John");
  BOOST_TEST(john.hours_ == 8u);
}

BOOST_AUTO_TEST_CASE

(

numbers

)

Definition at line 88 of file aggregate_t.cc.

{
  MockRun r;
  r.put<double>(14.3);
  r.put<double>(3.4);
  BOOST_CHECK_CLOSE_FRACTION(r.get<double>(), 17.7, tolerance);
}

BOOST_AUTO_TEST_CASE

(

vector

)

Definition at line 96 of file aggregate_t.cc.

{
  using nums_t = std::vector<int>;
  MockRun r;
  r.put<nums_t>(nums_t{1, 3, 5});
  r.put<nums_t>(nums_t{2, 4, 6});
  auto ref = {1, 3, 5, 2, 4, 6};
  BOOST_TEST(r.get<nums_t>() == ref, boost::test_tools::per_element{});
}

BOOST_AUTO_TEST_CASE

(

list

)

Definition at line 106 of file aggregate_t.cc.

{
  using chars_t = std::list<char>;
  MockRun r;
  r.put<chars_t>(chars_t{'a', 'b', 'c'});
  r.put<chars_t>(chars_t{'y', 'z'});
  auto ref = {'a', 'b', 'c', 'y', 'z'};
  BOOST_TEST(r.get<chars_t>() == ref, boost::test_tools::per_element{});
}

BOOST_AUTO_TEST_CASE

(

deque

)

Definition at line 116 of file aggregate_t.cc.

{
  using nums_t = std::deque<unsigned>;
  MockRun r;
  r.put<nums_t>(nums_t{0, 5, 8});
  r.put<nums_t>(nums_t{1, 2, 4});
  std::initializer_list<unsigned> const ref{0u, 5u, 8u, 1u, 2u, 4u};
  BOOST_TEST(r.get<nums_t>() == ref, boost::test_tools::per_element{});
}

BOOST_AUTO_TEST_CASE

(

array

)

Definition at line 126 of file aggregate_t.cc.

{
  using histo_t = std::array<int, 3>;
  MockRun r;
  r.put<histo_t>(histo_t{{1, 4, 7}});
  r.put<histo_t>(histo_t{{-1, 6, 92}});
  auto ref = {0, 10, 99};
  BOOST_TEST(r.get<histo_t>() == ref, boost::test_tools::per_element{});
}

BOOST_AUTO_TEST_CASE

(

map

)

Definition at line 136 of file aggregate_t.cc.

{
  using map_t = std::map<std::string, unsigned>;
  map_t const children{{"Billy", 7}, {"Josephine", 9}, {"Gregory", 0}};
  map_t const adults{{"Jennifer", 28}, {"Gregory", 47}, {"Ervin", 78}};
  MockRun r;
  r.put<map_t>(children);
  r.put<map_t>(adults);
  map_t const people{{"Billy", 7},
                     {"Ervin", 78},
                     {"Gregory", 0},
                     {"Jennifer", 28},
                     {"Josephine", 9}};
  BOOST_TEST(r.get<map_t>() == people);
}

BOOST_AUTO_TEST_CASE

(

multimap

)

Definition at line 152 of file aggregate_t.cc.

{
  using map_t = std::multimap<std::string, unsigned>;
  map_t const children{{"Billy", 7}, {"Josephine", 9}, {"Gregory", 0}};
  map_t const adults{{"Jennifer", 28}, {"Gregory", 47}, {"Ervin", 78}};
  MockRun r;
  r.put<map_t>(children);
  r.put<map_t>(adults);
  map_t const people{{"Billy", 7},
                     {"Ervin", 78},
                     {"Gregory", 0},
                     {"Gregory", 47},
                     {"Jennifer", 28},
                     {"Josephine", 9}};
  BOOST_TEST(r.get<map_t>() == people);
}

BOOST_AUTO_TEST_CASE

(

set

)

Definition at line 169 of file aggregate_t.cc.

{
  using set_t = std::set<std::string>;
  MockRun r;
  r.put<set_t>(set_t{"Brahms", "Beethoven"});
  r.put<set_t>(set_t{"Bach", "Brahms"});
  set_t const composers{"Bach", "Beethoven", "Brahms"};
  BOOST_TEST(r.get<set_t>() == composers);
}

BOOST_AUTO_TEST_CASE

(

pair

)

Definition at line 179 of file aggregate_t.cc.

{
  using pair_t = std::pair<unsigned, double>;
  MockRun r;
  r.put<pair_t>(pair_t{0u, 14.});
  r.put<pair_t>(pair_t{6u, 20.});
  auto result = r.get<pair_t>();
  BOOST_TEST(result.first == 6u);
  BOOST_CHECK_CLOSE_FRACTION(result.second, 34., tolerance);
}

BOOST_AUTO_TEST_CASE

(

tuple

)

Definition at line 190 of file aggregate_t.cc.

{
  using tuple_t = std::tuple<A, unsigned, double>;
  MockRun r;
  r.put<tuple_t>(tuple_t{"run1"s, 3, 1.2});
  r.put<tuple_t>(tuple_t{"run2"s, 74, 2.9});
  auto result = r.get<tuple_t>();
  BOOST_TEST(std::get<A>(result).name_ == "run1");
  BOOST_TEST(std::get<unsigned>(result) == 77u);
  BOOST_CHECK_CLOSE_FRACTION(std::get<double>(result), 4.1, tolerance);
}

BOOST_AUTO_TEST_CASE

(

map_vector

)

Definition at line 202 of file aggregate_t.cc.

{
  using mv_t = cet::map_vector<std::string>;
  using key_type = typename mv_t::key_type;
  mv_t primes;
  primes.insert({key_type{2}, "two"});
  primes.insert({key_type{3}, "three"});
  primes.insert({key_type{5}, "five"});

  mv_t more_nums;
  more_nums.insert({key_type{7}, "seven"});
  more_nums.insert({key_type{11}, "eleven"});
  more_nums.insert({key_type{13}, "thirteen"});

  MockRun r;
  r.put<mv_t>(primes);
  r.put<mv_t>(more_nums);

  mv_t ref;
  ref.insert({key_type{2}, "two"});
  ref.insert({key_type{3}, "three"});
  ref.insert({key_type{5}, "five"});
  ref.insert({key_type{7}, "seven"});
  ref.insert({key_type{11}, "eleven"});
  ref.insert({key_type{13}, "thirteen"});

  BOOST_TEST(r.get<mv_t>() == ref, boost::test_tools::per_element{});
}

BOOST_AUTO_TEST_CASE

(

string1

)

Definition at line 231 of file aggregate_t.cc.

{
  MockRun r;
  r.put<std::string>("howdy");
  r.put<std::string>("dowdy");
  BOOST_REQUIRE_EXCEPTION(
    r.get<std::string>(), art::Exception, [](art::Exception const& e) {
      return e.categoryCode() == art::errors::ProductCannotBeAggregated;
    });
}

BOOST_AUTO_TEST_CASE

(

string2

)

Definition at line 242 of file aggregate_t.cc.

{
  MockRun r;
  r.put<std::string>("howdy");
  r.put<std::string>("howdy");
  BOOST_TEST(r.get<std::string>() == "howdy");
}

ostream& std::operator<<	(	ostream &	os,
		pair< string, unsigned > const &	p
	)

Definition at line 55 of file aggregate_t.cc.

  {
    os << '[' << p.first << ',' << p.second << ']';
    return os;
  }

ostream& std::operator<<	(	ostream &	os,
		pair< cet::map_vector_key, string > const &	entry
	)

Definition at line 62 of file aggregate_t.cc.

  {
    os << '[' << entry.first.asUint() << ',' << entry.second << ']';
    return os;
  }