feedc0de/boost_range
1
0
Fork 0
forked from boostorg/range
Code Pull Requests Activity

Boost.Range improvements for compiler compatibility, especially C++0x compilers.

Browse Source 
[SVN r61026]
This commit is contained in:
Neil Groves
2010-04-03 20:10:16 +00:00
parent 39d77206e1
commit f8f29ae7d3
5 changed files with 157 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
include/boost/range/concepts.hpp
View File

@ -74,10 +74,10 @@ namespace boost {
// Ultimately modeling the range concepts using composition
// with the Boost.Iterator concepts would render the library
// incompatible with many common Boost.Lambda expressions.
template<typename Iterator>
template<class Iterator>
struct IncrementableIteratorConcept : CopyConstructible<Iterator>
{
typedef typename iterator_traversal<Iterator>::type traversal_category;
typedef BOOST_DEDUCED_TYPENAME iterator_traversal<Iterator>::type traversal_category;
BOOST_CONCEPT_ASSERT((
Convertible<
@ -94,42 +94,42 @@ namespace boost {
Iterator i;
};
template<typename Iterator>
template<class Iterator>
struct SinglePassIteratorConcept
: IncrementableIteratorConcept<Iterator>
, EqualityComparable<Iterator>
{
BOOST_CONCEPT_ASSERT((
Convertible<
typename SinglePassIteratorConcept::traversal_category,
BOOST_DEDUCED_TYPENAME SinglePassIteratorConcept::traversal_category,
single_pass_traversal_tag
>));
};
template<typename Iterator>
template<class Iterator>
struct ForwardIteratorConcept
: SinglePassIteratorConcept<Iterator>
, DefaultConstructible<Iterator>
{
typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::difference_type difference_type;
BOOST_MPL_ASSERT((is_integral<difference_type>));
BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
BOOST_CONCEPT_ASSERT((
Convertible<
typename ForwardIteratorConcept::traversal_category,
BOOST_DEDUCED_TYPENAME ForwardIteratorConcept::traversal_category,
forward_traversal_tag
>));
};
template<typename Iterator>
template<class Iterator>
struct BidirectionalIteratorConcept
: ForwardIteratorConcept<Iterator>
{
BOOST_CONCEPT_ASSERT((
Convertible<
typename BidirectionalIteratorConcept::traversal_category,
BOOST_DEDUCED_TYPENAME BidirectionalIteratorConcept::traversal_category,
bidirectional_traversal_tag
>));
@ -142,13 +142,13 @@ namespace boost {
Iterator i;
};
template<typename Iterator>
template<class Iterator>
struct RandomAccessIteratorConcept
: BidirectionalIteratorConcept<Iterator>
{
BOOST_CONCEPT_ASSERT((
Convertible<
typename RandomAccessIteratorConcept::traversal_category,
BOOST_DEDUCED_TYPENAME RandomAccessIteratorConcept::traversal_category,
random_access_traversal_tag
>));
@ -162,7 +162,7 @@ namespace boost {
n = i - j;
}
private:
typename RandomAccessIteratorConcept::difference_type n;
BOOST_DEDUCED_TYPENAME RandomAccessIteratorConcept::difference_type n;
Iterator i;
Iterator j;
};
@ -170,11 +170,11 @@ namespace boost {
} // namespace range_detail
//! Check if a type T models the SinglePassRange range concept.
template<typename T>
template<class T>
struct SinglePassRangeConcept
{
typedef typename range_iterator<T const>::type const_iterator;
typedef typename range_iterator<T>::type iterator;
typedef BOOST_DEDUCED_TYPENAME range_iterator<T const>::type const_iterator;
typedef BOOST_DEDUCED_TYPENAME range_iterator<T>::type iterator;
BOOST_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<iterator>));
BOOST_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<const_iterator>));
@ -211,17 +211,17 @@ namespace boost {
};
//! Check if a type T models the ForwardRange range concept.
template<typename T>
template<class T>
struct ForwardRangeConcept : SinglePassRangeConcept<T>
{
BOOST_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<typename ForwardRangeConcept::iterator>));
BOOST_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<typename ForwardRangeConcept::const_iterator>));
BOOST_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<BOOST_DEDUCED_TYPENAME ForwardRangeConcept::iterator>));
BOOST_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<BOOST_DEDUCED_TYPENAME ForwardRangeConcept::const_iterator>));
};
template<typename Range>
template<class Range>
struct WriteableRangeConcept
{
typedef typename range_iterator<Range>::type iterator;
typedef BOOST_DEDUCED_TYPENAME range_iterator<Range>::type iterator;
BOOST_CONCEPT_USAGE(WriteableRangeConcept)
{
@ -229,11 +229,11 @@ namespace boost {
}
private:
iterator i;
typename range_value<Range>::type v;
BOOST_DEDUCED_TYPENAME range_value<Range>::type v;
};
//! Check if a type T models the WriteableForwardRange range concept.
template<typename T>
template<class T>
struct WriteableForwardRangeConcept
: ForwardRangeConcept<T>
, WriteableRangeConcept<T>
@ -241,15 +241,15 @@ namespace boost {
};
//! Check if a type T models the BidirectionalRange range concept.
template<typename T>
template<class T>
struct BidirectionalRangeConcept : ForwardRangeConcept<T>
{
BOOST_CONCEPT_ASSERT((BidirectionalIteratorConcept<typename BidirectionalRangeConcept::iterator>));
BOOST_CONCEPT_ASSERT((BidirectionalIteratorConcept<typename BidirectionalRangeConcept::const_iterator>));
BOOST_CONCEPT_ASSERT((BidirectionalIteratorConcept<BOOST_DEDUCED_TYPENAME BidirectionalRangeConcept::iterator>));
BOOST_CONCEPT_ASSERT((BidirectionalIteratorConcept<BOOST_DEDUCED_TYPENAME BidirectionalRangeConcept::const_iterator>));
};
//! Check if a type T models the WriteableBidirectionalRange range concept.
template<typename T>
template<class T>
struct WriteableBidirectionalRangeConcept
: BidirectionalRangeConcept<T>
, WriteableRangeConcept<T>
@ -257,15 +257,15 @@ namespace boost {
};
//! Check if a type T models the RandomAccessRange range concept.
template<typename T>
template<class T>
struct RandomAccessRangeConcept : BidirectionalRangeConcept<T>
{
BOOST_CONCEPT_ASSERT((RandomAccessIteratorConcept<typename RandomAccessRangeConcept::iterator>));
BOOST_CONCEPT_ASSERT((RandomAccessIteratorConcept<typename RandomAccessRangeConcept::const_iterator>));
BOOST_CONCEPT_ASSERT((RandomAccessIteratorConcept<BOOST_DEDUCED_TYPENAME RandomAccessRangeConcept::iterator>));
BOOST_CONCEPT_ASSERT((RandomAccessIteratorConcept<BOOST_DEDUCED_TYPENAME RandomAccessRangeConcept::const_iterator>));
};
//! Check if a type T models the WriteableRandomAccessRange range concept.
template<typename T>
template<class T>
struct WriteableRandomAccessRangeConcept
: RandomAccessRangeConcept<T>
, WriteableRangeConcept<T>

69
test/iterator_pair.cpp Executable file → Normal file
View File

@ -23,8 +23,6 @@
#include <boost/test/test_tools.hpp>
#include <vector>
using namespace boost;
void check_iterator_pair()
{
typedef std::vector<int> vec_t;
@ -35,57 +33,56 @@ void check_iterator_pair()
typedef std::pair<vec_t::const_iterator,vec_t::const_iterator>
const_pair_t;
typedef const pair_t const_pair_tt;
pair_t pair = std::make_pair( begin( vec ), end( vec ) );
const_pair_t const_pair = std::make_pair( begin( vec ), end( vec ) );
pair_t pair = std::make_pair( boost::begin( vec ), boost::end( vec ) );
const_pair_t const_pair = std::make_pair( boost::begin( vec ), boost::end( vec ) );
const_pair_tt constness_pair( pair );
BOOST_STATIC_ASSERT(( is_same< range_value<pair_t>::type,
detail::iterator_traits<pair_t::first_type>::value_type>::value ));
BOOST_STATIC_ASSERT(( is_same< range_iterator<pair_t>::type, pair_t::first_type >::value ));
BOOST_STATIC_ASSERT(( is_same< range_const_iterator<pair_t>::type, pair_t::first_type >::value ));
BOOST_STATIC_ASSERT(( is_same< range_difference<pair_t>::type,
detail::iterator_traits<pair_t::first_type>::difference_type >::value ));
BOOST_STATIC_ASSERT(( is_same< range_size<pair_t>::type, std::size_t >::value ));
BOOST_STATIC_ASSERT(( is_same< range_iterator<pair_t>::type, pair_t::first_type >::value ));
BOOST_STATIC_ASSERT(( is_same< range_iterator<const_pair_t>::type, const_pair_t::first_type >::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_value<pair_t>::type,
boost::detail::iterator_traits<pair_t::first_type>::value_type>::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<pair_t>::type, pair_t::first_type >::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_const_iterator<pair_t>::type, pair_t::first_type >::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_difference<pair_t>::type,
boost::detail::iterator_traits<pair_t::first_type>::difference_type >::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_size<pair_t>::type, std::size_t >::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<pair_t>::type, pair_t::first_type >::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<const_pair_t>::type, const_pair_t::first_type >::value ));
BOOST_STATIC_ASSERT(( is_same< range_value<const_pair_tt>::type,
detail::iterator_traits<const_pair_t::first_type>::value_type>::value ));
BOOST_STATIC_ASSERT(( is_same< range_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_value<const_pair_tt>::type,
boost::detail::iterator_traits<const_pair_t::first_type>::value_type>::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
//
// This behavior is not supported with v2.
//BOOST_STATIC_ASSERT(( is_same< range_const_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
BOOST_STATIC_ASSERT(( is_same< range_difference<const_pair_tt>::type,
detail::iterator_traits<const_pair_tt::first_type>::difference_type >::value ));
BOOST_STATIC_ASSERT(( is_same< range_size<const_pair_tt>::type, std::size_t >::value ));
BOOST_STATIC_ASSERT(( is_same< range_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
BOOST_STATIC_ASSERT(( is_same< range_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_difference<const_pair_tt>::type,
boost::detail::iterator_traits<const_pair_tt::first_type>::difference_type >::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_size<const_pair_tt>::type, std::size_t >::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
BOOST_CHECK( begin( pair ) == pair.first );
BOOST_CHECK( end( pair ) == pair.second );
BOOST_CHECK( empty( pair ) == (pair.first == pair.second) );
BOOST_CHECK( size( pair ) == std::distance( pair.first, pair.second ) );
BOOST_CHECK( boost::begin( pair ) == pair.first );
BOOST_CHECK( boost::end( pair ) == pair.second );
BOOST_CHECK( boost::empty( pair ) == (pair.first == pair.second) );
BOOST_CHECK( boost::size( pair ) == std::distance( pair.first, pair.second ) );
BOOST_CHECK( begin( const_pair ) == const_pair.first );
BOOST_CHECK( end( const_pair ) == const_pair.second );
BOOST_CHECK( empty( const_pair ) == (const_pair.first == const_pair.second) );
BOOST_CHECK( size( const_pair ) == std::distance( const_pair.first, const_pair.second ) );
BOOST_CHECK( boost::begin( const_pair ) == const_pair.first );
BOOST_CHECK( boost::end( const_pair ) == const_pair.second );
BOOST_CHECK( boost::empty( const_pair ) == (const_pair.first == const_pair.second) );
BOOST_CHECK( boost::size( const_pair ) == std::distance( const_pair.first, const_pair.second ) );
BOOST_CHECK( begin( constness_pair ) == constness_pair.first );
BOOST_CHECK( end( constness_pair ) == constness_pair.second );
BOOST_CHECK( empty( constness_pair ) == (constness_pair.first == const_pair.second) );
BOOST_CHECK( size( constness_pair ) == std::distance( constness_pair.first, constness_pair.second ) );
BOOST_CHECK( boost::begin( constness_pair ) == constness_pair.first );
BOOST_CHECK( boost::end( constness_pair ) == constness_pair.second );
BOOST_CHECK( boost::empty( constness_pair ) == (constness_pair.first == const_pair.second) );
BOOST_CHECK( boost::size( constness_pair ) == std::distance( constness_pair.first, constness_pair.second ) );
}
#include <boost/test/unit_test.hpp>
using boost::unit_test::test_suite;
test_suite* init_unit_test_suite( int argc, char* argv[] )
boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
{
test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
boost::unit_test::test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
test->add( BOOST_TEST_CASE( &check_iterator_pair ) );

77
test/iterator_range.cpp Executable file → Normal file
View File

@ -25,25 +25,22 @@
#include <iostream>
#include <string>
using namespace boost;
using namespace std;
void check_reference_type();
void check_iterator_range()
{
typedef string::iterator iterator;
typedef string::const_iterator const_iterator;
typedef iterator_range<iterator> irange;
typedef iterator_range<const_iterator> cirange;
string str = "hello world";
const string cstr = "const world";
irange r = make_iterator_range( str );
r = make_iterator_range( str.begin(), str.end() );
cirange r2 = make_iterator_range( cstr );
r2 = make_iterator_range( cstr.begin(), cstr.end() );
r2 = make_iterator_range( str );
typedef std::string::iterator iterator;
typedef std::string::const_iterator const_iterator;
typedef boost::iterator_range<iterator> irange;
typedef boost::iterator_range<const_iterator> cirange;
std::string str = "hello world";
const std::string cstr = "const world";
irange r = boost::make_iterator_range( str );
r = boost::make_iterator_range( str.begin(), str.end() );
cirange r2 = boost::make_iterator_range( cstr );
r2 = boost::make_iterator_range( cstr.begin(), cstr.end() );
r2 = boost::make_iterator_range( str );
BOOST_CHECK( !r.empty() );
BOOST_CHECK( !r2.empty() );
@ -63,54 +60,52 @@ void check_iterator_range()
BOOST_CHECK_EQUAL( r.size(), size( r ) );
BOOST_CHECK_EQUAL( r2.size(), size( r2 ) );
BOOST_CHECK_EQUAL( distance( r.begin(), r.end() ),
distance( begin( r2 ), end( r2 ) ) );
cout << r << r2;
BOOST_CHECK_EQUAL( std::distance( r.begin(), r.end() ),
std::distance( begin( r2 ), end( r2 ) ) );
std::cout << r << r2;
#ifndef BOOST_NO_STD_WSTRING
wcout << make_iterator_range( wstring( L"a wide string" ) )
<< make_iterator_range( L"another wide string" );
std::wcout << boost::make_iterator_range( std::wstring( L"a wide string" ) )
<< boost::make_iterator_range( L"another wide string" );
#endif
string res = copy_range<string>( r );
BOOST_CHECK( equal( res.begin(), res.end(), r.begin() ) );
std::string res = boost::copy_range<std::string>( r );
BOOST_CHECK_EQUAL_COLLECTIONS( res.begin(), res.end(), r.begin(), r.end() );
irange rr = make_iterator_range( str );
irange rr = boost::make_iterator_range( str );
BOOST_CHECK( rr.equal( r ) );
rr = make_iterator_range( str.begin(), str.begin() + 5 );
BOOST_CHECK( rr == as_literal("hello") );
BOOST_CHECK( rr != as_literal("hell") );
BOOST_CHECK( rr < as_literal("hello dude") );
BOOST_CHECK( as_literal("hello") == rr );
BOOST_CHECK( as_literal("hell") != rr );
BOOST_CHECK( ! (as_literal("hello dude") < rr ) );
rr = boost::make_iterator_range( str.begin(), str.begin() + 5 );
BOOST_CHECK( rr == boost::as_literal("hello") );
BOOST_CHECK( rr != boost::as_literal("hell") );
BOOST_CHECK( rr < boost::as_literal("hello dude") );
BOOST_CHECK( boost::as_literal("hello") == rr );
BOOST_CHECK( boost::as_literal("hell") != rr );
BOOST_CHECK( ! (boost::as_literal("hello dude") < rr ) );
irange rrr = rr;
BOOST_CHECK( rrr == rr );
BOOST_CHECK( !( rrr != rr ) );
BOOST_CHECK( !( rrr < rr ) );
const irange cr = make_iterator_range( str );
const irange cr = boost::make_iterator_range( str );
BOOST_CHECK_EQUAL( cr.front(), 'h' );
BOOST_CHECK_EQUAL( cr.back(), 'd' );
BOOST_CHECK_EQUAL( cr[1], 'e' );
BOOST_CHECK_EQUAL( cr(1), 'e' );
rrr = make_iterator_range( str, 1, -1 );
BOOST_CHECK( rrr == as_literal("ello worl") );
rrr = make_iterator_range( rrr, -1, 1 );
rrr = boost::make_iterator_range( str, 1, -1 );
BOOST_CHECK( rrr == boost::as_literal("ello worl") );
rrr = boost::make_iterator_range( rrr, -1, 1 );
BOOST_CHECK( rrr == str );
check_reference_type();
}
using boost::unit_test::test_suite;
test_suite* init_unit_test_suite( int argc, char* argv[] )
boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
{
test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
boost::unit_test::test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
test->add( BOOST_TEST_CASE( &check_iterator_range ) );
@ -129,9 +124,9 @@ test_suite* init_unit_test_suite( int argc, char* argv[] )
template< class Container >
int test_iter_range( Container& a_cont )
{
typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type citer_type;
typedef iterator_range<citer_type> riter_type;
riter_type a_riter( make_iterator_range( a_cont ) );
typedef BOOST_DEDUCED_TYPENAME boost::range_iterator<Container>::type citer_type;
typedef boost::iterator_range<citer_type> riter_type;
riter_type a_riter( boost::make_iterator_range( a_cont ) );
a_riter.front();
a_riter.back();
int i = a_riter[0];
@ -142,7 +137,7 @@ int test_iter_range( Container& a_cont )
void check_reference_type()
{
typedef vector<int> veci_type;
typedef std::vector<int> veci_type;
veci_type a_vec;
a_vec.push_back( 999 );
test_iter_range<veci_type>(a_vec);

43
test/reversible_range.cpp Executable file → Normal file
View File

@ -27,44 +27,39 @@
#include <vector>
#include <algorithm>
using namespace boost;
using namespace std;
void check_iterator()
{
typedef vector<int> vec_t;
typedef std::vector<int> vec_t;
typedef vec_t::iterator iterator;
typedef pair<iterator,iterator> pair_t;
typedef range_reverse_iterator<pair_t>::type rev_iterator;
typedef pair<rev_iterator,rev_iterator> rev_pair_t;
typedef std::pair<iterator,iterator> pair_t;
typedef boost::range_reverse_iterator<pair_t>::type rev_iterator;
typedef std::pair<rev_iterator,rev_iterator> rev_pair_t;
vec_t vec;
pair_t p = make_pair( vec.begin(), vec.end() );
rev_pair_t rp = make_pair( rbegin( p ), rend( p ) );
pair_t p = std::make_pair( vec.begin(), vec.end() );
rev_pair_t rp = std::make_pair( boost::rbegin( p ), boost::rend( p ) );
int a[] = {1,2,3,4,5,6,7,8,9,10};
const int ca[] = {1,2,3,4,5,6,7,8,9,10,11,12};
BOOST_CHECK( rbegin( vec ) == range_reverse_iterator<vec_t>::type( vec.end() ) );
BOOST_CHECK( rend( vec ) == range_reverse_iterator<vec_t>::type( vec.begin() ) );
BOOST_CHECK( std::distance( rbegin( vec ), rend( vec ) ) == std::distance( begin( vec ), end( vec ) ) );
BOOST_CHECK( boost::rbegin( vec ) == boost::range_reverse_iterator<vec_t>::type( vec.end() ) );
BOOST_CHECK( boost::rend( vec ) == boost::range_reverse_iterator<vec_t>::type( vec.begin() ) );
BOOST_CHECK( std::distance( boost::rbegin( vec ), boost::rend( vec ) ) == std::distance( boost::begin( vec ), boost::end( vec ) ) );
BOOST_CHECK( rbegin( p ) == begin( rp ) );
BOOST_CHECK( rend( p ) == end( rp ) );
BOOST_CHECK( std::distance( rbegin( p ), rend( p ) ) == std::distance( begin( rp ), end( rp ) ) );
BOOST_CHECK( std::distance( begin( p ), end( p ) ) == std::distance( rbegin( rp ), rend( rp ) ) );
BOOST_CHECK( boost::rbegin( p ) == boost::begin( rp ) );
BOOST_CHECK( boost::rend( p ) == boost::end( rp ) );
BOOST_CHECK( std::distance( boost::rbegin( p ), boost::rend( p ) ) == std::distance( boost::begin( rp ), boost::end( rp ) ) );
BOOST_CHECK( std::distance( boost::begin( p ), boost::end( p ) ) == std::distance( boost::rbegin( rp ), boost::rend( rp ) ) );
BOOST_CHECK_EQUAL( &*begin( a ), &*( rend( a ) - 1 ) );
BOOST_CHECK_EQUAL( &*( end( a ) - 1 ), &*rbegin( a ) );
BOOST_CHECK_EQUAL( &*begin( ca ), &*( rend( ca ) - 1 ) );
BOOST_CHECK_EQUAL( &*( end( ca ) - 1 ), &*rbegin( ca ) );
BOOST_CHECK_EQUAL( &*boost::begin( a ), &*( boost::rend( a ) - 1 ) );
BOOST_CHECK_EQUAL( &*( boost::end( a ) - 1 ), &*boost::rbegin( a ) );
BOOST_CHECK_EQUAL( &*boost::begin( ca ), &*( boost::rend( ca ) - 1 ) );
BOOST_CHECK_EQUAL( &*( boost::end( ca ) - 1 ), &*boost::rbegin( ca ) );
}
using boost::unit_test::test_suite;
test_suite* init_unit_test_suite( int argc, char* argv[] )
boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
{
test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
boost::unit_test::test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
test->add( BOOST_TEST_CASE( &check_iterator ) );

43
test/std_container.cpp Executable file → Normal file
View File

@ -24,8 +24,6 @@
#include <boost/test/test_tools.hpp>
#include <vector>
using namespace boost;
void check_std_container()
{
typedef std::vector<int> vec_t;
@ -33,37 +31,36 @@ void check_std_container()
vec.push_back( 3 ); vec.push_back( 4 );
const vec_t cvec( vec );
BOOST_STATIC_ASSERT(( is_same< range_value<vec_t>::type, vec_t::value_type >::value ));
BOOST_STATIC_ASSERT(( is_same< range_iterator<vec_t>::type, vec_t::iterator >::value ));
BOOST_STATIC_ASSERT(( is_same< range_iterator<const vec_t>::type, vec_t::const_iterator >::value ));
BOOST_STATIC_ASSERT(( is_same< range_difference<vec_t>::type, vec_t::difference_type >::value ));
BOOST_STATIC_ASSERT(( is_same< range_size<vec_t>::type, vec_t::size_type >::value ));
BOOST_STATIC_ASSERT(( is_same< range_iterator<vec_t>::type, vec_t::iterator >::value ));
BOOST_STATIC_ASSERT(( is_same< range_iterator<const vec_t>::type, vec_t::const_iterator >::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_value<vec_t>::type, vec_t::value_type >::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<vec_t>::type, vec_t::iterator >::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<const vec_t>::type, vec_t::const_iterator >::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_difference<vec_t>::type, vec_t::difference_type >::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_size<vec_t>::type, vec_t::size_type >::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<vec_t>::type, vec_t::iterator >::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<const vec_t>::type, vec_t::const_iterator >::value ));
BOOST_STATIC_ASSERT(( is_same< range_value<const vec_t>::type, vec_t::value_type >::value ));
BOOST_STATIC_ASSERT(( is_same< range_difference<const vec_t>::type, vec_t::difference_type >::value ));
BOOST_STATIC_ASSERT(( is_same< range_size<const vec_t>::type, vec_t::size_type >::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_value<const vec_t>::type, vec_t::value_type >::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_difference<const vec_t>::type, vec_t::difference_type >::value ));
BOOST_STATIC_ASSERT(( boost::is_same< boost::range_size<const vec_t>::type, vec_t::size_type >::value ));
BOOST_CHECK( begin( vec ) == vec.begin() );
BOOST_CHECK( end( vec ) == vec.end() );
BOOST_CHECK( empty( vec ) == vec.empty() );
BOOST_CHECK( (std::size_t)size( vec ) == vec.size() );
BOOST_CHECK( boost::begin( vec ) == vec.begin() );
BOOST_CHECK( boost::end( vec ) == vec.end() );
BOOST_CHECK( boost::empty( vec ) == vec.empty() );
BOOST_CHECK( static_cast<std::size_t>(boost::size( vec )) == vec.size() );
BOOST_CHECK( begin( cvec ) == cvec.begin() );
BOOST_CHECK( end( cvec ) == cvec.end() );
BOOST_CHECK( empty( cvec ) == cvec.empty() );
BOOST_CHECK( (std::size_t)size( cvec ) == cvec.size() );
BOOST_CHECK( boost::begin( cvec ) == cvec.begin() );
BOOST_CHECK( boost::end( cvec ) == cvec.end() );
BOOST_CHECK( boost::empty( cvec ) == cvec.empty() );
BOOST_CHECK( static_cast<std::size_t>(boost::size( cvec )) == cvec.size() );
}
#include <boost/test/unit_test.hpp>
using boost::unit_test::test_suite;
test_suite* init_unit_test_suite( int argc, char* argv[] )
boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
{
test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
boost::unit_test::test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
test->add( BOOST_TEST_CASE( &check_std_container ) );