All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Macros | Functions
get_elements_test.cc File Reference

Test of util::get_elements(). More...

#include "larcorealg/CoreUtils/get_elements.h"
#include "larcorealg/CoreUtils/zip.h"
#include <boost/test/unit_test.hpp>
#include <vector>
#include <tuple>
#include <utility>
#include <cstddef>

Go to the source code of this file.

Macros

#define BOOST_TEST_MODULE   ( get_elements_test )
 

Functions

void test_get_elements ()
 
void test_get_const_elements ()
 
void test_get_elements_single ()
 
void test_get_const_elements_single ()
 
void get_elements_documentation_test ()
 
 BOOST_AUTO_TEST_CASE (get_elements_testcase)
 

Detailed Description

Test of util::get_elements().

Author
Gianluca Petrillo (petri.nosp@m.llo@.nosp@m.slac..nosp@m.stan.nosp@m.ford..nosp@m.edu)
Date
December 13, 2019

Definition in file get_elements_test.cc.

Macro Definition Documentation

#define BOOST_TEST_MODULE   ( get_elements_test )

Definition at line 16 of file get_elements_test.cc.

Function Documentation

BOOST_AUTO_TEST_CASE ( get_elements_testcase  )

Definition at line 259 of file get_elements_test.cc.

259  {
260 
261  test_get_elements();
262  test_get_const_elements();
263  test_get_elements_single();
264  test_get_const_elements_single();
265 
266  get_elements_documentation_test();
267 
268 } // BOOST_AUTO_TEST_CASE(get_elements_testcase)
test_get_const_elements_single
void test_get_const_elements_single()
Definition: get_elements_test.cc:157
test_get_elements
void test_get_elements()
Definition: get_elements_test.cc:27
test_get_elements_single
void test_get_elements_single()
Definition: get_elements_test.cc:117
test_get_const_elements
void test_get_const_elements()
Definition: get_elements_test.cc:71
get_elements_documentation_test
void get_elements_documentation_test()
Definition: get_elements_test.cc:198
void get_elements_documentation_test ( )

Definition at line 198 of file get_elements_test.cc.

198  {
199 
200  /*
201  * The promise:
202  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
203  * std::vector<std::tuple<char, int, float>> data
204  * { { 'z', 0, 1.0F }, { 'o', 1, 3.0F }, { 't', 2, 9.0F } };
205  * std::map<char, double> factors;
206  *
207  * for (auto const& [ letter, factor ]: util::get_elements<0U, 2U>(data)) {
208  * factors.emplace(letter, factor);
209  * }
210  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
211  * and
212  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
213  * std::vector<int> exponents;
214  *
215  * for (int exponent: util::get_elements<1U>(data)) {
216  * exponents.push_back(exponent);
217  * }
218  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
219  */
220 
221  std::vector<std::tuple<char, int, float>> data
222  { { 'z', 0, 1.0F }, { 'o', 1, 3.0F }, { 't', 2, 9.0F } };
223  std::map<char, double> factors;
224 
225  for (auto const& [ letter, factor ]: util::get_elements<0U, 2U>(data)) {
226  factors.emplace(letter, factor);
227  }
228 
229  std::vector<int> exponents;
230 
231  for (int exponent: util::get_elements<1U>(data)) {
232  exponents.push_back(exponent);
233  }
234 
235  //
236  // check
237  //
238  std::map<char, double> const expected_factors
239  { { 'z', 1.0F }, { 'o', 3.0F }, { 't', 9.0F } };
240  std::vector<int> const expected_exponents{ 0, 1, 2 };
241 
242  BOOST_TEST(factors.size() == expected_factors.size());
243  for (auto const& [ f, expected_f ]: util::zip(factors, expected_factors)) {
244  BOOST_TEST(f.first == expected_f.first);
245  BOOST_TEST(f.second == expected_f.second);
246  } // for
247 
248  BOOST_CHECK_EQUAL_COLLECTIONS(
249  exponents.cbegin(), exponents.cend(),
250  expected_exponents.begin(), expected_exponents.end()
251  );
252 
253 } // get_elements_documentation_test()
util::zip
auto zip(Iterables &&...iterables)
Range-for loop helper iterating across many collections at the same time.
Definition: zip.h:295
void test_get_const_elements ( )

Definition at line 71 of file get_elements_test.cc.

71  {
72 
73  struct A {};
74 
75  std::vector<std::tuple<int, void const*, A>> const data {
76  { 0, nullptr, A{} },
77  { 1, nullptr, A{} }
78  };
79 
80  //
81  // read-only access
82  //
83  {
84  auto iItem = data.cbegin();
85  for (auto&& [ index, a ]: util::get_elements<0U, 2U>(std::as_const(data))) {
86  static_assert(std::is_same_v<decltype(index), int const&>);
87  static_assert(std::is_same_v<decltype(a), A const&>);
88  BOOST_TEST(index == std::get<0U>(*iItem));
89  BOOST_TEST(&index == &std::get<0U>(*iItem));
90  BOOST_TEST(&a == &std::get<2U>(*iItem));
91  ++iItem;
92  }
93  BOOST_TEST((iItem == data.cend()));
94  }
95 
96  //
97  // read/write access
98  //
99  {
100  auto iItem = data.cbegin();
101  for (auto&& [ index, a ]: util::get_elements<0U, 2U>(data)) {
102  static_assert(std::is_same_v<decltype(index), int const&>);
103  static_assert(std::is_same_v<decltype(a), A const&>);
104  BOOST_TEST(index == std::get<0U>(*iItem));
105  BOOST_TEST(&index == &std::get<0U>(*iItem));
106  BOOST_TEST(&a == &std::get<2U>(*iItem));
107  ++iItem;
108  }
109  BOOST_TEST((iItem == data.cend()));
110  }
111 
112 } // test_get_const_elements()
a
process_name gaushit a
Definition: decode_signalprocess_icarus.fcl:37
lib.dedx.A
float A
Definition: dedx.py:137
void test_get_const_elements_single ( )

