boost/bimap
2
0
Fork 0
mirror of https://github.com/boostorg/bimap.git synced 2026-01-19 04:02:10 +00:00
Code Issues Projects Releases Wiki Activity

Switch to LightweightTest and eliminate warnings in tests

Browse Source
This commit is contained in:
Glen Fernandes
2020-05-22 10:57:15 -04:00
parent 6b4d000a4f
commit a4317e5c82
34 changed files with 464 additions and 540 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
test/compile_fail/test_bimap_info_1.cpp
View File

@@ -17,9 +17,6 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
// Boost.Bimap
#include <boost/bimap/bimap.hpp>
#include <boost/bimap/list_of.hpp>
@@ -39,11 +36,3 @@ void test_bimap_info_1()
cbm.begin()->info = 10;
}
}
int test_main( int, char* [] )
{
test_bimap_info_1();
return 0;
}

11
test/compile_fail/test_bimap_info_2.cpp
View File

@@ -17,9 +17,6 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
// Boost.Bimap
#include <boost/bimap/bimap.hpp>
#include <boost/bimap/list_of.hpp>
@@ -38,11 +35,3 @@ void test_bimap_info_2()
bm.begin()->info;
}
}
int test_main( int, char* [] )
{
test_bimap_info_2();
return 0;
}

11
test/compile_fail/test_bimap_info_3.cpp
View File

@@ -17,9 +17,6 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
// Boost.Bimap
#include <boost/bimap/bimap.hpp>
#include <boost/bimap/list_of.hpp>
@@ -38,11 +35,3 @@ void test_bimap_info_3()
bm.left.info_at(1);
}
}
int test_main( int, char* [] )
{
test_bimap_info_3();
return 0;
}

11
test/compile_fail/test_bimap_mutable_1.cpp
View File

@@ -17,9 +17,6 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
// Boost.Bimap
#include <boost/bimap/bimap.hpp>
#include <boost/bimap/list_of.hpp>
@@ -39,11 +36,3 @@ void test_bimap_mutable_1()
cbm.begin()->right = 10;
}
}
int test_main( int, char* [] )
{
test_bimap_mutable_1();
return 0;
}

11
test/compile_fail/test_bimap_mutable_2.cpp
View File

@@ -17,9 +17,6 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
// Boost.Bimap
#include <boost/bimap/bimap.hpp>
#include <boost/bimap/list_of.hpp>
@@ -39,11 +36,3 @@ void test_bimap_mutable_2()
cbm.left.find(1)->second = 10;
}
}
int test_main( int, char* [] )
{
test_bimap_mutable_2();
return 0;
}

11
test/compile_fail/test_bimap_mutable_3.cpp
View File

@@ -17,9 +17,6 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
// Boost.Bimap
#include <boost/bimap/bimap.hpp>
#include <boost/bimap/list_of.hpp>
@@ -38,11 +35,3 @@ void test_bimap_mutable_3()
bm.right.begin()->second = 10;
}
}
int test_main( int, char* [] )
{
test_bimap_mutable_3();
return 0;
}

220
test/test_bimap.hpp
View File

