RangeForWrapper_test.cc File Reference

Test for RangeForWrapper utilities. More...

#include "lardata/Utilities/RangeForWrapper.h"
#include <boost/test/unit_test.hpp>
#include <iterator>
#include <numeric>
#include <limits>
#include <type_traits>
#include <initializer_list>

Go to the source code of this file.

Classes
class	base_iterator< Value >
struct	begin_iterator_t
struct	end_iterator_t
struct	begin_const_iterator_t
struct	end_const_iterator_t
struct	Data

Macros
#define	BOOST_TEST_MODULE   ( RangeForWrapper_test )

Typedefs
using	wrapper_type = util::details::RangeForWrapperIterator< begin_iterator_t, end_iterator_t >
using	const_wrapper_type = util::details::RangeForWrapperIterator< begin_const_iterator_t, end_const_iterator_t >

Functions
template<typename ValueL , typename ValueR >
bool	operator!= (base_iterator< ValueL > const &a, base_iterator< ValueR > const &b)
template<typename T >
T	copy (T const &v)
template<typename DataColl >
void	const_test (DataColl const &data, int expected_total)
template<typename DataColl >
void	test (DataColl &data, int expected_total)
template<typename Iter , typename RefIter >
void	iterator_tests (Iter iter, RefIter refIter, RefIter refEnd)
template<typename Iter , typename RefIter >
void	const_input_iterator_tests (Iter iter, RefIter refIter, RefIter refEnd)
template<typename Iter , typename RefIter >
void	input_iterator_tests (Iter iter, RefIter refIter, RefIter refEnd)
template<typename Iter , typename RefIter >
void	const_output_iterator_tests (Iter iter, RefIter refIter, RefIter refEnd)
template<typename Iter , typename RefIter >
void	output_iterator_tests (Iter iter, RefIter refIter, RefIter refEnd)
template<typename Iter , typename RefIter >
void	const_forward_iterator_tests (Iter iter, RefIter refIter, RefIter refEnd)
template<typename Iter , typename RefIter >
void	forward_iterator_tests (Iter iter, RefIter refIter, RefIter refEnd)
template<typename Iter , typename RefIter >
void	const_bidirectional_iterator_tests (Iter iter, RefIter refIter, RefIter refEnd)
template<typename Iter , typename RefIter >
void	bidirectional_iterator_tests (Iter iter, RefIter refIter, RefIter refEnd)
template<typename Iter , typename RefIter >
void	const_random_access_iterator_tests (Iter iter, RefIter refIter, RefIter refEnd)
template<typename Iter , typename RefIter >
void	random_access_iterator_tests (Iter iter, RefIter refIter, RefIter refEnd)
template<bool IsConst, typename Iter , typename RefIter >
std::enable_if_t< IsConst >	iterator_test_impl (Iter iter, RefIter refIter, RefIter refEnd, std::input_iterator_tag)
template<bool IsConst, typename Iter , typename RefIter >
std::enable_if_t<!IsConst >	iterator_test_impl (Iter iter, RefIter refIter, RefIter refEnd, std::input_iterator_tag tag)
template<bool IsConst, typename Iter , typename RefIter >
std::enable_if_t< IsConst >	iterator_test_impl (Iter iter, RefIter refIter, RefIter refEnd, std::output_iterator_tag)
template<bool IsConst, typename Iter , typename RefIter >
std::enable_if_t<!IsConst >	iterator_test_impl (Iter iter, RefIter refIter, RefIter refEnd, std::output_iterator_tag tag)
template<bool IsConst, typename Iter , typename RefIter >
std::enable_if_t< IsConst >	iterator_test_impl (Iter iter, RefIter refIter, RefIter refEnd, std::forward_iterator_tag)
template<bool IsConst, typename Iter , typename RefIter >
std::enable_if_t<!IsConst >	iterator_test_impl (Iter iter, RefIter refIter, RefIter refEnd, std::forward_iterator_tag tag)
template<bool IsConst, typename Iter , typename RefIter >
std::enable_if_t< IsConst >	iterator_test_impl (Iter iter, RefIter refIter, RefIter refEnd, std::bidirectional_iterator_tag)
template<bool IsConst, typename Iter , typename RefIter >
std::enable_if_t<!IsConst >	iterator_test_impl (Iter iter, RefIter refIter, RefIter refEnd, std::bidirectional_iterator_tag tag)
template<bool IsConst, typename Iter , typename RefIter >
std::enable_if_t< IsConst >	iterator_test_impl (Iter iter, RefIter refIter, RefIter refEnd, std::random_access_iterator_tag)
template<bool IsConst, typename Iter , typename RefIter >
std::enable_if_t<!IsConst >	iterator_test_impl (Iter iter, RefIter refIter, RefIter refEnd, std::random_access_iterator_tag tag)
template<typename Iter , typename RefIter >
void	iterator_test (Iter iter, RefIter refIter, RefIter refEnd)
template<bool IsConst>
void	RangeForWrapperIteratorStandardsTest ()
	BOOST_AUTO_TEST_CASE (RangeForWrapperSameIterator_test)
	BOOST_AUTO_TEST_CASE (RangeForWrapperDifferentIterator_test)
	BOOST_AUTO_TEST_CASE (RangeForWrapperIteratorStandardsTestCase)

