values_test.cc File Reference

#include "larcorealg/CoreUtils/values.h"
#include <boost/test/unit_test.hpp>
#include <numeric>
#include <vector>
#include <map>
#include <utility>
#include <cstddef>

Go to the source code of this file.

Macros
#define	BOOST_TEST_MODULE   ( values_test )

Functions
void	test_values ()
void	test_const_values ()
template<template< typename Key, typename Value, typename...Args > typename Map>
void	test_values_map ()
template<template< typename Key, typename Value, typename...Args > typename Map>
void	test_const_values_map ()
void	test_values_documentation ()
	BOOST_AUTO_TEST_CASE (values_testcase)

Macro Definition Documentation

#define BOOST_TEST_MODULE   ( values_test )

Definition at line 14 of file values_test.cc.

Function Documentation

BOOST_AUTO_TEST_CASE

(

values_testcase

)

Definition at line 191 of file values_test.cc.

                                      {

  test_values();
  test_const_values();
  test_values_map<std::map>();
  test_const_values_map<std::map>();

  test_values_documentation();

} // BOOST_AUTO_TEST_CASE(values_testcase)

void test_const_values

(

)

Definition at line 74 of file values_test.cc.

                         {

  // prepare the data set
  constexpr std::size_t N = 7U;

  std::vector<float> data(N);
  std::iota(data.begin(), data.end(), 0.0F);

  //
  // static checks
  //
  // for a vector, we expect exactly the same vector object as return value:
  static_assert(std::is_same_v<
    decltype(util::const_values(data)),
    std::add_lvalue_reference_t<std::vector<float> const>
    >
    );
  BOOST_TEST(&util::const_values(data) == &data);

  //
  // read-only access
  //
  std::size_t i = 0U;
  for (auto&& value: util::const_values(data)) {
    static_assert(std::is_const_v<std::remove_reference_t<decltype(value)>>);
    BOOST_TEST(value == data[i]);
    BOOST_TEST(std::addressof(value) == std::addressof(data[i]));
    ++i;
  } // for
  BOOST_TEST(i == data.size());

} // test_const_values()

template<template< typename Key, typename Value, typename...Args > typename Map>

void test_const_values_map

(

)

Definition at line 135 of file values_test.cc.

                             {

  // prepare the data set
  constexpr std::size_t N = 7U;
  constexpr double factor = 5.0;

  std::vector<int> keys(N);
  std::iota(keys.begin(), keys.end(), 0U);
  Map<int, float> data;
  for (int key: keys) data.emplace(key, key * factor);

  std::size_t i = 0U;
  for (auto&& value: util::const_values(data)) {
    static_assert(std::is_same_v<decltype(value), float const&>);
    BOOST_TEST(value == data[i]);
    BOOST_TEST(std::addressof(value) == std::addressof(data[i]));
    ++i;
  } // for
  BOOST_TEST(i == data.size());

} // test_const_values_map()

void test_values

(

)

Definition at line 26 of file values_test.cc.

                   {

  // prepare the data set
  constexpr std::size_t N = 7U;

  std::vector<float> data(N);
  std::iota(data.begin(), data.end(), 0.0F);

  //
  // static checks
  //
  // for a vector, we expect exactly the same vector object as return value:
  static_assert(std::is_same_v<
    decltype(util::values(data)),
    std::add_lvalue_reference_t<std::vector<float>>
    >
    );
  BOOST_TEST(&util::values(data) == &data);

  //
  // read-only access
  //
  {
    std::size_t i = 0U;
    for (auto&& value: util::values(std::as_const(data))) {
      BOOST_TEST(value == data[i]);
      BOOST_TEST(std::addressof(value) == std::addressof(data[i]));
      ++i;
    } // for
    BOOST_TEST(i == data.size());
  }

  //
  // read/write access
  //
  {
    std::size_t i = 0U;
    for (auto&& value: util::values(data)) {
      BOOST_TEST(value == data[i]);
      BOOST_TEST(std::addressof(value) == std::addressof(data[i]));
      ++i;
    } // for
    BOOST_TEST(i == data.size());
  }

} // test_values()

void test_values_documentation

(

)

Definition at line 159 of file values_test.cc.

                                 {
  /*
   * The promise:
   * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
   * std::map<int, float> data { { 1, 4.0F }, { 3, 12.0F }, { 2, 8.0F } };
   * std::vector<float> values;
   *
   * for (float value: util::values(data))
   *   values.push_back(value);
   * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   * will result in `values` vector being of size `3` and with values
   * `{ 4.0F, 8.0F, 12.0F }`
   */

  std::map<int, float> data { { 1, 4.0F }, { 3, 12.0F }, { 2, 8.0F } };
  std::vector<float> values;

  for (float value: util::values(data))
    values.push_back(value);

  // the test
  BOOST_TEST(values.size() == 3U);
  BOOST_TEST(values[0] ==  4.0F);
  BOOST_TEST(values[1] ==  8.0F);
  BOOST_TEST(values[2] == 12.0F);

} // test_values_documentation()

template<template< typename Key, typename Value, typename...Args > typename Map>

void test_values_map

(

)

Definition at line 110 of file values_test.cc.

                       {

  // prepare the data set
  constexpr std::size_t N = 7U;
  constexpr double factor = 5.0;

  std::vector<int> keys(N);
  std::iota(keys.begin(), keys.end(), 0U);
  Map<int, float> data;
  for (int key: keys) data.emplace(key, key * factor);

  std::size_t i = 0U;
  for (auto&& value: util::values(data)) {
    static_assert(std::is_same_v<decltype(value), float&>);
    BOOST_TEST(value == data[i]);
    BOOST_TEST(std::addressof(value) == std::addressof(data[i]));
    ++i;
  } // for
  BOOST_TEST(i == data.size());

} // test_values_map()