@@ -33,35 +33,35 @@ void test_container(Container & c, const Data & d)
c.clear();
BOOST_CHECK( c.size() == 0 );
BOOST_CHECK( c.empty() );
BOOST_TEST( c.size() == 0 );
BOOST_TEST( c.empty() );
c.insert( *d.begin() );
c.insert( ++d.begin(),d.end() );
BOOST_CHECK( c.size() == d.size() );
BOOST_TEST( c.size() == d.size() );
BOOST_CHECK( c.size() <= c.max_size() );
BOOST_CHECK( ! c.empty() );
BOOST_TEST( c.size() <= c.max_size() );
BOOST_TEST( ! c.empty() );
c.erase( c.begin() );
BOOST_CHECK( c.size() == d.size() - 1 );
BOOST_TEST( c.size() == d.size() - 1 );
c.erase( c.begin(), c.end() );
BOOST_CHECK( c.empty() );
BOOST_TEST( c.empty() );
c.insert( *d.begin() );
BOOST_CHECK( c.size() == 1 );
BOOST_TEST( c.size() == 1 );
c.insert( c.begin(), *(++d.begin()) );
BOOST_CHECK( c.size() == 2 );
BOOST_TEST( c.size() == 2 );
BOOST_CHECK( c.begin() != c.end() );
BOOST_TEST( c.begin() != c.end() );
}
template< class Container, class Data >
@@ -71,48 +71,48 @@ void test_sequence_container(Container & c, const Data & d)
c.clear();
BOOST_CHECK( c.size() == 0 );
BOOST_CHECK( c.empty() );
BOOST_TEST( c.size() == 0 );
BOOST_TEST( c.empty() );
c.push_front( * d.begin() );
c.push_back ( *(++d.begin()) );
BOOST_CHECK( c.front() == * c.begin() );
BOOST_CHECK( c.back () == *(++c.begin()) );
BOOST_TEST( c.front() == * c.begin() );
BOOST_TEST( c.back () == *(++c.begin()) );
BOOST_CHECK( c.size() == 2 );
BOOST_TEST( c.size() == 2 );
BOOST_CHECK( c.size() <= c.max_size() );
BOOST_CHECK( ! c.empty() );
BOOST_TEST( c.size() <= c.max_size() );
BOOST_TEST( ! c.empty() );
c.erase( c.begin() );
BOOST_CHECK( c.size() == 1 );
BOOST_TEST( c.size() == 1 );
c.insert( c.begin(), *(++d.begin()) );
c.erase( c.begin(), c.end() );
BOOST_CHECK( c.empty() );
BOOST_TEST( c.empty() );
c.push_front( *d.begin() );
BOOST_CHECK( c.size() == 1 );
BOOST_TEST( c.size() == 1 );
BOOST_CHECK( c.begin() != c.end() );
BOOST_TEST( c.begin() != c.end() );
c.clear();
BOOST_CHECK( c.empty() );
BOOST_TEST( c.empty() );
// assign
c.assign(d.begin(),d.end());
BOOST_CHECK( c.size() == d.size() );
BOOST_CHECK( std::equal( c.begin(), c.end(), d.begin() ) );
BOOST_TEST( c.size() == d.size() );
BOOST_TEST( std::equal( c.begin(), c.end(), d.begin() ) );
c.assign(d.size(),*d.begin());
BOOST_CHECK( c.size() == d.size() );
BOOST_CHECK( *c.begin() == *d.begin() );
BOOST_TEST( c.size() == d.size() );
BOOST_TEST( *c.begin() == *d.begin() );
// Check insert(IterPos,InputIter,InputIter)
@@ -120,22 +120,22 @@ void test_sequence_container(Container & c, const Data & d)
c.insert( c.begin(), d.begin(), d.end() );
c.insert( boost::next(c.begin(),2), d.begin(), d.end() );
BOOST_CHECK( std::equal( boost::next(c.begin(),2)
BOOST_TEST( std::equal( boost::next(c.begin(),2)
, boost::next(c.begin(),2+d.size()) , d.begin() ) );
// Check resize
c.clear() ;
c.resize(4,*d.begin());
BOOST_CHECK( c.size() == 4 );
BOOST_CHECK( *c.begin() == *d.begin() ) ;
BOOST_TEST( c.size() == 4 );
BOOST_TEST( *c.begin() == *d.begin() ) ;
BOOST_CHECK( c == c );
BOOST_CHECK( ! ( c != c ) );
BOOST_CHECK( ! ( c < c ) );
BOOST_CHECK( ( c <= c ) );
BOOST_CHECK( ! ( c > c ) );
BOOST_CHECK( ( c >= c ) );
BOOST_TEST( c == c );
BOOST_TEST( ! ( c != c ) );
BOOST_TEST( ! ( c < c ) );
BOOST_TEST( ( c <= c ) );
BOOST_TEST( ! ( c > c ) );
BOOST_TEST( ( c >= c ) );
}
template< class Container, class Data >
@@ -145,12 +145,12 @@ void test_vector_container(Container & c, const Data & d)
c.clear() ;
c.reserve(2) ;
BOOST_CHECK( c.capacity() >= 2 ) ;
BOOST_TEST( c.capacity() >= 2 ) ;
c.assign(d.begin(),d.end());
BOOST_CHECK( c.capacity() >= c.size() ) ;
BOOST_TEST( c.capacity() >= c.size() ) ;
BOOST_CHECK( c[0] == *d.begin() ) ;
BOOST_CHECK( c.at(1) == *boost::next(d.begin()) );
BOOST_TEST( c[0] == *d.begin() ) ;
BOOST_TEST( c.at(1) == *boost::next(d.begin()) );
test_sequence_container(c,d) ;
}
@@ -166,7 +166,7 @@ void test_associative_container(Container & c, const Data & d)
for( typename Data::const_iterator di = d.begin(), de = d.end();
di != de; ++di )
{
BOOST_CHECK( c.find(*di) != c.end() );
BOOST_TEST( c.find(*di) != c.end() );
}
typename Data::const_iterator da = d.begin();
@@ -174,19 +174,19 @@ void test_associative_container(Container & c, const Data & d)
c.erase(*da);
BOOST_CHECK( c.size() == d.size()-1 );
BOOST_TEST( c.size() == d.size()-1 );
BOOST_CHECK( c.count(*da) == 0 );
BOOST_CHECK( c.count(*db) == 1 );
BOOST_TEST( c.count(*da) == 0 );
BOOST_TEST( c.count(*db) == 1 );
BOOST_CHECK( c.find(*da) == c.end() );
BOOST_CHECK( c.find(*db) != c.end() );
BOOST_TEST( c.find(*da) == c.end() );
BOOST_TEST( c.find(*db) != c.end() );
BOOST_CHECK( c.equal_range(*db).first != c.end() );
BOOST_TEST( c.equal_range(*db).first != c.end() );
c.clear();
BOOST_CHECK( c.equal_range(*da).first == c.end() );
BOOST_TEST( c.equal_range(*da).first == c.end() );
}
@@ -230,7 +230,7 @@ void test_pair_associative_container(Container & c, const Data & d)
for( typename Data::const_iterator di = d.begin(), de = d.end();
di != de; ++di )
{
BOOST_CHECK( c.find(di->first) != c.end() );
BOOST_TEST( c.find(di->first) != c.end() );
}
typename Data::const_iterator da = d.begin();
@@ -238,30 +238,30 @@ void test_pair_associative_container(Container & c, const Data & d)
c.erase(da->first);
BOOST_CHECK( c.size() == d.size()-1 );
BOOST_TEST( c.size() == d.size()-1 );
BOOST_CHECK( c.count(da->first) == 0 );
BOOST_CHECK( c.count(db->first) == 1 );
BOOST_TEST( c.count(da->first) == 0 );
BOOST_TEST( c.count(db->first) == 1 );
BOOST_CHECK( c.find(da->first) == c.end() );
BOOST_CHECK( c.find(db->first) != c.end() );
BOOST_TEST( c.find(da->first) == c.end() );
BOOST_TEST( c.find(db->first) != c.end() );
BOOST_CHECK( c.equal_range(db->first).first != c.end() );
BOOST_TEST( c.equal_range(db->first).first != c.end() );
c.clear();
BOOST_CHECK( c.equal_range(da->first).first == c.end() );
BOOST_TEST( c.equal_range(da->first).first == c.end() );
}
template< class Container, class Data >
void test_simple_ordered_associative_container_equality(Container & c, const Data & d)
{
BOOST_CHECK( std::equal( c. begin(), c. end(), d. begin() ) );
BOOST_CHECK( std::equal( c.rbegin(), c.rend(), d.rbegin() ) );
BOOST_TEST( std::equal( c. begin(), c. end(), d. begin() ) );
BOOST_TEST( std::equal( c.rbegin(), c.rend(), d.rbegin() ) );
BOOST_CHECK( c.lower_bound( *d.begin() ) == c.begin() );
BOOST_CHECK( c.upper_bound( *d.begin() ) == ++c.begin() );
BOOST_TEST( c.lower_bound( *d.begin() ) == c.begin() );
BOOST_TEST( c.upper_bound( *d.begin() ) == ++c.begin() );
}
template< class Container, class Data >
@@ -276,10 +276,10 @@ void test_simple_ordered_associative_container(Container & c, const Data & d)
di != de; ++di )
{
typename Container::const_iterator ci = c.find(*di);
BOOST_CHECK( ci != c.end() );
BOOST_TEST( ci != c.end() );
BOOST_CHECK( ! c.key_comp()(*ci,*di) );
BOOST_CHECK( ! c.value_comp()(*ci,*di) );
BOOST_TEST( ! c.key_comp()(*ci,*di) );
BOOST_TEST( ! c.value_comp()(*ci,*di) );
}
test_simple_ordered_associative_container_equality(c, d);
@@ -288,15 +288,15 @@ void test_simple_ordered_associative_container(Container & c, const Data & d)
test_simple_ordered_associative_container_equality(cr, d);
BOOST_CHECK( c == c );
BOOST_CHECK( ! ( c != c ) );
BOOST_CHECK( ! ( c < c ) );
BOOST_CHECK( ( c <= c ) );
BOOST_CHECK( ! ( c > c ) );
BOOST_CHECK( ( c >= c ) );
BOOST_TEST( c == c );
BOOST_TEST( ! ( c != c ) );
BOOST_TEST( ! ( c < c ) );
BOOST_TEST( ( c <= c ) );
BOOST_TEST( ! ( c > c ) );
BOOST_TEST( ( c >= c ) );
/*
BOOST_CHECK( c.range( *c.begin() <= ::boost::lambda::_1,
BOOST_TEST( c.range( *c.begin() <= ::boost::lambda::_1,
::boost::lambda::_1 <= *(++c.begin()) ).
first == c.begin()
);
@@ -309,8 +309,8 @@ void test_simple_unordered_associative_container(Container & c, const Data & d)
c.clear();
c.insert( d.begin(), d.end() );
BOOST_CHECK( c.bucket_count() * c.max_load_factor() >= d.size() );
BOOST_CHECK( c.max_bucket_count() >= c.bucket_count() );
BOOST_TEST( c.bucket_count() * c.max_load_factor() >= d.size() );
BOOST_TEST( c.max_bucket_count() >= c.bucket_count() );
for( typename Data::const_iterator di = d.begin(), de = d.end() ;
di != de ; ++di )
@@ -319,32 +319,32 @@ void test_simple_unordered_associative_container(Container & c, const Data & d)
{
typename Container::size_type nb = c.bucket(*c.find(*di));
BOOST_CHECK( c.begin(nb) != c.end(nb) );
BOOST_TEST( c.begin(nb) != c.end(nb) );
}
// const
{
const Container & const_c = c;
BOOST_CHECK(
BOOST_TEST(
const_c.bucket_size(const_c.bucket(*di)) == 1
);
typename Container::size_type nb =
const_c.bucket(*const_c.find(*di));
BOOST_CHECK(
BOOST_TEST(
const_c.begin(nb) != const_c.end(nb)
);
}
}
BOOST_CHECK( c.load_factor() < c.max_load_factor() );
BOOST_TEST( c.load_factor() < c.max_load_factor() );
c.max_load_factor(0.75);
BOOST_CHECK( c.max_load_factor() == 0.75 );
BOOST_TEST( c.max_load_factor() == 0.75 );
c.rehash(10);
}
@@ -353,11 +353,11 @@ void test_simple_unordered_associative_container(Container & c, const Data & d)
template< class Container, class Data >
void test_pair_ordered_associative_container_equality(Container & c, const Data & d)
{
BOOST_CHECK( std::equal( c. begin(), c. end(), d. begin() ) );
BOOST_CHECK( std::equal( c.rbegin(), c.rend(), d.rbegin() ) );
BOOST_TEST( std::equal( c. begin(), c. end(), d. begin() ) );
BOOST_TEST( std::equal( c.rbegin(), c.rend(), d.rbegin() ) );
BOOST_CHECK( c.lower_bound( d.begin()->first ) == c.begin() );
BOOST_CHECK( c.upper_bound( d.begin()->first ) == ++c.begin() );
BOOST_TEST( c.lower_bound( d.begin()->first ) == c.begin() );
BOOST_TEST( c.upper_bound( d.begin()->first ) == ++c.begin() );
}
template< class Container, class Data >
@@ -372,9 +372,9 @@ void test_pair_ordered_associative_container(Container & c, const Data & d)
ci != ce; ++ci )
{
typename Data::const_iterator di = d.find(ci->first);
BOOST_CHECK( di != d.end() );
BOOST_CHECK( ! c.key_comp()(di->first,ci->first) );
BOOST_CHECK( ! c.value_comp()(*ci,*di) );
BOOST_TEST( di != d.end() );
BOOST_TEST( ! c.key_comp()(di->first,ci->first) );
BOOST_TEST( ! c.value_comp()(*ci,*di) );
}
test_pair_ordered_associative_container_equality(c, d);
@@ -383,7 +383,7 @@ void test_pair_ordered_associative_container(Container & c, const Data & d)
test_pair_ordered_associative_container_equality(cr, d);
BOOST_CHECK( c.range( c.begin()->first <= ::boost::lambda::_1,
BOOST_TEST( c.range( c.begin()->first <= ::boost::lambda::_1,
::boost::lambda::_1 <= (++c.begin())->first ).
first == c.begin()
);
@@ -396,8 +396,8 @@ void test_pair_unordered_associative_container(Container & c, const Data & d)
c.clear();
c.insert( d.begin(), d.end() );
BOOST_CHECK( c.bucket_count() * c.max_load_factor() >= d.size() );
BOOST_CHECK( c.max_bucket_count() >= c.bucket_count() );
BOOST_TEST( c.bucket_count() * c.max_load_factor() >= d.size() );
BOOST_TEST( c.max_bucket_count() >= c.bucket_count() );
for( typename Data::const_iterator di = d.begin(), de = d.end() ;
di != de ; ++di )
@@ -407,28 +407,28 @@ void test_pair_unordered_associative_container(Container & c, const Data & d)
typename Container::size_type nb =
c.bucket(c.find(di->first)->first);
BOOST_CHECK( c.begin(nb) != c.end(nb) );
BOOST_TEST( c.begin(nb) != c.end(nb) );
}
// const
{
const Container & const_c = c;
BOOST_CHECK( const_c.bucket_size(const_c.bucket(di->first)) == 1 );
BOOST_TEST( const_c.bucket_size(const_c.bucket(di->first)) == 1 );
typename Container::size_type nb =
const_c.bucket(const_c.find(di->first)->first);
BOOST_CHECK( const_c.begin(nb) != const_c.end(nb) );
BOOST_TEST( const_c.begin(nb) != const_c.end(nb) );
}
}
BOOST_CHECK( c.load_factor() < c.max_load_factor() );
BOOST_TEST( c.load_factor() < c.max_load_factor() );
c.max_load_factor(0.75);
BOOST_CHECK( c.max_load_factor() == 0.75 );
BOOST_TEST( c.max_load_factor() == 0.75 );
c.rehash(10);
}
@@ -440,7 +440,7 @@ void test_unique_container(Container & c, Data & d)
c.clear();
c.insert(d.begin(),d.end());
c.insert(*d.begin());
BOOST_CHECK( c.size() == d.size() );
BOOST_TEST( c.size() == d.size() );
}
template< class Container, class Data >
@@ -449,7 +449,7 @@ void test_non_unique_container(Container & c, Data & d)
c.clear();
c.insert(d.begin(),d.end());
c.insert(*d.begin());
BOOST_CHECK( c.size() == (d.size()+1) );
BOOST_TEST( c.size() == (d.size()+1) );
}
@@ -463,8 +463,8 @@ void test_basic_bimap( Bimap & b,
test_container(b,d);
BOOST_CHECK( & b.left == & b.template by<member_at::left >() );
BOOST_CHECK( & b.right == & b.template by<member_at::right>() );
BOOST_TEST( & b.left == & b.template by<member_at::left >() );
BOOST_TEST( & b.right == & b.template by<member_at::right>() );
test_container(b.left , ld);
test_container(b.right, rd);
@@ -476,18 +476,18 @@ void test_tagged_bimap(Bimap & b,
{
using namespace boost::bimaps;
BOOST_CHECK( &b.left == & b.template by<LeftTag >() );
BOOST_CHECK( &b.right == & b.template by<RightTag>() );
BOOST_TEST( &b.left == & b.template by<LeftTag >() );
BOOST_TEST( &b.right == & b.template by<RightTag>() );
b.clear();
b.insert( *d.begin() );
BOOST_CHECK(
BOOST_TEST(
b.begin()->template get<LeftTag>() ==
b.template by<RightTag>().begin()->template get<LeftTag>()
);
BOOST_CHECK(
BOOST_TEST(
b.begin()->template get<RightTag>() ==
b.template by<LeftTag>().begin()->template get<RightTag>()
);
@@ -497,13 +497,13 @@ void test_tagged_bimap(Bimap & b,
const Bimap & bc = b;
BOOST_CHECK( &bc.left == & bc.template by<LeftTag>() );
BOOST_CHECK( &bc.right == & bc.template by<RightTag>() );
BOOST_TEST( &bc.left == & bc.template by<LeftTag>() );
BOOST_TEST( &bc.right == & bc.template by<RightTag>() );
BOOST_CHECK( bc.begin()->template get<LeftTag>() ==
BOOST_TEST( bc.begin()->template get<LeftTag>() ==
bc.template by<RightTag>().begin()->template get<LeftTag>() );
BOOST_CHECK( bc.begin()->template get<RightTag>() ==
BOOST_TEST( bc.begin()->template get<RightTag>() ==
bc.template by<LeftTag>().begin()->template get<RightTag>() );
}
}
@@ -581,29 +581,29 @@ void test_bimap_init_copy_swap(const Data&d)
{
Bimap b1(d.begin(),d.end());
Bimap b2( b1 );
BOOST_CHECK( b1 == b2 );
BOOST_TEST( b1 == b2 );
b2.clear();
b2 = b1;
BOOST_CHECK( b2 == b1 );
BOOST_TEST( b2 == b1 );
b2.clear();
b2.left = b1.left;
BOOST_CHECK( b2 == b1 );
BOOST_TEST( b2 == b1 );
b2.clear();
b2.right = b1.right;
BOOST_CHECK( b2 == b1 );
BOOST_TEST( b2 == b1 );
b1.clear();
b2.swap(b1);
BOOST_CHECK( b2.empty() && !b1.empty() );
BOOST_TEST( b2.empty() && !b1.empty() );
b1.left.swap( b2.left );
BOOST_CHECK( b1.empty() && !b2.empty() );
BOOST_TEST( b1.empty() && !b2.empty() );
b1.right.swap( b2.right );
BOOST_CHECK( b2.empty() && !b1.empty() );
BOOST_TEST( b2.empty() && !b1.empty() );
}
#endif // LIBS_BIMAP_TEST_BIMAP_TEST_HPP

5
test/test_bimap_assign.cpp
View File

@@ -17,9 +17,6 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
// std
#include <sstream>
#include <algorithm>
@@ -81,7 +78,7 @@ void test_bimap_assign()
}
int test_main( int, char* [] )
int main()
{
test_bimap_assign();
return 0;

9
test/test_bimap_convenience_header.cpp
View File

@@ -17,8 +17,7 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/lightweight_test.hpp>
#include <boost/bimap.hpp>
@@ -27,12 +26,12 @@ void test_bimap_convenience_header()
typedef boost::bimap< int, double > bm_type;
bm_type bm;
bm.insert( bm_type::value_type(1,0.1) );
BOOST_CHECK( bm.right.at(0.1) == 1 );
BOOST_TEST( bm.right.at(0.1) == 1 );
}
int test_main( int, char* [] )
int main()
{
test_bimap_convenience_header();
return 0;
return boost::report_errors();
}

5
test/test_bimap_extra.cpp
View File

@@ -17,9 +17,6 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
@@ -90,7 +87,7 @@ void test_bimap_extra()
}
int test_main( int, char* [] )
int main()
{
test_bimap_extra();
return 0;

43
test/test_bimap_info.cpp
View File

@@ -17,8 +17,7 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/lightweight_test.hpp>
#include <boost/config.hpp>
@@ -43,28 +42,28 @@ int test_bimap_info()
bm.right.insert( bm_type::right_value_type( 3 , 3.3, "three" ) );
bm.begin()->info = "1";
BOOST_CHECK( bm.right.find(1)->info == "1" );
BOOST_TEST( bm.right.find(1)->info == "1" );
bm.left.find(2.2)->info = "2";
BOOST_CHECK( bm.right.find(2)->info == "2" );
BOOST_TEST( bm.right.find(2)->info == "2" );
bm.right.find(3)->info = "3";
BOOST_CHECK( bm.right.find(3)->info == "3" );
BOOST_TEST( bm.right.find(3)->info == "3" );
// Empty info insert
bm .insert( bm_type:: value_type(4.4 , 4) );
bm. left.insert( bm_type:: left_value_type(5.5 , 5) );
bm.right.insert( bm_type::right_value_type( 6 , 6.6) );
BOOST_CHECK( bm.right.find(4)->info == "" );
BOOST_TEST( bm.right.find(4)->info == "" );
bm.left.info_at(4.4) = "4";
BOOST_CHECK( bm.right.info_at(4) == "4" );
BOOST_CHECK( cbm.right.info_at(4) == "4" );
BOOST_TEST( bm.right.info_at(4) == "4" );
BOOST_TEST( cbm.right.info_at(4) == "4" );
bm.right.info_at(5) = "5";
BOOST_CHECK( bm.left.info_at(5.5) == "5" );
BOOST_CHECK( cbm.left.info_at(5.5) == "5" );
BOOST_TEST( bm.left.info_at(5.5) == "5" );
BOOST_TEST( cbm.left.info_at(5.5) == "5" );
return 0;
}
@@ -90,16 +89,16 @@ int test_tagged_bimap_info()
bm.right.insert( bm_type::right_value_type(3,3,3) );
bm.begin()->get<info>() = 10;
BOOST_CHECK( bm.right.find(1)->get<info>() == 10 );
BOOST_CHECK( cbm.right.find(1)->get<info>() == 10 );
BOOST_TEST( bm.right.find(1)->get<info>() == 10 );
BOOST_TEST( cbm.right.find(1)->get<info>() == 10 );
bm.left.find(2)->get<info>() = 20;
BOOST_CHECK( bm.right.find(2)->get<info>() == 20 );
BOOST_CHECK( cbm.right.find(2)->get<info>() == 20 );
BOOST_TEST( bm.right.find(2)->get<info>() == 20 );
BOOST_TEST( cbm.right.find(2)->get<info>() == 20 );
bm.right.find(3)->get<info>() = 30;
BOOST_CHECK( bm.right.find(3)->get<info>() == 30 );
BOOST_CHECK( cbm.right.find(3)->get<info>() == 30 );
BOOST_TEST( bm.right.find(3)->get<info>() == 30 );
BOOST_TEST( cbm.right.find(3)->get<info>() == 30 );
// Empty info insert
bm .insert( bm_type:: value_type(4,4) );
@@ -107,20 +106,20 @@ int test_tagged_bimap_info()
bm.right.insert( bm_type::right_value_type(6,6) );
bm.left.info_at(4) = 4;
BOOST_CHECK( bm.right.info_at(4) == 4 );
BOOST_CHECK( cbm.right.info_at(4) == 4 );
BOOST_TEST( bm.right.info_at(4) == 4 );
BOOST_TEST( cbm.right.info_at(4) == 4 );
bm.right.info_at(5) = 5;
BOOST_CHECK( bm.left.info_at(5) == 5 );
BOOST_CHECK( cbm.left.info_at(5) == 5 );
BOOST_TEST( bm.left.info_at(5) == 5 );
BOOST_TEST( cbm.left.info_at(5) == 5 );
return 0;
}
int test_main( int, char* [] )
int main()
{
test_bimap_info();
test_tagged_bimap_info();
return 0;
return boost::report_errors();
}

15
test/test_bimap_lambda.cpp
View File

@@ -17,8 +17,7 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/lightweight_test.hpp>
// Boost.Bimap
#include <boost/bimap/support/lambda.hpp>
@@ -33,15 +32,15 @@ void test_bimap_lambda()
bm b;
b.insert( bm::value_type(1,0.1) );
BOOST_CHECK( b.size() == 1 );
BOOST_CHECK( b.left.modify_key ( b.left.begin(), _key = 2 ) );
BOOST_CHECK( b.left.modify_data( b.left.begin(), _data = 0.2 ) );
BOOST_CHECK( b.left.range( _key >= 1, _key < 3 ).first == b.left.begin() );
BOOST_TEST( b.size() == 1 );
BOOST_TEST( b.left.modify_key ( b.left.begin(), _key = 2 ) );
BOOST_TEST( b.left.modify_data( b.left.begin(), _data = 0.2 ) );
BOOST_TEST( b.left.range( _key >= 1, _key < 3 ).first == b.left.begin() );
}
int test_main( int, char* [] )
int main()
{
test_bimap_lambda();
return 0;
return boost::report_errors();
}

7
test/test_bimap_list_of.cpp
View File

@@ -17,15 +17,16 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/ignore_unused.hpp>
#include <boost/bimap/list_of.hpp>
int test_main( int, char* [] )
int main()
{
typedef boost::bimaps::list_of<int> set_type;
typedef boost::bimaps::list_of_relation set_type_of_relation;
boost::ignore_unused<set_type>();
boost::ignore_unused<set_type_of_relation>();
return 0;
}

155
test/test_bimap_modify.cpp
View File

@@ -17,8 +17,7 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/lightweight_test.hpp>
// Boost.Bimap
#include <boost/bimap/support/lambda.hpp>
@@ -35,7 +34,7 @@ void test_bimap_modify()
bm b;
b.insert( bm::value_type(2,200) );
BOOST_CHECK( b.left.at(2) == 200 );
BOOST_TEST( b.left.at(2) == 200 );
bool result;
@@ -48,24 +47,24 @@ void test_bimap_modify()
result = b.left.replace( i, bm::left_value_type(1,100) );
BOOST_CHECK( result );
BOOST_CHECK( b.size() == 1 );
BOOST_CHECK( i->first == 1 && i->second == 100 );
BOOST_CHECK( b.left.at(1) == 100 );
BOOST_TEST( result );
BOOST_TEST( b.size() == 1 );
BOOST_TEST( i->first == 1 && i->second == 100 );
BOOST_TEST( b.left.at(1) == 100 );
result = b.left.replace_key( i, 2 );
BOOST_CHECK( result );
BOOST_CHECK( b.size() == 1 );
BOOST_CHECK( i->first == 2 && i->second == 100 );
BOOST_CHECK( b.left.at(2) == 100 );
BOOST_TEST( result );
BOOST_TEST( b.size() == 1 );
BOOST_TEST( i->first == 2 && i->second == 100 );
BOOST_TEST( b.left.at(2) == 100 );
result = b.left.replace_data( i, 200 );
BOOST_CHECK( result );
BOOST_CHECK( b.size() == 1 );
BOOST_CHECK( i->first == 2 && i->second == 200 );
BOOST_CHECK( b.left.at(2) == 200 );
BOOST_TEST( result );
BOOST_TEST( b.size() == 1 );
BOOST_TEST( i->first == 2 && i->second == 200 );
BOOST_TEST( b.left.at(2) == 200 );
}
// successful replace in right map view
@@ -74,24 +73,24 @@ void test_bimap_modify()
result = b.right.replace( i, bm::right_value_type(100,1) );
BOOST_CHECK( result );
BOOST_CHECK( b.size() == 1 );
BOOST_CHECK( i->first == 100 && i->second == 1 );
BOOST_CHECK( b.right.at(100) == 1 );
BOOST_TEST( result );
BOOST_TEST( b.size() == 1 );
BOOST_TEST( i->first == 100 && i->second == 1 );
BOOST_TEST( b.right.at(100) == 1 );
result = b.right.replace_key( i, 200 );
BOOST_CHECK( result );
BOOST_CHECK( b.size() == 1 );
BOOST_CHECK( i->first == 200 && i->second == 1 );
BOOST_CHECK( b.right.at(200) == 1 );
BOOST_TEST( result );
BOOST_TEST( b.size() == 1 );
BOOST_TEST( i->first == 200 && i->second == 1 );
BOOST_TEST( b.right.at(200) == 1 );
result = b.right.replace_data( i, 2 );
BOOST_CHECK( result );
BOOST_CHECK( b.size() == 1 );
BOOST_CHECK( i->first == 200 && i->second == 2 );
BOOST_CHECK( b.right.at(200) == 2 );
BOOST_TEST( result );
BOOST_TEST( b.size() == 1 );
BOOST_TEST( i->first == 200 && i->second == 2 );
BOOST_TEST( b.right.at(200) == 2 );
}
// successful replace in set of relations view
@@ -100,24 +99,24 @@ void test_bimap_modify()
result = b.replace( i, bm::value_type(1,100) );
BOOST_CHECK( result );
BOOST_CHECK( b.size() == 1 );
BOOST_CHECK( i->left == 1 && i->right == 100 );
BOOST_CHECK( b.left.at(1) == 100 );
BOOST_TEST( result );
BOOST_TEST( b.size() == 1 );
BOOST_TEST( i->left == 1 && i->right == 100 );
BOOST_TEST( b.left.at(1) == 100 );
result = b.replace_left( i, 2 );
BOOST_CHECK( result );
BOOST_CHECK( b.size() == 1 );
BOOST_CHECK( i->left == 2 && i->right == 100 );
BOOST_CHECK( b.left.at(2) == 100 );
BOOST_TEST( result );
BOOST_TEST( b.size() == 1 );
BOOST_TEST( i->left == 2 && i->right == 100 );
BOOST_TEST( b.left.at(2) == 100 );
result = b.replace_right( b.begin(), 200 );
BOOST_CHECK( result );
BOOST_CHECK( b.size() == 1 );
BOOST_CHECK( i->left == 2 && i->right == 200 );
BOOST_CHECK( b.left.at(2) == 200 );
BOOST_TEST( result );
BOOST_TEST( b.size() == 1 );
BOOST_TEST( i->left == 2 && i->right == 200 );
BOOST_TEST( b.left.at(2) == 200 );
}
@@ -131,11 +130,11 @@ void test_bimap_modify()
result = b.left.replace( i, bm::left_value_type(2,100) );
BOOST_CHECK( ! result );
BOOST_CHECK( b.size() == 2 );
BOOST_CHECK( i->first == 1 && i->second == 100 );
BOOST_CHECK( b.left.at(1) == 100 );
BOOST_CHECK( b.left.at(2) == 200 );
BOOST_TEST( ! result );
BOOST_TEST( b.size() == 2 );
BOOST_TEST( i->first == 1 && i->second == 100 );
BOOST_TEST( b.left.at(1) == 100 );
BOOST_TEST( b.left.at(2) == 200 );
// Add checks for replace_key and replace_data
@@ -156,15 +155,15 @@ void test_bimap_modify()
{
result = b.left.modify_key( b.left.begin(), _key = 2 );
BOOST_CHECK( result );
BOOST_CHECK( b.size() == 1 );
BOOST_CHECK( b.left.at(2) == 100 );
BOOST_TEST( result );
BOOST_TEST( b.size() == 1 );
BOOST_TEST( b.left.at(2) == 100 );
result = b.left.modify_data( b.left.begin() , _data = 200 );
BOOST_CHECK( result );
BOOST_CHECK( b.size() == 1 );
BOOST_CHECK( b.left.at(2) == 200 );
BOOST_TEST( result );
BOOST_TEST( b.size() == 1 );
BOOST_TEST( b.left.at(2) == 200 );
}
// Add checks for successful modify in right map view
@@ -182,8 +181,8 @@ void test_bimap_replace_with_info()
bm b;
b.insert( bm::value_type(2,200,-2) );
BOOST_CHECK( b.left.at(2) == 200 );
BOOST_CHECK( b.left.info_at(2) == -2 );
BOOST_TEST( b.left.at(2) == 200 );
BOOST_TEST( b.left.info_at(2) == -2 );
// Use set view
{
@@ -191,24 +190,24 @@ void test_bimap_replace_with_info()
bool result = b.replace( i, bm::value_type(1,100,-1) );
BOOST_CHECK( result );
BOOST_CHECK( b.size() == 1 );
BOOST_CHECK( i->left == 1 && i->right == 100 );
BOOST_CHECK( i->info == -1 );
BOOST_TEST( result );
BOOST_TEST( b.size() == 1 );
BOOST_TEST( i->left == 1 && i->right == 100 );
BOOST_TEST( i->info == -1 );
result = b.replace_left( i, 2 );
BOOST_CHECK( result );
BOOST_CHECK( b.size() == 1 );
BOOST_CHECK( i->left == 2 && i->right == 100 );
BOOST_CHECK( i->info == -1 );
BOOST_TEST( result );
BOOST_TEST( b.size() == 1 );
BOOST_TEST( i->left == 2 && i->right == 100 );
BOOST_TEST( i->info == -1 );
result = b.replace_right( i, 200 );
BOOST_CHECK( result );
BOOST_CHECK( b.size() == 1 );
BOOST_CHECK( i->left == 2 && i->right == 200 );
BOOST_CHECK( i->info == -1 );
BOOST_TEST( result );
BOOST_TEST( b.size() == 1 );
BOOST_TEST( i->left == 2 && i->right == 200 );
BOOST_TEST( i->info == -1 );
}
// Use map view
@@ -217,33 +216,33 @@ void test_bimap_replace_with_info()
bool result = b.left.replace( i, bm::left_value_type(1,100,-1) );
BOOST_CHECK( result );
BOOST_CHECK( b.left.size() == 1 );
BOOST_CHECK( i->first == 1 && i->second == 100 );
BOOST_CHECK( i->info == -1 );
BOOST_TEST( result );
BOOST_TEST( b.left.size() == 1 );
BOOST_TEST( i->first == 1 && i->second == 100 );
BOOST_TEST( i->info == -1 );
result = b.left.replace_key( i, 2 );
BOOST_CHECK( result );
BOOST_CHECK( b.left.size() == 1 );
BOOST_CHECK( i->first == 2 && i->second == 100 );
BOOST_CHECK( i->info == -1 );
BOOST_TEST( result );
BOOST_TEST( b.left.size() == 1 );
BOOST_TEST( i->first == 2 && i->second == 100 );
BOOST_TEST( i->info == -1 );
result = b.left.replace_data( i, 200 );
BOOST_CHECK( result );
BOOST_CHECK( b.left.size() == 1 );
BOOST_CHECK( i->first == 2 && i->second == 200 );
BOOST_CHECK( i->info == -1 );
BOOST_TEST( result );
BOOST_TEST( b.left.size() == 1 );
BOOST_TEST( i->first == 2 && i->second == 200 );
BOOST_TEST( i->info == -1 );
}
}
int test_main( int, char* [] )
int main()
{
test_bimap_modify();
test_bimap_replace_with_info();
return 0;
return boost::report_errors();
}

7
test/test_bimap_multiset_of.cpp
View File

@@ -17,15 +17,16 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/ignore_unused.hpp>
#include <boost/bimap/multiset_of.hpp>
int test_main( int, char* [] )
int main()
{
typedef boost::bimaps::multiset_of<int> set_type;
typedef boost::bimaps::multiset_of_relation<> set_type_of_relation;
boost::ignore_unused<set_type>();
boost::ignore_unused<set_type_of_relation>();
return 0;
}

31
test/test_bimap_mutable.cpp
View File

@@ -17,8 +17,7 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/lightweight_test.hpp>
// Boost.Bimap
#include <boost/bimap/bimap.hpp>
@@ -43,13 +42,13 @@ void test_bimap_mutable()
BOOST_DEDUCED_TYPENAME bm_type::left_iterator iter = bm.left.begin();
iter->second = 0.2;
BOOST_CHECK( iter->second == bm.left.begin()->second );
BOOST_TEST( iter->second == bm.left.begin()->second );
BOOST_DEDUCED_TYPENAME bm_type::left_const_iterator citer = bm.left.begin();
BOOST_CHECK( citer->second == bm.left.begin()->second );
BOOST_TEST( citer->second == bm.left.begin()->second );
BOOST_DEDUCED_TYPENAME bm_type::left_const_iterator cciter = cbm.left.begin();
BOOST_CHECK( cciter->second == cbm.left.begin()->second );
BOOST_TEST( cciter->second == cbm.left.begin()->second );
}
@@ -58,13 +57,13 @@ void test_bimap_mutable()
BOOST_DEDUCED_TYPENAME bm_type::iterator iter = bm.begin();
iter->right = 0.1;
BOOST_CHECK( iter->right == bm.begin()->right );
BOOST_TEST( iter->right == bm.begin()->right );
BOOST_DEDUCED_TYPENAME bm_type::const_iterator citer = bm.begin();
BOOST_CHECK( citer->right == bm.begin()->right );
BOOST_TEST( citer->right == bm.begin()->right );
BOOST_DEDUCED_TYPENAME bm_type::const_iterator cciter = cbm.begin();
BOOST_CHECK( cciter->left == cbm.begin()->left );
BOOST_TEST( cciter->left == cbm.begin()->left );
}
@@ -73,13 +72,13 @@ void test_bimap_mutable()
BOOST_DEDUCED_TYPENAME bm_type::left_reference r = *bm.left.begin();
r.second = 0.2;
BOOST_CHECK( r == *bm.left.begin() );
BOOST_TEST( r == *bm.left.begin() );
BOOST_DEDUCED_TYPENAME bm_type::left_const_reference cr = *bm.left.begin();
BOOST_CHECK( cr == *bm.left.begin() );
BOOST_TEST( cr == *bm.left.begin() );
BOOST_DEDUCED_TYPENAME bm_type::left_const_reference ccr = *cbm.left.begin();
BOOST_CHECK( ccr == *cbm.left.begin() );
BOOST_TEST( ccr == *cbm.left.begin() );
}
@@ -88,22 +87,22 @@ void test_bimap_mutable()
BOOST_DEDUCED_TYPENAME bm_type::reference r = *bm.begin();
r.right = 0.1;
BOOST_CHECK( r == *bm.begin() );
BOOST_TEST( r == *bm.begin() );
BOOST_DEDUCED_TYPENAME bm_type::const_reference cr = *bm.begin();
BOOST_CHECK( cr == *bm.begin() );
BOOST_TEST( cr == *bm.begin() );
BOOST_DEDUCED_TYPENAME bm_type::const_reference ccr = *cbm.begin();
BOOST_CHECK( ccr == *bm.begin() );
BOOST_TEST( ccr == *bm.begin() );
}
}
int test_main( int, char* [] )
int main()
{
test_bimap_mutable< bimap< int, list_of<double> > >();
test_bimap_mutable< bimap< int, vector_of<double> > >();
test_bimap_mutable< bimap< int, unconstrained_set_of<double> > >();
return 0;
return boost::report_errors();
}

51
test/test_bimap_operator_bracket.cpp
View File

@@ -17,8 +17,8 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/ignore_unused.hpp>
#include <boost/core/lightweight_test.hpp>
// Boost.Bimap
#include <boost/bimap/support/lambda.hpp>
@@ -43,7 +43,7 @@ void test_bimap_operator_bracket()
b.insert( bm::value_type(2,"2") );
b.insert( bm::value_type(3,"3") );
BOOST_CHECK( b.left.at(1) == "1" );
BOOST_TEST( b.left.at(1) == "1" );
// Out of range test
{
@@ -53,13 +53,14 @@ void test_bimap_operator_bracket()
{
bool comp;
comp = b.left.at(2) < "banana";
boost::ignore_unused(comp);
}
catch( std::out_of_range & )
{
value_not_found_test_passed = true;
}
BOOST_CHECK( value_not_found_test_passed );
BOOST_TEST( value_not_found_test_passed );
}
}
@@ -76,13 +77,14 @@ void test_bimap_operator_bracket()
{
bool comp;
comp = b.left.at(1) < "banana";
boost::ignore_unused(comp);
}
catch( std::out_of_range & )
{
value_not_found_test_passed = true;
}
BOOST_CHECK( value_not_found_test_passed );
BOOST_TEST( value_not_found_test_passed );
}
@@ -95,23 +97,24 @@ void test_bimap_operator_bracket()
const bm & cb(b);
bool comp;
comp = cb.left.at(1) < "banana";
boost::ignore_unused(comp);
}
catch( std::out_of_range & )
{
value_not_found_test_passed = true;
}
BOOST_CHECK( value_not_found_test_passed );
BOOST_TEST( value_not_found_test_passed );
}
BOOST_CHECK( b.left[1] == "" );
BOOST_CHECK( b.left.at(1) == "" );
BOOST_TEST( b.left[1] == "" );
BOOST_TEST( b.left.at(1) == "" );
b.left[2] = "two";
BOOST_CHECK( b.left.at(2) == "two" );
BOOST_TEST( b.left.at(2) == "two" );
b.left[2] = "<<two>>";
BOOST_CHECK( b.left.at(2) == "<<two>>" );
BOOST_TEST( b.left.at(2) == "<<two>>" );
b.left.at(2) = "two";
BOOST_CHECK( b.left.at(2) == "two" );
BOOST_TEST( b.left.at(2) == "two" );
}
@@ -128,12 +131,13 @@ void test_bimap_operator_bracket()
{
bool comp;
comp = b.right.at("banana") < 1;
boost::ignore_unused(comp);
}
catch( std::out_of_range & )
{
value_not_found_test_passed = true;
}
BOOST_CHECK( value_not_found_test_passed );
BOOST_TEST( value_not_found_test_passed );
}
// Out of range test (const version)
@@ -145,23 +149,24 @@ void test_bimap_operator_bracket()
const bm & cb(b);
bool comp;
comp = cb.right.at("banana") < 1;
boost::ignore_unused(comp);
}
catch( std::out_of_range & )
{
value_not_found_test_passed = true;
}
BOOST_CHECK( value_not_found_test_passed );
BOOST_TEST( value_not_found_test_passed );
}
b.right["one"];
BOOST_CHECK( b.size() == 1 );
BOOST_TEST( b.size() == 1 );
b.right["two"] = 2;
BOOST_CHECK( b.right.at("two") == 2 );
BOOST_TEST( b.right.at("two") == 2 );
b.right["two"] = -2;
BOOST_CHECK( b.right.at("two") == -2 );
BOOST_TEST( b.right.at("two") == -2 );
b.right.at("two") = 2;
BOOST_CHECK( b.right.at("two") == 2 );
BOOST_TEST( b.right.at("two") == 2 );
}
// Mutable data test (3)
@@ -173,21 +178,21 @@ void test_bimap_operator_bracket()
bm b;
b.right["one"];
BOOST_CHECK( b.size() == 1 );
BOOST_TEST( b.size() == 1 );
b.right["two"] = 2;
BOOST_CHECK( b.right.at("two") == 2 );
BOOST_TEST( b.right.at("two") == 2 );
b.right["two"] = -2;
BOOST_CHECK( b.right.at("two") == -2 );
BOOST_TEST( b.right.at("two") == -2 );
b.right.at("two") = 2;
BOOST_CHECK( b.right.at("two") == 2 );
BOOST_TEST( b.right.at("two") == 2 );
}
}
int test_main( int, char* [] )
int main()
{
test_bimap_operator_bracket();
return 0;
return boost::report_errors();
}

31
test/test_bimap_ordered.cpp
View File

@@ -19,8 +19,7 @@
#define BOOST_BIMAP_DISABLE_SERIALIZATION
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/lightweight_test.hpp>
// std
#include <set>
@@ -131,46 +130,46 @@ void test_bimap()
bimap_type b2( b1 );
BOOST_CHECK( b1 == b2 );
BOOST_CHECK( ! ( b1 != b2 ) );
BOOST_CHECK( b1 <= b2 );
BOOST_CHECK( b1 >= b2 );
BOOST_CHECK( ! ( b1 < b2 ) );
BOOST_CHECK( ! ( b1 > b2 ) );
BOOST_TEST( b1 == b2 );
BOOST_TEST( ! ( b1 != b2 ) );
BOOST_TEST( b1 <= b2 );
BOOST_TEST( b1 >= b2 );
BOOST_TEST( ! ( b1 < b2 ) );
BOOST_TEST( ! ( b1 > b2 ) );
b1.insert( bimap_type::value_type(2,"two") );
b2 = b1;
BOOST_CHECK( b2 == b1 );
BOOST_TEST( b2 == b1 );
b1.insert( bimap_type::value_type(3,"three") );
b2.left = b1.left;
BOOST_CHECK( b2 == b1 );
BOOST_TEST( b2 == b1 );
b1.insert( bimap_type::value_type(4,"four") );
b2.right = b1.right;
BOOST_CHECK( b2 == b1 );
BOOST_TEST( b2 == b1 );
b1.clear();
b2.swap(b1);
BOOST_CHECK( b2.empty() && !b1.empty() );
BOOST_TEST( b2.empty() && !b1.empty() );
b1.left.swap( b2.left );
BOOST_CHECK( b1.empty() && !b2.empty() );
BOOST_TEST( b1.empty() && !b2.empty() );
b1.right.swap( b2.right );
BOOST_CHECK( b2.empty() && !b1.empty() );
BOOST_TEST( b2.empty() && !b1.empty() );
}
//--------------------------------------------------------------------
}
int test_main( int, char* [] )
int main()
{
test_bimap();
return 0;
return boost::report_errors();
}

91
test/test_bimap_project.cpp
View File

@@ -17,8 +17,7 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/lightweight_test.hpp>
#include <string>
@@ -57,21 +56,21 @@ void test_bimap_project()
// non const projection
BOOST_CHECK( bm.project_up (bm.end()) == bm.end() );
BOOST_CHECK( bm.project_left (bm.end()) == bm.left.end() );
BOOST_CHECK( bm.project_right(bm.end()) == bm.right.end() );
BOOST_TEST( bm.project_up (bm.end()) == bm.end() );
BOOST_TEST( bm.project_left (bm.end()) == bm.left.end() );
BOOST_TEST( bm.project_right(bm.end()) == bm.right.end() );
BOOST_CHECK( bm.project_up (iter) == iter );
BOOST_CHECK( bm.project_left (iter) == left_iter );
BOOST_CHECK( bm.project_right(iter) == right_iter );
BOOST_TEST( bm.project_up (iter) == iter );
BOOST_TEST( bm.project_left (iter) == left_iter );
BOOST_TEST( bm.project_right(iter) == right_iter );
BOOST_CHECK( bm.project_up (left_iter) == iter );
BOOST_CHECK( bm.project_left (left_iter) == left_iter );
BOOST_CHECK( bm.project_right(left_iter) == right_iter );
BOOST_TEST( bm.project_up (left_iter) == iter );
BOOST_TEST( bm.project_left (left_iter) == left_iter );
BOOST_TEST( bm.project_right(left_iter) == right_iter );
BOOST_CHECK( bm.project_up (right_iter) == iter );
BOOST_CHECK( bm.project_left (right_iter) == left_iter );
BOOST_CHECK( bm.project_right(right_iter) == right_iter );
BOOST_TEST( bm.project_up (right_iter) == iter );
BOOST_TEST( bm.project_left (right_iter) == left_iter );
BOOST_TEST( bm.project_right(right_iter) == right_iter );
bm.project_up ( left_iter)->right = "u";
bm.project_left (right_iter)->second = "l";
@@ -79,31 +78,31 @@ void test_bimap_project()
// const projection
BOOST_CHECK( cbm.project_up (cbm.end()) == cbm.end() );
BOOST_CHECK( cbm.project_left (cbm.end()) == cbm.left.end() );
BOOST_CHECK( cbm.project_right(cbm.end()) == cbm.right.end() );
BOOST_TEST( cbm.project_up (cbm.end()) == cbm.end() );
BOOST_TEST( cbm.project_left (cbm.end()) == cbm.left.end() );
BOOST_TEST( cbm.project_right(cbm.end()) == cbm.right.end() );
BOOST_CHECK( cbm.project_up (citer) == citer );
BOOST_CHECK( cbm.project_left (citer) == left_citer );
BOOST_CHECK( cbm.project_right(citer) == right_citer );
BOOST_TEST( cbm.project_up (citer) == citer );
BOOST_TEST( cbm.project_left (citer) == left_citer );
BOOST_TEST( cbm.project_right(citer) == right_citer );
BOOST_CHECK( cbm.project_up (left_citer) == citer );
BOOST_CHECK( cbm.project_left (left_citer) == left_citer );
BOOST_CHECK( cbm.project_right(left_citer) == right_citer );
BOOST_TEST( cbm.project_up (left_citer) == citer );
BOOST_TEST( cbm.project_left (left_citer) == left_citer );
BOOST_TEST( cbm.project_right(left_citer) == right_citer );
BOOST_CHECK( cbm.project_up (right_citer) == citer );
BOOST_CHECK( cbm.project_left (right_citer) == left_citer );
BOOST_CHECK( cbm.project_right(right_citer) == right_citer );
BOOST_TEST( cbm.project_up (right_citer) == citer );
BOOST_TEST( cbm.project_left (right_citer) == left_citer );
BOOST_TEST( cbm.project_right(right_citer) == right_citer );
// mixed projection
BOOST_CHECK( bm.project_up (left_citer) == iter );
BOOST_CHECK( bm.project_left (left_citer) == left_iter );
BOOST_CHECK( bm.project_right(left_citer) == right_iter );
BOOST_TEST( bm.project_up (left_citer) == iter );
BOOST_TEST( bm.project_left (left_citer) == left_iter );
BOOST_TEST( bm.project_right(left_citer) == right_iter );
BOOST_CHECK( cbm.project_up (right_iter) == citer );
BOOST_CHECK( cbm.project_left (right_iter) == left_citer );
BOOST_CHECK( cbm.project_right(right_iter) == right_citer );
BOOST_TEST( cbm.project_up (right_iter) == citer );
BOOST_TEST( cbm.project_left (right_iter) == left_citer );
BOOST_TEST( cbm.project_right(right_iter) == right_citer );
bm.project_up ( left_citer)->right = "u";
bm.project_left (right_citer)->second = "l";
@@ -111,23 +110,23 @@ void test_bimap_project()
// Support for tags
BOOST_CHECK( bm.project< left_tag>(iter) == left_iter );
BOOST_CHECK( bm.project<right_tag>(iter) == right_iter );
BOOST_TEST( bm.project< left_tag>(iter) == left_iter );
BOOST_TEST( bm.project<right_tag>(iter) == right_iter );
BOOST_CHECK( bm.project< left_tag>(left_iter) == left_iter );
BOOST_CHECK( bm.project<right_tag>(left_iter) == right_iter );
BOOST_TEST( bm.project< left_tag>(left_iter) == left_iter );
BOOST_TEST( bm.project<right_tag>(left_iter) == right_iter );
BOOST_CHECK( bm.project< left_tag>(right_iter) == left_iter );
BOOST_CHECK( bm.project<right_tag>(right_iter) == right_iter );
BOOST_TEST( bm.project< left_tag>(right_iter) == left_iter );
BOOST_TEST( bm.project<right_tag>(right_iter) == right_iter );
BOOST_CHECK( cbm.project< left_tag>(citer) == left_citer );
BOOST_CHECK( cbm.project<right_tag>(citer) == right_citer );
BOOST_TEST( cbm.project< left_tag>(citer) == left_citer );
BOOST_TEST( cbm.project<right_tag>(citer) == right_citer );
BOOST_CHECK( cbm.project< left_tag>(left_citer) == left_citer );
BOOST_CHECK( cbm.project<right_tag>(left_citer) == right_citer );
BOOST_TEST( cbm.project< left_tag>(left_citer) == left_citer );
BOOST_TEST( cbm.project<right_tag>(left_citer) == right_citer );
BOOST_CHECK( cbm.project< left_tag>(right_citer) == left_citer );
BOOST_CHECK( cbm.project<right_tag>(right_citer) == right_citer );
BOOST_TEST( cbm.project< left_tag>(right_citer) == left_citer );
BOOST_TEST( cbm.project<right_tag>(right_citer) == right_citer );
bm.project< left_tag>(right_citer)->second = "l";
bm.project<right_tag>( left_citer)->first = "r";
@@ -135,9 +134,9 @@ void test_bimap_project()
}
int test_main( int, char* [] )
int main()
{
test_bimap_project();
return 0;
return boost::report_errors();
}

11
test/test_bimap_property_map.cpp
View File

@@ -24,8 +24,7 @@
#include <cassert>
#include <algorithm>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/lightweight_test.hpp>
// Boost.Bimap
@@ -48,8 +47,8 @@ void test_readable_property_map(
// TODO Add STATIC_ASSERT(
// boost::property_traits<Map>::category is readable )
BOOST_CHECK( get(m,key) == value );
//BOOST_CHECK( m[key] == value );
BOOST_TEST( get(m,key) == value );
//BOOST_TEST( m[key] == value );
}
@@ -68,9 +67,9 @@ void test_bimap_property_map()
test_readable_property_map(b.right,0.1, 1);
}
int test_main( int, char* [] )
int main()
{
test_bimap_property_map();
return 0;
return boost::report_errors();
}

33
test/test_bimap_range.cpp
View File

@@ -17,15 +17,15 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/ignore_unused.hpp>
#include <boost/core/lightweight_test.hpp>
#include <boost/config.hpp>
#include <algorithm>
#include <boost/range/functions.hpp>
#include <boost/range/metafunctions.hpp>
#include <boost/range/const_iterator.hpp>
#include <boost/bimap/bimap.hpp>
#include <boost/bimap/multiset_of.hpp>
@@ -51,7 +51,7 @@ struct do_something_with_a_pair
template< class Pair >
void operator()(const Pair & p)
{
BOOST_CHECK( p.first && p.second );
BOOST_TEST( p.first && p.second );
}
};
@@ -80,9 +80,9 @@ int test_bimap_range()
{
bm_type::left_range_type r = bm.left.range( 2.0 < _key, _key < 4.0 );
BOOST_CHECK( ! boost::empty(r) );
BOOST_CHECK( boost::begin(r) == bm.left.upper_bound(2.0) );
BOOST_CHECK( boost::end(r) == bm.left.lower_bound(4.0) );
BOOST_TEST( ! boost::empty(r) );
BOOST_TEST( boost::begin(r) == bm.left.upper_bound(2.0) );
BOOST_TEST( boost::end(r) == bm.left.lower_bound(4.0) );
}
@@ -90,9 +90,9 @@ int test_bimap_range()
{
bm_type::right_range_type r = bm.right.range( 2 <= _key, _key <= 3 );
BOOST_CHECK( ! boost::empty(r) );
BOOST_CHECK( boost::begin(r) == bm.right.lower_bound(2) );
BOOST_CHECK( boost::end(r) == bm.right.upper_bound(3) );
BOOST_TEST( ! boost::empty(r) );
BOOST_TEST( boost::begin(r) == bm.right.lower_bound(2) );
BOOST_TEST( boost::end(r) == bm.right.upper_bound(3) );
}
@@ -101,7 +101,8 @@ int test_bimap_range()
bm_type:: left_const_range_type lr = bm. left.range( unbounded, _key < 4.0 );
bm_type::right_const_range_type rr = bm.right.range( 2 < _key , unbounded );
boost::ignore_unused(lr);
boost::ignore_unused(rr);
}
const bm_type & cbm = bm;
@@ -109,8 +110,8 @@ int test_bimap_range()
// left const range
{
bm_type:: left_const_range_type r = cbm.left.range( unbounded, unbounded );
BOOST_CHECK( ! boost::empty(r) );
BOOST_CHECK( boost::begin(r) == cbm.left.begin() );
BOOST_TEST( ! boost::empty(r) );
BOOST_TEST( boost::begin(r) == cbm.left.begin() );
}
@@ -118,7 +119,7 @@ int test_bimap_range()
{
bm_type::right_const_range_type r = cbm.right.range( 1 < _key, _key < 1 );
BOOST_CHECK( boost::empty(r) );
BOOST_TEST( boost::empty(r) );
}
@@ -126,9 +127,9 @@ int test_bimap_range()
}
//]
int test_main( int, char* [] )
int main()
{
test_bimap_range();
return 0;
return boost::report_errors();
}

27
test/test_bimap_sequenced.cpp
View File

@@ -19,8 +19,7 @@
#define BOOST_BIMAP_DISABLE_SERIALIZATION
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/lightweight_test.hpp>
// std
#include <set>
@@ -50,17 +49,17 @@ void test_list_operations(Container & b, Container& c, const Data & d)
c.clear() ;
c.assign(d.begin(),d.end());
BOOST_CHECK( std::equal( c.begin(), c.end(), d.begin() ) );
BOOST_TEST( std::equal( c.begin(), c.end(), d.begin() ) );
c.reverse();
BOOST_CHECK( std::equal( c.begin(), c.end(), d.rbegin() ) );
BOOST_TEST( std::equal( c.begin(), c.end(), d.rbegin() ) );
c.sort();
BOOST_CHECK( std::equal( c.begin(), c.end(), d.begin() ) );
BOOST_TEST( std::equal( c.begin(), c.end(), d.begin() ) );
c.push_front( *d.begin() );
BOOST_CHECK( c.size() == d.size()+1 );
BOOST_TEST( c.size() == d.size()+1 );
c.unique();
BOOST_CHECK( c.size() == d.size() );
BOOST_TEST( c.size() == d.size() );
c.relocate( c.begin(), ++c.begin() );
c.relocate( c.end(), c.begin(), ++c.begin() );
@@ -71,23 +70,23 @@ void test_list_operations(Container & b, Container& c, const Data & d)
c.assign(d.begin(),d.end());
b.splice(b.begin(),c);
BOOST_CHECK( c.size() == 0 );
BOOST_CHECK( b.size() == d.size() );
BOOST_TEST( c.size() == 0 );
BOOST_TEST( b.size() == d.size() );
c.splice(c.begin(),b,++b.begin());
BOOST_CHECK( c.size() == 1 );
BOOST_TEST( c.size() == 1 );
c.splice(c.begin(),b,b.begin(),b.end());
BOOST_CHECK( b.size() == 0 );
BOOST_TEST( b.size() == 0 );
b.assign(d.begin(),d.end());
c.assign(d.begin(),d.end());
b.sort();
c.sort();
b.merge(c);
BOOST_CHECK( b.size() == 2*d.size() );
BOOST_TEST( b.size() == 2*d.size() );
b.unique();
}
@@ -271,9 +270,9 @@ void test_bimap()
}
int test_main( int, char* [] )
int main()
{
test_bimap();
return 0;
return boost::report_errors();
}

13
test/test_bimap_serialization.cpp
View File

@@ -26,8 +26,7 @@
#include <sstream>
#include <algorithm>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/lightweight_test.hpp>
// Boost
#include <boost/archive/text_oarchive.hpp>
@@ -88,27 +87,27 @@ void test_bimap_serialization()
ia >> b;
BOOST_CHECK( std::equal( b.begin(), b.end(), data.begin() ) );
BOOST_TEST( std::equal( b.begin(), b.end(), data.begin() ) );
bm::left_const_iterator left_iter;
ia >> left_iter;
BOOST_CHECK( left_iter == b.left.begin() );
BOOST_TEST( left_iter == b.left.begin() );
bm::const_iterator iter;
ia >> iter;
BOOST_CHECK( iter == ++b.begin() );
BOOST_TEST( iter == ++b.begin() );
}
}
int test_main( int, char* [] )
int main()
{
test_bimap_serialization();
return 0;
return boost::report_errors();
}

7
test/test_bimap_set_of.cpp
View File

@@ -17,15 +17,16 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/ignore_unused.hpp>
#include <boost/bimap/set_of.hpp>
int test_main( int, char* [] )
int main()
{
typedef boost::bimaps::set_of<int> set_type;
typedef boost::bimaps::set_of_relation<> set_type_of_relation;
boost::ignore_unused<set_type>();
boost::ignore_unused<set_type_of_relation>();
return 0;
}

19
test/test_bimap_unconstrained.cpp
View File

@@ -17,8 +17,7 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/lightweight_test.hpp>
// Boost.Bimap
#include <boost/bimap/support/lambda.hpp>
@@ -40,21 +39,21 @@ void test_bimap_unconstrained()
typedef bimap<int,unconstrained_set_of<double> > bm;
bm b;
b.insert( bm::value_type(2,34.4) );
BOOST_CHECK( b.size() == 1 );
BOOST_TEST( b.size() == 1 );
}
{
typedef bimap<unconstrained_set_of<int>, double > bm;
bm b;
b.right[2.4] = 34;
BOOST_CHECK( b.right.size() == 1 );
BOOST_TEST( b.right.size() == 1 );
}
{
typedef bimap<unconstrained_set_of<int>, double, right_based > bm;
bm b;
b.right[2.4] = 34;
BOOST_CHECK( b.right.size() == 1 );
BOOST_TEST( b.right.size() == 1 );
}
{
@@ -68,7 +67,7 @@ void test_bimap_unconstrained()
bm b;
b.left[2] = 34.4;
BOOST_CHECK( b.left.size() == 1 );
BOOST_TEST( b.left.size() == 1 );
}
{
@@ -82,7 +81,7 @@ void test_bimap_unconstrained()
bm b;
b.right[2.4] = 34;
BOOST_CHECK( b.right.size() == 1 );
BOOST_TEST( b.right.size() == 1 );
}
{
@@ -96,14 +95,14 @@ void test_bimap_unconstrained()
bm b;
b.insert( bm::value_type(1,2.3) );
BOOST_CHECK( b.size() == 1 );
BOOST_TEST( b.size() == 1 );
}
}
int test_main( int, char* [] )
int main()
{
test_bimap_unconstrained();
return 0;
return boost::report_errors();
}

7
test/test_bimap_unordered.cpp
View File

@@ -19,8 +19,7 @@
#define BOOST_BIMAP_DISABLE_SERIALIZATION
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/lightweight_test.hpp>
// std
#include <set>
@@ -159,9 +158,9 @@ void test_bimap()
}
int test_main( int, char* [] )
int main()
{
test_bimap();
return 0;
return boost::report_errors();
}

8
test/test_bimap_unordered_multiset_of.cpp
View File

@@ -17,18 +17,20 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/ignore_unused.hpp>
#include <boost/bimap/unordered_multiset_of.hpp>
int test_main( int, char* [] )
int main()
{
typedef boost::bimaps::unordered_multiset_of<int> set_type;
typedef boost::bimaps::
unordered_multiset_of_relation<> set_type_of_relation;
boost::ignore_unused<set_type>();
boost::ignore_unused<set_type_of_relation>();
return 0;
}

7
test/test_bimap_unordered_set_of.cpp
View File

@@ -17,15 +17,16 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/ignore_unused.hpp>
#include <boost/bimap/unordered_set_of.hpp>
int test_main( int, char* [] )
int main()
{
typedef boost::bimaps::unordered_set_of<int> set_type;
typedef boost::bimaps::unordered_set_of_relation<> set_type_of_relation;
boost::ignore_unused<set_type>();
boost::ignore_unused<set_type_of_relation>();
return 0;
}

7
test/test_bimap_vector_of.cpp
View File

@@ -17,15 +17,16 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/ignore_unused.hpp>
#include <boost/bimap/vector_of.hpp>
int test_main( int, char* [] )
int main()
{
typedef boost::bimaps::vector_of<int> set_type;
typedef boost::bimaps::vector_of_relation set_type_of_relation;
boost::ignore_unused<set_type>();
boost::ignore_unused<set_type_of_relation>();
return 0;
}

25
test/test_mutant.cpp
View File

@@ -17,8 +17,7 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/lightweight_test.hpp>
// Boost.MPL
#include <boost/mpl/list.hpp>
@@ -77,27 +76,27 @@ void test_mutant_basic()
{
MutantData m(value_a,value_b);
BOOST_CHECK( sizeof( MutantData ) == sizeof( StdPairView ) );
BOOST_TEST( sizeof( MutantData ) == sizeof( StdPairView ) );
BOOST_CHECK( mutate<StdPairView>(m).first == value_a );
BOOST_CHECK( mutate<StdPairView>(m).second == value_b );
BOOST_CHECK( mutate<ReverseStdPairView>(m).first == value_b );
BOOST_CHECK( mutate<ReverseStdPairView>(m).second == value_a );
BOOST_TEST( mutate<StdPairView>(m).first == value_a );
BOOST_TEST( mutate<StdPairView>(m).second == value_b );
BOOST_TEST( mutate<ReverseStdPairView>(m).first == value_b );
BOOST_TEST( mutate<ReverseStdPairView>(m).second == value_a );
ReverseStdPairView & rpair = mutate<ReverseStdPairView>(m);
rpair.first = value_b;
rpair.second = value_a;
BOOST_CHECK( mutate<StdPairView>(m).first == value_a );
BOOST_CHECK( mutate<StdPairView>(m).second == value_b );
BOOST_TEST( mutate<StdPairView>(m).first == value_a );
BOOST_TEST( mutate<StdPairView>(m).second == value_b );
BOOST_CHECK( &mutate<StdPairView>(m).first == &m.a );
BOOST_CHECK( &mutate<StdPairView>(m).second == &m.b );
BOOST_TEST( &mutate<StdPairView>(m).first == &m.a );
BOOST_TEST( &mutate<StdPairView>(m).second == &m.b );
}
}
int test_main( int, char* [] )
int main()
{
test_mutant_basic();
return 0;
return boost::report_errors();
}

7
test/test_mutant_relation.cpp
View File

@@ -20,8 +20,7 @@
// std
#include <string>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/lightweight_test.hpp>
// Boost.MPL
#include <boost/mpl/assert.hpp>
@@ -224,7 +223,7 @@ void test_mutant_relation()
test_relation<mutant_relation_builder, cc4, cc5>(0,0);
}
int test_main( int, char* [] )
int main()
{
// Test metadata correctness with untagged relation version
@@ -236,6 +235,6 @@ int test_main( int, char* [] )
// Test basic
test_mutant_relation();
return 0;
return boost::report_errors();
}

61
test/test_relation.hpp
View File

@@ -15,8 +15,7 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/lightweight_test.hpp>
// Boost.MPL
#include <boost/mpl/assert.hpp>
@@ -49,28 +48,28 @@ void test_relation_with_default_tags(Relation & rel,
// It must work with normal tags
BOOST_CHECK( pair_by<member_at::left >(rel).first == lv );
BOOST_CHECK( pair_by<member_at::left >(rel).second == rv );
BOOST_TEST( pair_by<member_at::left >(rel).first == lv );
BOOST_TEST( pair_by<member_at::left >(rel).second == rv );
BOOST_CHECK( pair_by<member_at::right>(rel).first == rv );
BOOST_CHECK( pair_by<member_at::right>(rel).second == lv );
BOOST_TEST( pair_by<member_at::right>(rel).first == rv );
BOOST_TEST( pair_by<member_at::right>(rel).second == lv );
BOOST_CHECK( get<member_at::left >(rel) == rel.left );
BOOST_CHECK( get<member_at::right>(rel) == rel.right );
BOOST_TEST( get<member_at::left >(rel) == rel.left );
BOOST_TEST( get<member_at::right>(rel) == rel.right );
BOOST_CHECK(
BOOST_TEST(
get<member_at::left >(pair_by<member_at::left >(rel)) == rel.left
);
BOOST_CHECK(
BOOST_TEST(
get<member_at::right>(pair_by<member_at::left >(rel)) == rel.right
);
BOOST_CHECK(
BOOST_TEST(
get<member_at::left >(pair_by<member_at::right>(rel)) == rel.left
);
BOOST_CHECK(
BOOST_TEST(
get<member_at::right>(pair_by<member_at::right>(rel)) == rel.right
);
@@ -88,31 +87,31 @@ void test_relation_with_user_tags(Relation & rel,
// And with users ones
BOOST_CHECK( pair_by<LeftTag >(rel).first == lv );
BOOST_CHECK( pair_by<LeftTag >(rel).second == rv );
BOOST_TEST( pair_by<LeftTag >(rel).first == lv );
BOOST_TEST( pair_by<LeftTag >(rel).second == rv );
BOOST_CHECK( pair_by<RightTag>(rel).first == rv );
BOOST_CHECK( pair_by<RightTag>(rel).second == lv );
BOOST_TEST( pair_by<RightTag>(rel).first == rv );
BOOST_TEST( pair_by<RightTag>(rel).second == lv );
BOOST_CHECK( get<LeftTag >(rel) == rel.left );
BOOST_CHECK( get<RightTag>(rel) == rel.right );
BOOST_TEST( get<LeftTag >(rel) == rel.left );
BOOST_TEST( get<RightTag>(rel) == rel.right );
BOOST_CHECK( get<LeftTag >(pair_by<LeftTag >(rel)) == rel.left );
BOOST_CHECK( get<RightTag>(pair_by<LeftTag >(rel)) == rel.right );
BOOST_TEST( get<LeftTag >(pair_by<LeftTag >(rel)) == rel.left );
BOOST_TEST( get<RightTag>(pair_by<LeftTag >(rel)) == rel.right );
BOOST_CHECK( get<LeftTag >(pair_by<RightTag>(rel)) == rel.left );
BOOST_CHECK( get<RightTag>(pair_by<RightTag>(rel)) == rel.right );
BOOST_TEST( get<LeftTag >(pair_by<RightTag>(rel)) == rel.left );
BOOST_TEST( get<RightTag>(pair_by<RightTag>(rel)) == rel.right );
//----------------------------------------------------------------
BOOST_CHECK( rel.template get<LeftTag >() == rel.left );
BOOST_CHECK( rel.template get<RightTag>() == rel.right );
BOOST_TEST( rel.template get<LeftTag >() == rel.left );
BOOST_TEST( rel.template get<RightTag>() == rel.right );
BOOST_CHECK( pair_by<LeftTag >(rel).template get<LeftTag >()== rel.left );
BOOST_CHECK( pair_by<LeftTag >(rel).template get<RightTag>()== rel.right);
BOOST_TEST( pair_by<LeftTag >(rel).template get<LeftTag >()== rel.left );
BOOST_TEST( pair_by<LeftTag >(rel).template get<RightTag>()== rel.right);
BOOST_CHECK( pair_by<RightTag>(rel).template get<LeftTag >()== rel.left );
BOOST_CHECK( pair_by<RightTag>(rel).template get<RightTag>()== rel.right);
BOOST_TEST( pair_by<RightTag>(rel).template get<LeftTag >()== rel.left );
BOOST_TEST( pair_by<RightTag>(rel).template get<RightTag>()== rel.right);
}
struct left_user_tag {};
@@ -175,14 +174,14 @@ void test_relation(const LeftData & lv, const RightData & rv)
rel_type rel_from_left ( left_pair(lv,rv) );
rel_type rel_from_right( right_pair(rv,lv) );
BOOST_CHECK( rel_from_left == rel_from_right );
BOOST_CHECK( rel_from_left == rel_type(lv,rv) );
BOOST_TEST( rel_from_left == rel_from_right );
BOOST_TEST( rel_from_left == rel_type(lv,rv) );
rel_type rel;
rel = rel_from_left;
BOOST_CHECK( rel == rel_from_left );
BOOST_TEST( rel == rel_from_left );
*/
}