Detailed Description

Test for RangeForWrapper utilities.

Author

Gianluca Petrillo (petri.nosp@m.llo@.nosp@m.fnal..nosp@m.gov)

Date

December 29, 2016

See Also

RangeForWrapper.h

The test is run with no arguments.

Definition in file RangeForWrapper_test.cc.

Macro Definition Documentation

#define BOOST_TEST_MODULE   ( RangeForWrapper_test )

Definition at line 16 of file RangeForWrapper_test.cc.

Typedef Documentation

using const_wrapper_type = util::details::RangeForWrapperIterator<begin_const_iterator_t, end_const_iterator_t>

Definition at line 69 of file RangeForWrapper_test.cc.

using wrapper_type = util::details::RangeForWrapperIterator<begin_iterator_t, end_iterator_t>

Definition at line 68 of file RangeForWrapper_test.cc.

Function Documentation

template<typename Iter , typename RefIter >

void bidirectional_iterator_tests	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd
	)

Definition at line 423 of file RangeForWrapper_test.cc.

{
  const_bidirectional_iterator_tests(iter, refIter, refEnd);
} // bidirectional_iterator_tests()

BOOST_AUTO_TEST_CASE

(

RangeForWrapperSameIterator_test

)

Definition at line 618 of file RangeForWrapper_test.cc.

                                                       {

  std::vector vdata { 2, 3, 4 };

  // static checks
  static_assert(std::is_same<
      std::decay_t<decltype(vdata)>,
      std::decay_t<decltype(vdata | util::range_for)>
    >::value,
    "util::range_for should be pass-through!"
    );
  static_assert(
    std::is_lvalue_reference<decltype(vdata | util::range_for)>::value,
    "Pass-through on a lvalue should return a lvalue reference"
    );

  static_assert(
    !std::is_lvalue_reference
      <decltype(copy(vdata) | util::range_for)>::value,
    "Pass-through on a rvalue should return a rvalue (or its reference)"
    );

  BOOST_TEST(&vdata == &(vdata | util::range_for));

  auto const expected_total = std::accumulate(vdata.begin(), vdata.end(), 0);

  const_test(vdata, expected_total);

  test(vdata, expected_total);

} // BOOST_AUTO_TEST_CASE(RangeForWrapperSameIterator_test_test)

BOOST_AUTO_TEST_CASE

(

RangeForWrapperDifferentIterator_test

)

Definition at line 651 of file RangeForWrapper_test.cc.

                                                            {

  std::vector vdata { 2, 3, 4 };

  Data data { 2, 3, 4 };

  auto expected_total = std::accumulate(vdata.begin(), vdata.end(), 0);

  // static check
  static_assert(!std::is_same<
      std::decay_t<decltype(data)>,
      std::decay_t<decltype(data | util::range_for)>
    >::value,
    "util::range_for should generate a wrapper!"
    );

//  for (double d: data); // this should fail compilation

  const_test(data, expected_total);

  test(data, expected_total);

} // BOOST_AUTO_TEST_CASE(RangeForWrapperDifferentIterator_test_test)

BOOST_AUTO_TEST_CASE

(

RangeForWrapperIteratorStandardsTestCase

)

Definition at line 676 of file RangeForWrapper_test.cc.

                                                               {

  RangeForWrapperIteratorStandardsTest<false>(); // mutable range test
  RangeForWrapperIteratorStandardsTest<true>(); // constant range test

} // BOOST_AUTO_TEST_CASE(RangeForWrapperIteratorStandardsTestCase)

