FilteredIterator_UnitTests.cpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//                    Teuchos: Common Tools Package
//
// Copyright 2004 NTESS and the Teuchos contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER

#include "Teuchos_FilteredIterator.hpp"
#include "Teuchos_Array.hpp"
#include "Teuchos_TypeNameTraits.hpp"
#include "Teuchos_UnitTestHarness.hpp"


namespace {


template<typename T>
class SelectAll {
public:
  bool operator()(const T& x) const
    { return true; }
};


template<typename IntegralType>
class SelectEven {
public:
  bool operator()(const IntegralType& x) const
    { return ( (x % 2) == 0 ); }
};


template<typename IntegralType>
class SelectOdd {
public:
  bool operator()(const IntegralType& x) const
    { return ( (x % 2) != 0 ); }
};


} // namespace


namespace Teuchos {


TEUCHOS_UNIT_TEST( FilteredIterator, default_construct )
{
  FilteredIterator<int*, SelectAll<int> > itr;
  // There is just nothing that we can check for an uninitialized iterator!
}


TEUCHOS_UNIT_TEST( FilteredIterator, construct )
{
  typedef Array<int>::iterator itr_t;
  Array<int> a;
  a.push_back(1);
  FilteredIterator<itr_t,SelectAll<int> > itr(a.begin(), a.begin(), a.end());
  TEST_ITER_EQUALITY(itr.current(), a.begin());
  TEST_ITER_EQUALITY(itr.begin(), a.begin());
  TEST_ITER_EQUALITY(itr.end(), a.end());
  FilteredIterator<itr_t,SelectAll<int> > itr_end(a.end(), a.begin(), a.end());
  TEST_ITER_EQUALITY(itr_end.current(), a.end());
  TEST_ITER_EQUALITY(itr_end.begin(), a.begin());
  TEST_ITER_EQUALITY(itr_end.end(), a.end());
}


TEUCHOS_UNIT_TEST( FilteredIterator, deref )
{
  typedef Array<int>::iterator itr_t;
  Array<int> a;
  a.push_back(2);
  FilteredIterator<itr_t,SelectAll<int> > itr(a.begin(), a.begin(), a.end());
  TEST_EQUALITY_CONST(*itr, 2);
}


TEUCHOS_UNIT_TEST( FilteredIterator, member_access )
{
  typedef std::pair<int,int> value_t;
  typedef Array<value_t>::iterator itr_t;
  Array<value_t> a;
  a.push_back(std::make_pair(2, 4));
  FilteredIterator<itr_t,SelectAll<value_t> > itr(a.begin(), a.begin(), a.end());
  TEST_EQUALITY_CONST(itr->first, 2);
  TEST_EQUALITY_CONST(itr->second, 4);
}


TEUCHOS_UNIT_TEST( FilteredIterator, copy_construct_same )
{
  typedef Array<int>::iterator itr_t;
  Array<int> a;
  a.push_back(1);
  FilteredIterator<itr_t,SelectAll<int> > itr1(a.begin(), a.begin(), a.end());
  FilteredIterator<itr_t,SelectAll<int> > itr2(itr1);
  TEST_ITER_EQUALITY(itr2.current(), a.begin());
  TEST_ITER_EQUALITY(itr2.begin(), a.begin());
  TEST_ITER_EQUALITY(itr2.end(), a.end());
  TEST_EQUALITY(*itr1, *itr2);
}


TEUCHOS_UNIT_TEST( FilteredIterator, copy_construct_different )
{
  typedef Array<int>::iterator itr_t;
  typedef Array<int>::const_iterator citr_t;
  Array<int> a;
  a.push_back(1);
  FilteredIterator<itr_t,SelectAll<int> > itr1(a.begin(), a.begin(), a.end());
  FilteredIterator<citr_t,SelectAll<int> > itr2(itr1);
  TEST_ITER_EQUALITY(itr2.current(), a.begin());
  TEST_ITER_EQUALITY(itr2.begin(), a.begin());
  TEST_ITER_EQUALITY(itr2.end(), a.end());
  TEST_EQUALITY(*itr1, *itr2);
}


TEUCHOS_UNIT_TEST( FilteredIterator, assign_same )
{
  typedef Array<int>::iterator itr_t;
  Array<int> a;
  a.push_back(1);
  FilteredIterator<itr_t,SelectAll<int> > itr1(a.begin(), a.begin(), a.end());
  FilteredIterator<itr_t,SelectAll<int> > itr2;
  itr2 = itr1;
  TEST_ITER_EQUALITY(itr2.current(), a.begin());
  TEST_ITER_EQUALITY(itr2.begin(), a.begin());
  TEST_ITER_EQUALITY(itr2.end(), a.end());
  TEST_EQUALITY(*itr1, *itr2);
}


TEUCHOS_UNIT_TEST( FilteredIterator, assign_different )
{
  typedef Array<int>::iterator itr_t;
  typedef Array<int>::const_iterator citr_t;
  Array<int> a;
  a.push_back(1);
  FilteredIterator<itr_t,SelectAll<int> > itr1(a.begin(), a.begin(), a.end());
  FilteredIterator<citr_t,SelectAll<int> > itr2;
  itr2 = itr1;
  TEST_ITER_EQUALITY(itr2.current(), a.begin());
  TEST_ITER_EQUALITY(itr2.begin(), a.begin());
  TEST_ITER_EQUALITY(itr2.end(), a.end());
  TEST_EQUALITY(*itr1, *itr2);
}


TEUCHOS_UNIT_TEST( FilteredIterator, equality_operators_same )
{
  typedef Array<int>::iterator itr_t;
  Array<int> a;
  a.push_back(1);
  FilteredIterator<itr_t,SelectAll<int> > itr1(a.begin(), a.begin(), a.end());
  FilteredIterator<itr_t,SelectAll<int> > itr2(itr1);
  TEST_EQUALITY_CONST(itr2 == itr1, true);
  TEST_EQUALITY_CONST(itr2 != itr1, false);
}


TEUCHOS_UNIT_TEST( FilteredIterator, equality_operators_different )
{
  typedef Array<int>::iterator itr_t;
  Array<int> a;
  a.push_back(1);
  FilteredIterator<itr_t,SelectAll<int> > itr1(a.begin(), a.begin(), a.end());
  FilteredIterator<itr_t,SelectAll<int> > itr2(a.end(), a.begin(), a.end());
  TEST_EQUALITY_CONST(itr2 == itr1, false);
  TEST_EQUALITY_CONST(itr2 != itr1, true);
}


TEUCHOS_UNIT_TEST( FilteredIterator, pre_iterate_forward_no_filtering )
{
  typedef Array<int>::const_iterator citr_t;
  Array<int> a = tuple<int>(1, 2, 3);
  FilteredIterator<citr_t,SelectAll<int> > itr(a.begin(), a.begin(), a.end());
  FilteredIterator<citr_t,SelectAll<int> > itr_end(a.end(), a.begin(), a.end());
  TEST_ITER_INEQUALITY(itr, itr_end);
  TEST_EQUALITY_CONST(*itr, 1);
  ECHO(++itr);
  TEST_EQUALITY_CONST(*itr, 2);
  ECHO(++itr);
  TEST_EQUALITY_CONST(*itr, 3);
  ECHO(++itr);
  TEST_ITER_EQUALITY(itr, itr_end);
}


TEUCHOS_UNIT_TEST( FilteredIterator, post_iterate_forward_no_filtering )
{
  typedef Array<int>::const_iterator citr_t;
  Array<int> a = tuple<int>(1, 2, 3);
  FilteredIterator<citr_t,SelectAll<int> > itr(a.begin(), a.begin(), a.end());
  FilteredIterator<citr_t,SelectAll<int> > itr_end(a.end(), a.begin(), a.end());
  TEST_ITER_INEQUALITY(itr, itr_end);
  ECHO(const int v0 = *itr++);
  TEST_EQUALITY_CONST(v0, 1);
  ECHO(const int v1 = *itr++);
  TEST_EQUALITY_CONST(v1, 2);
  ECHO(const int v2 = *itr++);
  TEST_EQUALITY_CONST(v2, 3);
  TEST_ITER_EQUALITY(itr, itr_end);
}


TEUCHOS_UNIT_TEST( FilteredIterator, pre_iterate_backward_no_filtering )
{
  typedef Array<int>::const_iterator citr_t;
  Array<int> a = tuple<int>(1, 2, 3);
  FilteredIterator<citr_t,SelectAll<int> > itr(a.end(), a.begin(), a.end());
  FilteredIterator<citr_t,SelectAll<int> > itr_begin(a.begin(), a.begin(), a.end());
  ECHO(--itr);
  TEST_EQUALITY_CONST(*itr, 3);
  ECHO(--itr);
  TEST_EQUALITY_CONST(*itr, 2);
  ECHO(--itr);
  TEST_EQUALITY_CONST(*itr, 1);
  TEST_ITER_EQUALITY(itr, itr_begin);
}


TEUCHOS_UNIT_TEST( FilteredIterator, post_iterate_backward_no_filtering )
{
  typedef Array<int>::const_iterator citr_t;
  Array<int> a = tuple<int>(1, 2, 3);
  FilteredIterator<citr_t,SelectAll<int> > itr(a.end(), a.begin(), a.end());
  FilteredIterator<citr_t,SelectAll<int> > itr_begin(a.begin(), a.begin(), a.end());
  ECHO(--itr);
  ECHO(const int v0 = *itr--);
  TEST_EQUALITY_CONST(v0, 3);
  ECHO(const int v1 = *itr--);
  TEST_EQUALITY_CONST(v1, 2);
  ECHO(const int v2 = *itr);
  TEST_EQUALITY_CONST(v2, 1);
  TEST_ITER_EQUALITY(itr, itr_begin);
}


TEUCHOS_UNIT_TEST( FilteredIterator, pre_iterate_forward_filter_even )
{
  typedef Array<int>::const_iterator citr_t;
  Array<int> a = tuple<int>(1, 2, 3, 4);
  FilteredIterator<citr_t,SelectEven<int> > itr(a.begin(), a.begin(), a.end());
  FilteredIterator<citr_t,SelectEven<int> > itr_end(a.end(), a.begin(), a.end());
  TEST_ITER_INEQUALITY(itr, itr_end);
  TEST_EQUALITY_CONST(*itr, 2);
  ECHO(++itr);
  TEST_EQUALITY_CONST(*itr, 4);
  ECHO(++itr);
  TEST_ITER_EQUALITY(itr, itr_end);
}


TEUCHOS_UNIT_TEST( FilteredIterator, pre_iterate_forward_filter_odd )
{
  typedef Array<int>::const_iterator citr_t;
  Array<int> a = tuple<int>(1, 2, 3, 4);
  FilteredIterator<citr_t,SelectOdd<int> > itr(a.begin(), a.begin(), a.end());
  FilteredIterator<citr_t,SelectOdd<int> > itr_end(a.end(), a.begin(), a.end());
  TEST_ITER_INEQUALITY(itr, itr_end);
  TEST_EQUALITY_CONST(*itr, 1);
  ECHO(++itr);
  TEST_EQUALITY_CONST(*itr, 3);
  ECHO(++itr);
  TEST_ITER_EQUALITY(itr, itr_end);
}


TEUCHOS_UNIT_TEST( FilteredIterator, post_iterate_forward_filter_even )
{
  typedef Array<int>::const_iterator citr_t;
  Array<int> a = tuple<int>(1, 2, 3, 4);
  FilteredIterator<citr_t,SelectEven<int> > itr(a.begin(), a.begin(), a.end());
  FilteredIterator<citr_t,SelectEven<int> > itr_end(a.end(), a.begin(), a.end());
  TEST_ITER_INEQUALITY(itr, itr_end);
  ECHO(const int v0 = *itr++);
  TEST_EQUALITY_CONST(v0, 2);
  ECHO(const int v1 = *itr++);
  TEST_EQUALITY_CONST(v1, 4);
  TEST_ITER_EQUALITY(itr, itr_end);
}


TEUCHOS_UNIT_TEST( FilteredIterator, post_iterate_forward_filter_odd )
{
  typedef Array<int>::const_iterator citr_t;
  Array<int> a = tuple<int>(1, 2, 3, 4);
  FilteredIterator<citr_t,SelectOdd<int> > itr(a.begin(), a.begin(), a.end());
  FilteredIterator<citr_t,SelectOdd<int> > itr_end(a.end(), a.begin(), a.end());
  TEST_ITER_INEQUALITY(itr, itr_end);
  ECHO(const int v0 = *itr++);
  TEST_EQUALITY_CONST(v0, 1);
  ECHO(const int v1 = *itr++);
  TEST_EQUALITY_CONST(v1, 3);
  TEST_ITER_EQUALITY(itr, itr_end);
}


TEUCHOS_UNIT_TEST( FilteredIterator, pre_iterate_backward_filter_even )
{
  typedef Array<int>::const_iterator citr_t;
  Array<int> a = tuple<int>(1, 2, 3, 4);
  FilteredIterator<citr_t,SelectEven<int> > itr(a.end(), a.begin(), a.end());
  FilteredIterator<citr_t,SelectEven<int> > itr_begin(a.begin(), a.begin(), a.end());
  ECHO(--itr);
  TEST_EQUALITY_CONST(*itr, 4);
  ECHO(--itr);
  TEST_EQUALITY_CONST(*itr, 2);
  TEST_ITER_EQUALITY(itr, itr_begin);
}


TEUCHOS_UNIT_TEST( FilteredIterator, pre_iterate_backward_filter_odd )
{
  typedef Array<int>::const_iterator citr_t;
  Array<int> a = tuple<int>(1, 2, 3, 4);
  FilteredIterator<citr_t,SelectOdd<int> > itr(a.end(), a.begin(), a.end());
  FilteredIterator<citr_t,SelectOdd<int> > itr_begin(a.begin(), a.begin(), a.end());
  ECHO(--itr);
  TEST_EQUALITY_CONST(*itr, 3);
  ECHO(--itr);
  TEST_EQUALITY_CONST(*itr, 1);
  TEST_ITER_EQUALITY(itr, itr_begin);
}


TEUCHOS_UNIT_TEST( FilteredIterator, post_iterate_backward_filter_even )
{
  typedef Array<int>::const_iterator citr_t;
  Array<int> a = tuple<int>(1, 2, 3, 4);
  FilteredIterator<citr_t,SelectEven<int> > itr(a.end(), a.begin(), a.end());
  FilteredIterator<citr_t,SelectEven<int> > itr_begin(a.begin(), a.begin(), a.end());
  ECHO(--itr);
  ECHO(const int v0 = *itr--);
  TEST_EQUALITY_CONST(v0, 4);
  ECHO(const int v1 = *itr);
  TEST_EQUALITY_CONST(v1, 2);
  TEST_ITER_EQUALITY(itr, itr_begin);
}


TEUCHOS_UNIT_TEST( FilteredIterator, post_iterate_backward_filter_odd )
{
  typedef Array<int>::const_iterator citr_t;
  Array<int> a = tuple<int>(1, 2, 3, 4);
  FilteredIterator<citr_t,SelectOdd<int> > itr(a.end(), a.begin(), a.end());
  FilteredIterator<citr_t,SelectOdd<int> > itr_begin(a.begin(), a.begin(), a.end());
  ECHO(--itr);
  ECHO(const int v0 = *itr--);
  TEST_EQUALITY_CONST(v0, 3);
  ECHO(const int v1 = *itr);
  TEST_EQUALITY_CONST(v1, 1);
  TEST_ITER_EQUALITY(itr, itr_begin);
}


#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK


TEUCHOS_UNIT_TEST( FilteredIterator, iterate_forward_past_end_throw )
{
  // Need to use an unchecked iterator to make sure class thows
  int a_raw = 1;
  FilteredIterator<int*,SelectAll<int> > itr_end((&a_raw)+1, &a_raw, (&a_raw)+1);
  FilteredIterator<int*,SelectAll<int> > itr = itr_end;
  TEST_THROW(++itr, RangeError);
  TEST_ITER_EQUALITY(itr, itr_end);
  TEST_THROW(itr++, RangeError);
  TEST_ITER_EQUALITY(itr, itr_end);
}


TEUCHOS_UNIT_TEST( FilteredIterator, iterate_backward_past_begin_throw )
{
  // Need to use an unchecked iterator to make sure class thows
  int a_raw = 1;
  FilteredIterator<int*,SelectAll<int> > itr_begin(&a_raw, &a_raw, (&a_raw)+1);
  FilteredIterator<int*,SelectAll<int> > itr = itr_begin;
  TEST_THROW(--itr, RangeError);
  TEST_ITER_EQUALITY(itr, itr_begin);
  TEST_THROW(itr--, RangeError);
  TEST_ITER_EQUALITY(itr, itr_begin);
}


#endif // HAVE_TEUCHOS_ARRAY_BOUNDSCHECK


} // namespace Teuchos