11
test/test_structured_pair.cpp
View File

@@ -17,8 +17,7 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/lightweight_test.hpp>
// std
#include <utility>
@@ -78,13 +77,13 @@ void test_basic()
pair_type pa( 2, 3.1416 );
mirror_type pb( 3.1416, 2 );
BOOST_CHECK( pa.first == pb.second );
BOOST_CHECK( pa.second == pb.first );
BOOST_TEST( pa.first == pb.second );
BOOST_TEST( pa.second == pb.first );
}
int test_main( int, char* [] )
int main()
{
BOOST_BIMAP_CALL_TEST_STATIC_FUNCTION( static_are_storage_compatible_test );
@@ -93,6 +92,6 @@ int test_main( int, char* [] )
test_basic();
return 0;
return boost::report_errors();
}

25
test/test_tagged.cpp
View File

@@ -17,8 +17,7 @@
#include <boost/config.hpp>
// Boost.Test
#include <boost/test/minimal.hpp>
#include <boost/core/lightweight_test.hpp>
#include <boost/static_assert.hpp>
@@ -75,34 +74,34 @@ void test_function()
typedef tagged< data, tag_a > data_a;
typedef tagged< data, tag_b > data_b;
BOOST_CHECK(( is_same< data_a::value_type , data >::value ));
BOOST_CHECK(( is_same< data_a::tag , tag_a >::value ));
BOOST_TEST(( is_same< data_a::value_type , data >::value ));
BOOST_TEST(( is_same< data_a::tag , tag_a >::value ));
BOOST_CHECK((
BOOST_TEST((
is_same< overwrite_tagged < data_a, tag_b >::type, data_b >::value
));
BOOST_CHECK((
BOOST_TEST((
is_same< default_tagged < data_a, tag_b >::type, data_a >::value
));
BOOST_CHECK((
BOOST_TEST((
is_same< default_tagged < data , tag_b >::type, data_b >::value
));
BOOST_CHECK(( is_tagged< data >::value == false ));
BOOST_CHECK(( is_tagged< data_a >::value == true ));
BOOST_TEST(( is_tagged< data >::value == false ));
BOOST_TEST(( is_tagged< data_a >::value == true ));
BOOST_CHECK(( is_same< value_type_of<data_a>::type, data >::value ));
BOOST_CHECK(( is_same< tag_of <data_a>::type, tag_a >::value ));
BOOST_TEST(( is_same< value_type_of<data_a>::type, data >::value ));
BOOST_TEST(( is_same< tag_of <data_a>::type, tag_a >::value ));
}
int test_main( int, char* [] )
int main()
{
test_function();
// Test metanfunctions
BOOST_BIMAP_CALL_TEST_STATIC_FUNCTION( test_metafunctions );
return 0;
return boost::report_errors();
}