template<typename Iter , typename RefIter >

void const_bidirectional_iterator_tests	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd
	)

Definition at line 395 of file RangeForWrapper_test.cc.

{
  const bool isEnd = refIter == refEnd;
//  const bool isLast = std::next(refIter) == refEnd;
  const bool isSingular = (iter == Iter());
  const bool isNormal = !isEnd && !isSingular;
  const bool isDereferenciable = isNormal;

  auto ia = isEnd? iter: std::next(iter);
  auto iaRef = isEnd? refIter: std::next(refIter);

  auto ib = ia;
  --ib;
  BOOST_TEST((ib != ia));
  BOOST_TEST((*ib == *std::prev(iaRef)));
  BOOST_TEST((++ib == ia));
  if (isDereferenciable) BOOST_TEST((*ib == *iaRef));

  ib--;
  BOOST_TEST((ib != ia));
  BOOST_TEST((*ib == *std::prev(iaRef)));
  BOOST_TEST((++ib == ia));
  if (isDereferenciable) BOOST_TEST((*ib == *iaRef));

} // const_bidirectional_iterator_tests()

template<typename Iter , typename RefIter >

void const_forward_iterator_tests	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd
	)

Definition at line 345 of file RangeForWrapper_test.cc.

{
  const bool isEnd = refIter == refEnd;
  const bool isSingular = (iter == Iter());
  const bool isNormal = !isEnd && !isSingular;
  const bool isDereferenciable = isNormal;

  static_assert(std::is_default_constructible<Iter>(),
    "Forward iterator concept violation");

  using traits_t = std::iterator_traits<Iter>;
  using dereference_t = std::remove_reference_t<decltype(*iter)>;
  constexpr bool isConst = std::is_const<dereference_t>();

  static_assert(
    std::is_same<
      typename traits_t::reference,
      std::add_lvalue_reference_t<
        std::conditional_t<isConst,
          std::add_const_t<typename traits_t::value_type>,
          typename traits_t::value_type
        >
      >
    >(),
    "Forward iterator concept violation"
    );

  if (isDereferenciable) {
    auto ia = iter, ib = iter;

    BOOST_TEST((ia == ib));

    BOOST_TEST((&*ia == &*ib));

    BOOST_TEST((++ia == ++ib));

  }

} // const_forward_iterator_tests()

template<typename Iter , typename RefIter >

void const_input_iterator_tests	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd
	)

Definition at line 223 of file RangeForWrapper_test.cc.

{
  const bool isEnd = refIter == refEnd;
  const bool isSingular = (iter == Iter());
  const bool isNormal = !isEnd && !isSingular;
//  const bool isDereferenciable = isNormal;
  const bool isLast = (std::next(refIter) == refEnd);

  static_assert(std::is_same<
    typename std::iterator_traits<Iter>::reference,
    decltype(Iter(iter).operator*())
    >(), "Inconsistent return type for dereference operator");

  if (!isEnd) {
    auto ia = iter;
    if (!isSingular) BOOST_TEST(++ia != iter);
  }

  if (isNormal) {
    auto ia = iter, ib = iter;
    ia++; ++ib;
    BOOST_TEST(ia == ib);
    if (!isLast) {
      auto ia = iter;
      BOOST_TEST(*(ia++) == *iter);
    }
  }

  {
    auto ia = iter;
    if (!isEnd)
      (void)ia++;
  }


} // const_input_iterator_tests()

template<typename Iter , typename RefIter >

void const_output_iterator_tests	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd
	)

Definition at line 270 of file RangeForWrapper_test.cc.

{
  const bool isEnd = refIter == refEnd;
  const bool isSingular = (iter == Iter());
  const bool isNormal = !isEnd && !isSingular;
//  const bool isDereferenciable = isNormal;
//  const bool isLast = (std::next(refIter) == refEnd);

  static_assert(std::is_same<
    typename std::iterator_traits<Iter>::reference,
    decltype(Iter(iter).operator*())
    >(), "Inconsistent return type for dereference operator");

  if (!isEnd) {
    auto ia = iter;
    auto addr = &ia;
    if (!isSingular) {
      BOOST_TEST((++ia != iter));
      BOOST_TEST((&++ia == addr));
    }
  }

  if (isNormal) {
    auto ia = iter, ib = iter;
    ia++; ++ib;
    BOOST_TEST(ia == ib);
  }

  {
    auto ia = iter;
    if (!isEnd) (void)ia++;
  }


} // const_output_iterator_tests()

