boostorg/range
1
0
Fork 1
mirror of https://github.com/boostorg/range.git synced 2025-07-12 12:16:38 +02:00
Code Issues Packages Projects Releases Wiki Activity

[boost][range] - Improved the tests by implementing outside of the boost namespace to better simulate real world usage.

Browse Source 
[SVN r67602]
This commit is contained in:
Neil Groves
2011-01-03 01:33:04 +00:00
parent a5d94bbe21
commit 2da424d940
11 changed files with 1177 additions and 1212 deletions
Download Patch File Download Diff File Expand all files Collapse all files

281
test/algorithm_test/find_end.cpp
View File

@ -21,173 +21,170 @@
#include <set>
#include <list>
namespace boost
namespace boost_range_test_algorithm_find_end
{
namespace
template<class Container2>
class find_end_test_policy
{
template<class Container2>
class find_end_test_policy
typedef Container2 container2_t;
public:
explicit find_end_test_policy(const Container2& cont)
: m_cont(cont)
{
typedef Container2 container2_t;
public:
explicit find_end_test_policy(const Container2& cont)
: m_cont(cont)
{
}
}
container2_t cont() { return m_cont; }
container2_t cont() { return m_cont; }
template<class Container>
BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
test_iter(Container& cont)
template<class Container>
BOOST_DEDUCED_TYPENAME boost::range_iterator<Container>::type
test_iter(Container& cont)
{
typedef BOOST_DEDUCED_TYPENAME boost::range_iterator<Container>::type iter_t;
iter_t result = boost::find_end(cont, m_cont);
BOOST_CHECK( result == boost::find_end(boost::make_iterator_range(cont), m_cont) );
BOOST_CHECK( result == boost::find_end(cont, boost::make_iterator_range(m_cont)) );
BOOST_CHECK( result == boost::find_end(boost::make_iterator_range(cont), boost::make_iterator_range(m_cont)) );
return result;
}
template<boost::range_return_value return_type>
struct test_range
{
template<class Container, class Policy>
BOOST_DEDUCED_TYPENAME boost::range_return<Container,return_type>::type
operator()(Policy& policy, Container& cont)
{
typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iter_t;
iter_t result = boost::find_end(cont, m_cont);
BOOST_CHECK( result == boost::find_end(boost::make_iterator_range(cont), m_cont) );
BOOST_CHECK( result == boost::find_end(cont, boost::make_iterator_range(m_cont)) );
BOOST_CHECK( result == boost::find_end(boost::make_iterator_range(cont), boost::make_iterator_range(m_cont)) );
typedef BOOST_DEDUCED_TYPENAME boost::range_return<Container,return_type>::type result_t;
result_t result = boost::find_end<return_type>(cont, policy.cont());
BOOST_CHECK( result == boost::find_end<return_type>(boost::make_iterator_range(cont), policy.cont()) );
BOOST_CHECK( result == boost::find_end<return_type>(cont, boost::make_iterator_range(policy.cont())) );
BOOST_CHECK( result == boost::find_end<return_type>(boost::make_iterator_range(cont),
boost::make_iterator_range(policy.cont())) );
return result;
}
template<range_return_value return_type>
struct test_range
{
template<class Container, class Policy>
BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
operator()(Policy& policy, Container& cont)
{
typedef BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type result_t;
result_t result = boost::find_end<return_type>(cont, policy.cont());
BOOST_CHECK( result == boost::find_end<return_type>(boost::make_iterator_range(cont), policy.cont()) );
BOOST_CHECK( result == boost::find_end<return_type>(cont, boost::make_iterator_range(policy.cont())) );
BOOST_CHECK( result == boost::find_end<return_type>(boost::make_iterator_range(cont),
boost::make_iterator_range(policy.cont())) );
return result;
}
};
template<class Container>
BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
reference(Container& cont)
{
return std::find_end(cont.begin(), cont.end(),
m_cont.begin(), m_cont.end());
}
private:
Container2 m_cont;
};
template<class Container2, class BinaryPredicate>
class find_end_pred_test_policy
template<class Container>
BOOST_DEDUCED_TYPENAME boost::range_iterator<Container>::type
reference(Container& cont)
{
typedef Container2 container2_t;
public:
explicit find_end_pred_test_policy(const Container2& cont)
: m_cont(cont)
return std::find_end(cont.begin(), cont.end(),
m_cont.begin(), m_cont.end());
}
private:
Container2 m_cont;
};
template<class Container2, class BinaryPredicate>
class find_end_pred_test_policy
{
typedef Container2 container2_t;
public:
explicit find_end_pred_test_policy(const Container2& cont)
: m_cont(cont)
{
}
container2_t& cont() { return m_cont; }
BinaryPredicate& pred() { return m_pred; }
template<class Container>
BOOST_DEDUCED_TYPENAME boost::range_iterator<Container>::type
test_iter(Container& cont)
{
typedef BOOST_DEDUCED_TYPENAME boost::range_iterator<Container>::type iter_t;
iter_t it = boost::find_end(cont, m_cont, m_pred);
BOOST_CHECK( it == boost::find_end(boost::make_iterator_range(cont), m_cont, m_pred) );
BOOST_CHECK( it == boost::find_end(cont, boost::make_iterator_range(m_cont), m_pred) );
BOOST_CHECK( it == boost::find_end(boost::make_iterator_range(cont), boost::make_iterator_range(m_cont), m_pred) );
return it;
}
template<boost::range_return_value return_type>
struct test_range
{
template<class Container, class Policy>
BOOST_DEDUCED_TYPENAME boost::range_return<Container,return_type>::type
operator()(Policy& policy, Container& cont)
{
typedef BOOST_DEDUCED_TYPENAME boost::range_return<Container,return_type>::type result_t;
result_t result = boost::find_end<return_type>(cont, policy.cont(), policy.pred());
BOOST_CHECK( result == boost::find_end<return_type>(boost::make_iterator_range(cont), policy.cont(), policy.pred()) );
BOOST_CHECK( result == boost::find_end<return_type>(cont, boost::make_iterator_range(policy.cont()), policy.pred()) );
BOOST_CHECK( result == boost::find_end<return_type>(boost::make_iterator_range(cont),
boost::make_iterator_range(policy.cont()), policy.pred()) );
return boost::find_end<return_type>(cont, policy.cont(), policy.pred());
}
container2_t& cont() { return m_cont; }
BinaryPredicate& pred() { return m_pred; }
template<class Container>
BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
test_iter(Container& cont)
{
typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iter_t;
iter_t it = boost::find_end(cont, m_cont, m_pred);
BOOST_CHECK( it == boost::find_end(boost::make_iterator_range(cont), m_cont, m_pred) );
BOOST_CHECK( it == boost::find_end(cont, boost::make_iterator_range(m_cont), m_pred) );
BOOST_CHECK( it == boost::find_end(boost::make_iterator_range(cont), boost::make_iterator_range(m_cont), m_pred) );
return it;
}
template<range_return_value return_type>
struct test_range
{
template<class Container, class Policy>
BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
operator()(Policy& policy, Container& cont)
{
typedef BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type result_t;
result_t result = boost::find_end<return_type>(cont, policy.cont(), policy.pred());
BOOST_CHECK( result == boost::find_end<return_type>(boost::make_iterator_range(cont), policy.cont(), policy.pred()) );
BOOST_CHECK( result == boost::find_end<return_type>(cont, boost::make_iterator_range(policy.cont()), policy.pred()) );
BOOST_CHECK( result == boost::find_end<return_type>(boost::make_iterator_range(cont),
boost::make_iterator_range(policy.cont()), policy.pred()) );
return boost::find_end<return_type>(cont, policy.cont(), policy.pred());
}
};
template<class Container>
BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
reference(Container& cont)
{
return std::find_end(cont.begin(), cont.end(),
m_cont.begin(), m_cont.end(),
m_pred);
}
private:
Container2 m_cont;
BinaryPredicate m_pred;
};
template<class Container1, class Container2>
void run_tests(Container1& cont1, Container2& cont2)
template<class Container>
BOOST_DEDUCED_TYPENAME boost::range_iterator<Container>::type
reference(Container& cont)
{
range_test::range_return_test_driver test_driver;
test_driver(cont1, find_end_test_policy<Container2>(cont2));
test_driver(cont1, find_end_pred_test_policy<Container2, std::less<int> >(cont2));
test_driver(cont2, find_end_pred_test_policy<Container2, std::greater<int> >(cont2));
return std::find_end(cont.begin(), cont.end(),
m_cont.begin(), m_cont.end(),
m_pred);
}
template<class Container1, class Container2>
void test_find_end_impl()
{
using namespace boost::assign;
private:
Container2 m_cont;
BinaryPredicate m_pred;
};
typedef BOOST_DEDUCED_TYPENAME remove_const<Container1>::type container1_t;
typedef BOOST_DEDUCED_TYPENAME remove_const<Container2>::type container2_t;
template<class Container1, class Container2>
void run_tests(Container1& cont1, Container2& cont2)
{
boost::range_test::range_return_test_driver test_driver;
test_driver(cont1, find_end_test_policy<Container2>(cont2));
test_driver(cont1, find_end_pred_test_policy<Container2, std::less<int> >(cont2));
test_driver(cont2, find_end_pred_test_policy<Container2, std::greater<int> >(cont2));
}
container1_t mcont1;
Container1& cont1 = mcont1;
container2_t mcont2;
Container2& cont2 = mcont2;
template<class Container1, class Container2>
void test_find_end_impl()
{
using namespace boost::assign;
run_tests(cont1, cont2);
typedef BOOST_DEDUCED_TYPENAME boost::remove_const<Container1>::type container1_t;
typedef BOOST_DEDUCED_TYPENAME boost::remove_const<Container2>::type container2_t;
mcont1 += 1;
run_tests(cont1, cont2);
container1_t mcont1;
Container1& cont1 = mcont1;
container2_t mcont2;
Container2& cont2 = mcont2;
mcont2 += 1;
run_tests(cont1, cont2);
run_tests(cont1, cont2);
mcont1 += 2,3,4,5,6,7,8,9;
mcont2 += 2,3,4;
run_tests(cont1, cont2);
mcont1 += 1;
run_tests(cont1, cont2);
mcont2.clear();
mcont2 += 7,8,9;
run_tests(cont1, cont2);
}
mcont2 += 1;
run_tests(cont1, cont2);
void test_find_end()
{
test_find_end_impl< std::vector<int>, std::vector<int> >();
test_find_end_impl< std::list<int>, std::list<int> >();
test_find_end_impl< std::deque<int>, std::deque<int> >();
test_find_end_impl< const std::vector<int>, const std::vector<int> >();
test_find_end_impl< const std::list<int>, const std::list<int> >();
test_find_end_impl< const std::deque<int>, const std::deque<int> >();
test_find_end_impl< const std::vector<int>, const std::list<int> >();
test_find_end_impl< const std::list<int>, const std::vector<int> >();
test_find_end_impl< const std::vector<int>, std::list<int> >();
test_find_end_impl< const std::list<int>, std::vector<int> >();
test_find_end_impl< std::vector<int>, std::list<int> >();
test_find_end_impl< std::list<int>, std::vector<int> >();
}
mcont1 += 2,3,4,5,6,7,8,9;
mcont2 += 2,3,4;
run_tests(cont1, cont2);
mcont2.clear();
mcont2 += 7,8,9;
run_tests(cont1, cont2);
}
void test_find_end()
{
test_find_end_impl< std::vector<int>, std::vector<int> >();
test_find_end_impl< std::list<int>, std::list<int> >();
test_find_end_impl< std::deque<int>, std::deque<int> >();
test_find_end_impl< const std::vector<int>, const std::vector<int> >();
test_find_end_impl< const std::list<int>, const std::list<int> >();
test_find_end_impl< const std::deque<int>, const std::deque<int> >();
test_find_end_impl< const std::vector<int>, const std::list<int> >();
test_find_end_impl< const std::list<int>, const std::vector<int> >();
test_find_end_impl< const std::vector<int>, std::list<int> >();
test_find_end_impl< const std::list<int>, std::vector<int> >();
test_find_end_impl< std::vector<int>, std::list<int> >();
test_find_end_impl< std::list<int>, std::vector<int> >();
}
}
@ -197,7 +194,7 @@ init_unit_test_suite(int argc, char* argv[])
boost::unit_test::test_suite* test
= BOOST_TEST_SUITE( "RangeTestSuite.algorithm.find_end" );
test->add( BOOST_TEST_CASE( &boost::test_find_end ) );
test->add( BOOST_TEST_CASE( &boost_range_test_algorithm_find_end::test_find_end ) );
return test;
}