260 lines
8.3 KiB
C++
260 lines
8.3 KiB
C++
// Boost.Geometry (aka GGL, Generic Geometry Library)
|
|
// Unit Test
|
|
|
|
// Copyright (c) 2014, Oracle and/or its affiliates.
|
|
|
|
// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
|
|
|
|
// Licensed under the Boost Software License version 1.0.
|
|
// http://www.boost.org/users/license.html
|
|
|
|
#ifndef BOOST_TEST_MODULE
|
|
#define BOOST_TEST_MODULE test_concatenate_iterator
|
|
#endif
|
|
|
|
#include <boost/test/included/unit_test.hpp>
|
|
|
|
#include <cstddef>
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <algorithm>
|
|
#include <iterator>
|
|
|
|
#include <vector>
|
|
#include <list>
|
|
|
|
#include <boost/assign/std/vector.hpp>
|
|
#include <boost/assign/std/list.hpp>
|
|
|
|
#include <boost/core/ignore_unused.hpp>
|
|
|
|
#include "test_iterator_common.hpp"
|
|
|
|
#include <boost/geometry/iterators/concatenate_iterator.hpp>
|
|
|
|
using namespace boost::assign;
|
|
|
|
|
|
struct test_concatenate_iterator
|
|
{
|
|
template
|
|
<
|
|
typename ConcatenateIterator,
|
|
typename ConstConcatenateIterator,
|
|
typename Container
|
|
>
|
|
static inline
|
|
void test_using_max_element(ConcatenateIterator first,
|
|
ConcatenateIterator beyond,
|
|
ConstConcatenateIterator const_first,
|
|
ConstConcatenateIterator const_beyond,
|
|
Container const& c,
|
|
std::size_t other_size,
|
|
bool second_container)
|
|
{
|
|
typedef typename std::iterator_traits
|
|
<
|
|
ConcatenateIterator
|
|
>::value_type value_type;
|
|
|
|
if ( c.size() == 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
ConcatenateIterator c_first = first;
|
|
if ( second_container )
|
|
{
|
|
std::size_t counter(0);
|
|
while ( counter != other_size )
|
|
{
|
|
++counter;
|
|
c_first++;
|
|
}
|
|
}
|
|
|
|
ConcatenateIterator it_max = std::max_element(first, beyond);
|
|
ConstConcatenateIterator const_it_max =
|
|
std::max_element(const_first, const_beyond);
|
|
|
|
BOOST_CHECK( it_max == const_it_max );
|
|
BOOST_CHECK( *it_max == *const_it_max );
|
|
|
|
value_type old_value = *c_first;
|
|
value_type new_value = *it_max + 1;
|
|
|
|
*c_first = *it_max + 1;
|
|
BOOST_CHECK( *c.begin() == new_value );
|
|
|
|
#ifdef BOOST_GEOMETRY_TEST_DEBUG
|
|
std::cout << std::endl;
|
|
std::cout << "modified element of ";
|
|
std::cout << (second_container ? "2nd" : "1st");
|
|
std::cout << " container:" << std::endl;
|
|
print_container(std::cout, c.begin(), c.end(),
|
|
(second_container ? "second :" : "first :"))
|
|
<< std::endl;
|
|
print_container(std::cout, first, beyond, "combined:") << std::endl;
|
|
#endif
|
|
|
|
*c_first = old_value;
|
|
BOOST_CHECK( *c.begin() == old_value );
|
|
}
|
|
|
|
|
|
template <typename Container1, typename Container2>
|
|
static inline void apply(Container1& c1, Container2& c2,
|
|
std::string const& case_id,
|
|
std::string const& containers_id)
|
|
{
|
|
boost::ignore_unused(case_id, containers_id);
|
|
|
|
#ifdef BOOST_GEOMETRY_TEST_DEBUG
|
|
std::stringstream sstream;
|
|
sstream << case_id << " [" << containers_id << "]";
|
|
|
|
std::cout << "case id: " << sstream.str() << std::endl;
|
|
#endif
|
|
typedef typename Container1::const_iterator const_iterator1;
|
|
typedef typename Container2::const_iterator const_iterator2;
|
|
typedef typename Container1::iterator iterator1;
|
|
typedef typename Container2::iterator iterator2;
|
|
|
|
typedef boost::geometry::concatenate_iterator
|
|
<
|
|
const_iterator1, const_iterator2,
|
|
typename Container1::value_type const
|
|
> const_concat_iterator;
|
|
|
|
typedef boost::geometry::concatenate_iterator
|
|
<
|
|
iterator1, iterator2, typename Container1::value_type
|
|
> concat_iterator;
|
|
|
|
typedef typename std::iterator_traits
|
|
<
|
|
concat_iterator
|
|
>::value_type value_type;
|
|
|
|
// test constructors/assignment operators
|
|
concat_iterator begin(c1.begin(), c1.end(), c2.begin(), c2.begin());
|
|
concat_iterator end(c1.end(), c2.begin(), c2.end());
|
|
const_concat_iterator const_begin(begin);
|
|
const_concat_iterator const_end(end);
|
|
const_begin = begin;
|
|
const_end = end;
|
|
|
|
concat_iterator begin2(c1.end(), c1.end(), c2.begin(), c2.begin());
|
|
const_concat_iterator const_begin2(c1.end(), c1.end(),
|
|
c2.begin(), c2.begin());
|
|
|
|
BOOST_CHECK( c1.empty() || *begin == *c1.begin() );
|
|
BOOST_CHECK( c1.empty() || *const_begin == *c1.begin() );
|
|
|
|
BOOST_CHECK( c2.empty() || *begin2 == *c2.begin() );
|
|
BOOST_CHECK( c2.empty() || *const_begin2 == *c2.begin() );
|
|
|
|
|
|
// test copying, dereferencing and element equality
|
|
std::vector<value_type> combined;
|
|
std::copy(c1.begin(), c1.end(), std::back_inserter(combined));
|
|
std::copy(c2.begin(), c2.end(), std::back_inserter(combined));
|
|
test_equality(begin, end, combined);
|
|
|
|
combined.clear();
|
|
std::copy(begin, end, std::back_inserter(combined));
|
|
test_equality(begin, end, combined);
|
|
test_equality(const_begin, const_end, combined);
|
|
|
|
combined.clear();
|
|
std::copy(const_begin, const_end, std::back_inserter(combined));
|
|
test_equality(begin, end, combined);
|
|
test_equality(const_begin, const_end, combined);
|
|
|
|
// test sizes (and std::distance)
|
|
test_size(begin, end, combined);
|
|
test_size(const_begin, const_end, combined);
|
|
|
|
|
|
#ifdef BOOST_GEOMETRY_TEST_DEBUG
|
|
print_container(std::cout, c1.begin(), c1.end(), "first :")
|
|
<< std::endl;
|
|
print_container(std::cout, c2.begin(), c2.end(), "second :")
|
|
<< std::endl;
|
|
print_container(std::cout, begin, end, "combined:")
|
|
<< std::endl;
|
|
|
|
if ( begin != end )
|
|
{
|
|
std::cout << "min element: "
|
|
<< *std::min_element(begin, end)
|
|
<< std::endl;
|
|
std::cout << "max element: "
|
|
<< *std::max_element(const_begin, const_end)
|
|
<< std::endl;
|
|
}
|
|
#endif
|
|
|
|
// perform reversals (std::reverse)
|
|
test_using_reverse(begin, end, combined);
|
|
|
|
// test std::max_element, dereferencing and value assigment
|
|
test_using_max_element(begin, end, const_begin, const_end,
|
|
c1, c2.size(), false);
|
|
test_using_max_element(begin, end, const_begin, const_end,
|
|
c2, c1.size(), true);
|
|
|
|
// test std::count_if / std::remove_if
|
|
test_using_remove_if(begin, end, combined);
|
|
|
|
#ifdef BOOST_GEOMETRY_TEST_DEBUG
|
|
std::cout << "====================" << std::endl << std::endl;
|
|
#endif
|
|
}
|
|
};
|
|
|
|
|
|
template <typename Container1, typename Container2>
|
|
inline void test_concatenation_of_containers(Container1& c1, Container2& c2,
|
|
std::string const& containers_id)
|
|
{
|
|
#ifdef BOOST_GEOMETRY_TEST_DEBUG
|
|
std::cout << std::endl << std::endl;
|
|
std::cout << "************************************" << std::endl
|
|
<< " TESTING CONTAINERS COMBINATION: "
|
|
<< containers_id << std::endl
|
|
<< "************************************" << std::endl
|
|
<< std::endl;
|
|
#endif
|
|
|
|
c1.clear();
|
|
c2.clear();
|
|
test_concatenate_iterator::apply(c1, c2, "empty_both", containers_id);
|
|
|
|
c2 += 10,11,12,13,14,15,16,17,18,19,20;
|
|
test_concatenate_iterator::apply(c1, c2, "empty_first", containers_id);
|
|
|
|
c2.clear();
|
|
c1 += 0,1,2,3,4,5,6;
|
|
test_concatenate_iterator::apply(c1, c2, "empty_second", containers_id);
|
|
|
|
c1.clear();
|
|
c2.clear();
|
|
c1 += 0,1,2,3,4,5,6;
|
|
c2 += 10,11,12,13,14,15,16,17,18,19,20;
|
|
test_concatenate_iterator::apply(c1, c2, "non_empty", containers_id);
|
|
}
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE( test_concatenate_iterator_all )
|
|
{
|
|
std::vector<int> v, vv;
|
|
std::list<int> l, ll;
|
|
|
|
test_concatenation_of_containers(v, vv, "VV");
|
|
test_concatenation_of_containers(v, l, "VL");
|
|
test_concatenation_of_containers(l, v, "LV");
|
|
test_concatenation_of_containers(l, ll, "LL");
|
|
}
|