template<typename Iter , typename RefIter >

void const_random_access_iterator_tests	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd
	)

Definition at line 431 of file RangeForWrapper_test.cc.

{
} // const_random_access_iterator_tests()

template<typename DataColl >

void const_test	(	DataColl const &	data,
		int	expected_total
	)

Definition at line 104 of file RangeForWrapper_test.cc.

{
  static_assert(
    !std::is_lvalue_reference
      <decltype(copy(data) | util::range_for)>::value,
    "util::range_for on a rvalue should return a rvalue"
    );

  int total = 0;
  for (int d: data | util::range_for) total += d;

  BOOST_TEST(total == expected_total);

  // from a temporary
  total = 0;
  for (int d: copy(data) | util::range_for) total += d;

  BOOST_TEST(total == expected_total);

} // const_test()

template<typename T >

T copy

(

T const &

v

)

Definition at line 98 of file RangeForWrapper_test.cc.

{ return v; }

template<typename Iter , typename RefIter >

void forward_iterator_tests	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd
	)

Definition at line 387 of file RangeForWrapper_test.cc.

{
  const_forward_iterator_tests(iter, refIter, refEnd);
} // forward_iterator_tests()

template<typename Iter , typename RefIter >

void input_iterator_tests	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd
	)

Definition at line 262 of file RangeForWrapper_test.cc.

{
  const_input_iterator_tests(iter, refIter, refEnd);
} // input_iterator_tests()

template<typename Iter , typename RefIter >

void iterator_test	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd
	)

Definition at line 539 of file RangeForWrapper_test.cc.

                                                               {
  //
  // dispatcher
  //
  using traits_t = std::iterator_traits<Iter>;
  constexpr bool IsConst
    = std::is_const<std::remove_reference_t<decltype(*iter)>>();

  iterator_test_impl<IsConst>
    (iter, refIter, refEnd, typename traits_t::iterator_category{});

} // iterator_test()

template<bool IsConst, typename Iter , typename RefIter >

std::enable_if_t<IsConst> iterator_test_impl	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd,
		std::input_iterator_tag
	)

Definition at line 448 of file RangeForWrapper_test.cc.

{
  iterator_tests(iter, refIter, refEnd);
  const_input_iterator_tests(iter, refIter, refEnd);
} // iterator_test_impl<const>(input iterator)

template<bool IsConst, typename Iter , typename RefIter >

std::enable_if_t<!IsConst> iterator_test_impl	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd,
		std::input_iterator_tag	tag
	)

Definition at line 457 of file RangeForWrapper_test.cc.

{
  iterator_tests(iter, refIter, refEnd);
  input_iterator_tests(iter, refIter, refEnd);
} // iterator_test_impl<non-const>(input iterator)

template<bool IsConst, typename Iter , typename RefIter >

std::enable_if_t<IsConst> iterator_test_impl	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd,
		std::output_iterator_tag
	)

Definition at line 466 of file RangeForWrapper_test.cc.

{
  iterator_tests(iter, refIter, refEnd);
  const_output_iterator_tests(iter, refIter, refEnd);
} // iterator_test_impl<const>(output iterator)

template<bool IsConst, typename Iter , typename RefIter >

std::enable_if_t<!IsConst> iterator_test_impl	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd,
		std::output_iterator_tag	tag
	)

Definition at line 475 of file RangeForWrapper_test.cc.

{
  iterator_tests(iter, refIter, refEnd);
  output_iterator_tests(iter, refIter, refEnd);
} // iterator_test_impl<non-const>(output iterator)

template<bool IsConst, typename Iter , typename RefIter >

std::enable_if_t<IsConst> iterator_test_impl	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd,
		std::forward_iterator_tag
	)

Definition at line 484 of file RangeForWrapper_test.cc.

{
  iterator_test_impl<IsConst>(iter, refIter, refEnd, std::input_iterator_tag{});
  iterator_test_impl<IsConst>(iter, refIter, refEnd, std::output_iterator_tag{});
  const_forward_iterator_tests(iter, refIter, refEnd);
} // iterator_test_impl<const>(random access iterator)

template<bool IsConst, typename Iter , typename RefIter >

std::enable_if_t<!IsConst> iterator_test_impl	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd,
		std::forward_iterator_tag	tag
	)

Definition at line 494 of file RangeForWrapper_test.cc.