Definition at line 157 of file get_elements_test.cc.

157  {
158 
159  struct A {};
160 
161  std::vector<std::tuple<int, void const*, A>> const data {
162  { 0, nullptr, A{} },
163  { 1, nullptr, A{} }
164  };
165 
166  //
167  // read-only access
168  //
169  {
170  auto iItem = data.cbegin();
171  for (auto&& index: util::get_elements<0U>(std::as_const(data))) {
172  static_assert(std::is_same_v<decltype(index), int const&>);
173  BOOST_TEST(index == std::get<0U>(*iItem));
174  BOOST_TEST(&index == &std::get<0U>(*iItem));
175  ++iItem;
176  }
177  BOOST_TEST((iItem == data.cend()));
178  }
179 
180  //
181  // read/write access
182  //
183  {
184  auto iItem = data.cbegin();
185  for (auto&& index: util::get_elements<0U>(data)) {
186  static_assert(std::is_same_v<decltype(index), int const&>);
187  BOOST_TEST(index == std::get<0U>(*iItem));
188  BOOST_TEST(&index == &std::get<0U>(*iItem));
189  ++iItem;
190  }
191  BOOST_TEST((iItem == data.cend()));
192  }
193 
194 } // test_get_const_elements_single()
lib.dedx.A
float A
Definition: dedx.py:137
void test_get_elements ( )

Definition at line 27 of file get_elements_test.cc.

27  {
28 
29  struct A {};
30 
31  std::vector<std::tuple<int, void const*, A>> data {
32  { 0, nullptr, A{} },
33  { 1, nullptr, A{} }
34  };
35 
36  //
37  // read-only access
38  //
39  {
40  auto iItem = data.cbegin();
41  for (auto&& [ index, a ]: util::get_elements<0U, 2U>(std::as_const(data))) {
42  static_assert(std::is_same_v<decltype(index), int const&>);
43  static_assert(std::is_same_v<decltype(a), A const&>);
44  BOOST_TEST(index == std::get<0U>(*iItem));
45  BOOST_TEST(&index == &std::get<0U>(*iItem));
46  BOOST_TEST(&a == &std::get<2U>(*iItem));
47  ++iItem;
48  }
49  BOOST_TEST((iItem == data.cend()));
50  }
51 
52  //
53  // read/write access
54  //
55  {
56  auto iItem = data.cbegin();
57  for (auto&& [ index, a ]: util::get_elements<0U, 2U>(data)) {
58  static_assert(std::is_same_v<decltype(index), int&>);
59  static_assert(std::is_same_v<decltype(a), A&>);
60  BOOST_TEST(index == std::get<0U>(*iItem));
61  BOOST_TEST(&index == &std::get<0U>(*iItem));
62  BOOST_TEST(&a == &std::get<2U>(*iItem));
63  ++iItem;
64  }
65  BOOST_TEST((iItem == data.cend()));
66  }
67 
68 } // test_get_elements()
a
process_name gaushit a
Definition: decode_signalprocess_icarus.fcl:37
lib.dedx.A
float A
Definition: dedx.py:137
void test_get_elements_single ( )

Definition at line 117 of file get_elements_test.cc.

117  {
118 
119  struct A {};
120 
121  std::vector<std::tuple<int, void const*, A>> data {
122  { 0, nullptr, A{} },
123  { 1, nullptr, A{} }
124  };
125 
126  //
127  // read-only access
128  //
129  {
130  auto iItem = data.cbegin();
131  for (auto&& index: util::get_elements<0U>(std::as_const(data))) {
132  static_assert(std::is_same_v<decltype(index), int const&>);
133  BOOST_TEST(index == std::get<0U>(*iItem));
134  BOOST_TEST(&index == &std::get<0U>(*iItem));
135  ++iItem;
136  }
137  BOOST_TEST((iItem == data.cend()));
138  }
139 
140  //
141  // read/write access
142  //
143  {
144  auto iItem = data.cbegin();
145  for (auto&& index: util::get_elements<0U>(data)) {
146  static_assert(std::is_same_v<decltype(index), int&>);
147  BOOST_TEST(index == std::get<0U>(*iItem));
148  BOOST_TEST(&index == &std::get<0U>(*iItem));
149  ++iItem;
150  }
151  BOOST_TEST((iItem == data.cend()));
152  }
153 
154 } // test_get_elements_single()
lib.dedx.A
float A
Definition: dedx.py:137
Generated by   doxygen 1.8.5