{
  iterator_test_impl<IsConst>(iter, refIter, refEnd, std::input_iterator_tag{});
  iterator_test_impl<IsConst>(iter, refIter, refEnd, std::output_iterator_tag{});
  forward_iterator_tests(iter, refIter, refEnd);
} // iterator_test_impl<non-const>(forward iterator)

template<bool IsConst, typename Iter , typename RefIter >

std::enable_if_t<IsConst> iterator_test_impl	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd,
		std::bidirectional_iterator_tag
	)

Definition at line 504 of file RangeForWrapper_test.cc.

{
  iterator_test_impl<IsConst>(iter, refIter, refEnd, std::forward_iterator_tag{});
  const_random_access_iterator_tests(iter, refIter, refEnd);
} // iterator_test_impl<const>(forward iterator)

template<bool IsConst, typename Iter , typename RefIter >

std::enable_if_t<!IsConst> iterator_test_impl	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd,
		std::bidirectional_iterator_tag	tag
	)

Definition at line 513 of file RangeForWrapper_test.cc.

{
  iterator_test_impl<IsConst>(iter, refIter, refEnd, std::forward_iterator_tag{});
  bidirectional_iterator_tests(iter, refIter, refEnd);
} // iterator_test_impl<non-const>(bidirectional iterator)

template<bool IsConst, typename Iter , typename RefIter >

std::enable_if_t<IsConst> iterator_test_impl	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd,
		std::random_access_iterator_tag
	)

Definition at line 522 of file RangeForWrapper_test.cc.

{
  iterator_test_impl<IsConst>(iter, refIter, refEnd, std::bidirectional_iterator_tag{});
  const_bidirectional_iterator_tests(iter, refIter, refEnd);
} // iterator_test_impl<const>(bidirectional iterator)

template<bool IsConst, typename Iter , typename RefIter >

std::enable_if_t<!IsConst> iterator_test_impl	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd,
		std::random_access_iterator_tag	tag
	)

Definition at line 531 of file RangeForWrapper_test.cc.

{
  iterator_test_impl<IsConst>(iter, refIter, refEnd, std::bidirectional_iterator_tag{});
  random_access_iterator_tests(iter, refIter, refEnd);
} // iterator_test_impl<non-const>(random access iterator)

template<typename Iter , typename RefIter >

void iterator_tests	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd
	)

Definition at line 182 of file RangeForWrapper_test.cc.

{
  // these asserts do not completely test the concepts;
  // for example, the copy-constructable concept requires that the value of
  // the copy-constructed object and the one it was constructed from are
  // "equivalent", while std::is_copy_constructable only guarantees that
  // copy construction can happen, not testing the equivalence.
  static_assert
    (std::is_move_constructible<Iter>(), "Iterator concept violation");
  static_assert
    (std::is_copy_constructible<Iter>(), "Iterator concept violation");
  static_assert
    (std::is_copy_assignable<Iter>(), "Iterator concept violation");
  static_assert
    (std::is_destructible<Iter>(), "Iterator concept violation");
  // C++17
//  static_assert
//    (std::is_swappable<Iter>(), "Iterator concept violation");

  const bool isEnd = refIter == refEnd;
  const bool isSingular = (iter == Iter());
  const bool isDereferenciable = !isEnd && !isSingular;
  const bool isLast = (std::next(refIter) == refEnd);

  Iter ia = iter;
  BOOST_TEST(bool(ia == iter));

  if (isDereferenciable) {
    //BOOST_TEST(*iter == *refIter);
    BOOST_TEST((*iter == *refIter));
  }
  if (!isLast && !isEnd && !isSingular) {
    //BOOST_TEST(*++iter == *++refIter);
    BOOST_TEST((*++iter == *++refIter));
  }

} // iterator_tests()

template<typename ValueL , typename ValueR >

bool operator!=	(	base_iterator< ValueL > const &	a,
		base_iterator< ValueR > const &	b
	)

Definition at line 59 of file RangeForWrapper_test.cc.

  { return a.ptr != b.ptr; }

template<typename Iter , typename RefIter >

void output_iterator_tests	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd
	)

Definition at line 308 of file RangeForWrapper_test.cc.

{
  const bool isEnd = refIter == refEnd;

  const_output_iterator_tests(iter, refIter, refEnd);

  if (!isEnd) {
    auto value = *iter;

    auto newValue = std::numeric_limits<typename Iter::value_type>::max();

    *iter = newValue;

    // we couldn't check the result since an output operator is not expected
    // to return anything useful with *iter; but since we have already used it
    // to store the old value...
    BOOST_TEST((*iter == newValue));

    *iter = value;
    BOOST_TEST((*iter == value));

    auto ia = iter, ib = iter;

    *ia++ = newValue;
    ++ib;
    BOOST_TEST((*iter == newValue));
    BOOST_TEST(ia == ib);

    *iter = value;
    BOOST_TEST((*iter == value));
  }

} // output_iterator_tests()

template<typename Iter , typename RefIter >

void random_access_iterator_tests	(	Iter	iter,
		RefIter	refIter,
		RefIter	refEnd
	)

Definition at line 437 of file RangeForWrapper_test.cc.

{
  const_random_access_iterator_tests(iter, refIter, refEnd);
} // random_access_iterator_tests()

template<bool IsConst>

void RangeForWrapperIteratorStandardsTest

(

)

Definition at line 554 of file RangeForWrapper_test.cc.

                                            {

  using base_reference_container_t = std::vector<int>;
  using reference_container_t = std::conditional_t
    <IsConst, base_reference_container_t const, base_reference_container_t>;
  reference_container_t vdata = { 2, 3, 4 };
  using basic_container_t = Data;

  static_assert(std::is_same<basic_container_t::begin_iterator::reference, int&>());
  static_assert(std::is_same<typename std::iterator_traits<basic_container_t::begin_iterator>::reference, int&>());

  static_assert(std::is_same<basic_container_t::begin_const_iterator::reference, std::add_const_t<int>&>());
  static_assert(std::is_same<typename std::iterator_traits<basic_container_t::begin_const_iterator>::reference, std::add_const_t<int>&>());

  using container_t
    = std::conditional_t<IsConst, basic_container_t const, basic_container_t>;
  //
  // non-const iterator interface (iterators may still be constant)
  //
  container_t data = { 2, 3, 4 };
  auto range = data | util::range_for;
  using std::begin;
  using std::end;
  auto rbegin = begin(range);
  auto rend = end(range);

  auto vbegin = vdata.begin();
  auto vend = vdata.end();

  BOOST_TEST((unsigned)std::distance(rbegin, rend) == vdata.size());

  iterator_test(rbegin, vbegin, vend);
  iterator_test(rend, vend, vend);


  //
  // const iterator interface
  //
  using std::cbegin;
  using std::cend;
  auto rcbegin = cbegin(range);
  auto rcend = cend(range);

  auto vcbegin = vdata.cbegin();
  auto vcend = vdata.cend();

  BOOST_TEST((unsigned)std::distance(rcbegin, rcend) == vdata.size());

  iterator_test(rcbegin, vcbegin, vcend);
  iterator_test(rcend, vcend, vcend);

  //
  // extra access (partial support for random access)
  //
  BOOST_TEST(range.size() == data.size());
  BOOST_TEST(range.empty() == data.empty());
  for (std::size_t i = 0; i < data.size(); ++i) {
    BOOST_TEST(range[i] == data[i]);
  }

} // RangeForWrapperIteratorStandardsTest()

template<typename DataColl >

void test	(	DataColl &	data,
		int	expected_total
	)

Definition at line 127 of file RangeForWrapper_test.cc.

                                              {
  static_assert(
    !std::is_lvalue_reference
      <decltype(copy(data) | util::range_for)>::value,
    "util::range_for on a rvalue should return a rvalue"
    );

  //
  // from a lvalue
  //
  int total = 0;
  for (int d: data | util::range_for) total += d;

  BOOST_TEST(total == expected_total);

  //
  // from a rvalue (temporary)
  //
  total = 0;
  for (int d: copy(data) | util::range_for) total += d;

  BOOST_TEST(total == expected_total);

  //
  // from a temporary, which is changed
  //
  total = 0;
  for (int& d: copy(data) | util::range_for) total += (d *= 3);

  BOOST_TEST(total == 3 * expected_total);

  // original value is still unchanged
  total = 0;
  for (int d: data | util::range_for) total += d;

  BOOST_TEST(total == expected_total);

  //
  // from a lvalue, which is changed
  //
  for (int& d: data | util::range_for) d *= 3;

  total = 0;
  for (int d: data | util::range_for) total += d;

  BOOST_TEST(total == 3 * expected_total);

} // test()