int main()
{
{
typedef double T;
typedef std::array<T, 3> C;
C c = {1, 2, 3.5};
C::reference r1 = c.at(0);
assert(r1 == 1);
r1 = 5.5;
assert(c.front() == 5.5);
C::reference r2 = c.at(2);
assert(r2 == 3.5);
r2 = 7.5;
assert(c.back() == 7.5);
try { (void) c.at(3); }
catch (const std::out_of_range &) {}
}
{
typedef double T;
typedef std::array<T, 3> C;
const C c = {1, 2, 3.5};
C::const_reference r1 = c.at(0);
assert(r1 == 1);
C::const_reference r2 = c.at(2);
assert(r2 == 3.5);
try { (void) c.at(3); }
catch (const std::out_of_range &) {}
}
#if TEST_STD_VER > 11
{
typedef double T;
typedef std::array<T, 3> C;
constexpr C c = {1, 2, 3.5};
constexpr T t1 = c.at(0);
static_assert (t1 == 1, "");
constexpr T t2 = c.at(2);
static_assert (t2 == 3.5, "");
}
#endif
}
int main()
{
{
typedef std::unordered_map<int, std::string> C;
typedef std::pair<int, std::string> P;
P a[] =
{
P(1, "one"),
P(2, "two"),
P(3, "three"),
P(4, "four"),
P(1, "four"),
P(2, "four"),
};
C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.size() == 4);
c.at(1) = "ONE";
assert(c.at(1) == "ONE");
#ifndef TEST_HAS_NO_EXCEPTIONS
try
{
c.at(11) = "eleven";
assert(false);
}
catch (std::out_of_range&)
{
}
assert(c.size() == 4);
#endif
}
{
typedef std::unordered_map<int, std::string> C;
typedef std::pair<int, std::string> P;
P a[] =
{
P(1, "one"),
P(2, "two"),
P(3, "three"),
P(4, "four"),
P(1, "four"),
P(2, "four"),
};
const C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.size() == 4);
assert(c.at(1) == "one");
#ifndef TEST_HAS_NO_EXCEPTIONS
try
{
c.at(11);
assert(false);
}
catch (std::out_of_range&)
{
}
assert(c.size() == 4);
#endif
}
#if TEST_STD_VER >= 11
{
typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C;
typedef std::pair<int, std::string> P;
P a[] =
{
P(1, "one"),
P(2, "two"),
P(3, "three"),
P(4, "four"),
P(1, "four"),
P(2, "four"),
};
C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.size() == 4);
c.at(1) = "ONE";
assert(c.at(1) == "ONE");
#ifndef TEST_HAS_NO_EXCEPTIONS
try
{
c.at(11) = "eleven";
assert(false);
}
catch (std::out_of_range&)
{
}
assert(c.size() == 4);
#endif
}
{
typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C;
typedef std::pair<int, std::string> P;
P a[] =
{
P(1, "one"),
P(2, "two"),
P(3, "three"),
P(4, "four"),
P(1, "four"),
P(2, "four"),
};
const C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.size() == 4);
assert(c.at(1) == "one");
#ifndef TEST_HAS_NO_EXCEPTIONS
try
{
c.at(11);
assert(false);
}
catch (std::out_of_range&)
{
}
assert(c.size() == 4);
#endif
}
#endif
}
void ptr_map_test()
{
using namespace boost;
BOOST_TEST_MESSAGE( "starting associative container test" );
enum { max_cnt = 10, size = 100 };
C c;
BOOST_CHECK( c.size() == 0 );
const C c2( c.begin(), c.end() );
BOOST_CHECK( c.size() == c2.size() );
C c3;
BOOST_TEST_MESSAGE( "finished construction test" );
BOOST_DEDUCED_TYPENAME C::allocator_type alloc = c.get_allocator();
BOOST_DEDUCED_TYPENAME C::iterator i = c.begin();
BOOST_DEDUCED_TYPENAME C::const_iterator ci = c2.begin();
BOOST_DEDUCED_TYPENAME C::iterator i2 = c.end();
hide_warning(i2);
BOOST_DEDUCED_TYPENAME C::const_iterator ci2 = c2.begin();
hide_warning(ci2);
ci = c.cbegin();
ci = c.cend();
BOOST_DEDUCED_TYPENAME C::key_type a_key;
BOOST_TEST_MESSAGE( "finished iterator test" );
BOOST_DEDUCED_TYPENAME C::size_type s = c.size();
BOOST_DEDUCED_TYPENAME C::size_type s2 = c.max_size();
hide_warning(s2);
BOOST_CHECK_EQUAL( c.size(), s );
bool b = c.empty();
hide_warning(b);
BOOST_TEST_MESSAGE( "finished accessors test" );
a_key = get_next_key( a_key );
c.insert( a_key, new T );
a_key = get_next_key( a_key );
c.insert( a_key, new T );
c3.insert( c.begin(), c.end() );
c.insert( c3 );
c.erase( c.begin() );
BOOST_CHECK( c3.end() == c3.erase( boost::make_iterator_range(c3) ) );
c3.erase( a_key );
BOOST_CHECK( c3.empty() );
c.swap( c3 );
swap(c,c3);
swap(c3,c);
BOOST_CHECK( !c3.empty() );
c3.clear();
BOOST_CHECK( c3.empty() );
BOOST_TEST_MESSAGE( "finished modifiers test" );
a_key = get_next_key( a_key );
c.insert( a_key, new T );
a_key = get_next_key( a_key );
#ifndef BOOST_NO_AUTO_PTR
c.insert( a_key, std::auto_ptr<T>( new T ) );
#endif
#ifndef BOOST_NO_CXX11_SMART_PTR
c.insert( a_key, std::unique_ptr<T>( new T ) );
#endif
typename C::auto_type ptr2 = c.release( c.begin() );
#ifndef BOOST_NO_AUTO_PTR
std::auto_ptr<C> ap = c.release();
#else
std::unique_ptr<C> up = c.release();
#endif
c = c2.clone();
BOOST_TEST_MESSAGE( "finished release/clone test" );
a_key = get_next_key( a_key );
c3.insert( a_key, new T );
a_key = get_next_key( a_key );
c3.insert( a_key, new T );
c. BOOST_NESTED_TEMPLATE transfer<C>( c3.begin(), c3 );
c. BOOST_NESTED_TEMPLATE transfer<C>( c3.begin(), c3.end(), c3 );
BOOST_CHECK( c3.empty() );
BOOST_CHECK( !c.empty() );
c3. BOOST_NESTED_TEMPLATE transfer<C>( c );
BOOST_CHECK( !c3.empty() );
BOOST_CHECK( c.empty() );
#ifdef BOOST_NO_SFINAE
#else
c. BOOST_NESTED_TEMPLATE transfer<C>( make_iterator_range(c3), c3 );
BOOST_CHECK( !c.empty() );
BOOST_CHECK( c3.empty() );
c3. BOOST_NESTED_TEMPLATE transfer<C>(c);
#endif
BOOST_TEST_MESSAGE( "finished transfer test" );
BOOST_CHECK( !c3.empty() );
c3.replace( c3.begin(), new T );
#ifndef BOOST_NO_AUTO_PTR
c3.replace( c3.begin(), std::auto_ptr<T>( new T ) );
#endif
#ifndef BOOST_NO_CXX11_SMART_PTR
c3.replace( c3.begin(), std::unique_ptr<T>( new T ) );
#endif
BOOST_TEST_MESSAGE( "finished set/map interface test" );
// @todo: make macro with algorithms so that the right erase() is called.
// c.unique();
// c.unique( std::not_equal_to<T>() );
// c.remove( T() );
// c.remove_if( std::binder1st< std::equal_to<T> >( T() ) );
sub_range<C> sub;
sub_range<const C> csub;
i = c.find( get_next_key( a_key ) );
ci = c2.find( get_next_key( a_key ) );
c2.count( get_next_key( a_key ) );
sub = c.equal_range( get_next_key( a_key ) );
csub = c2.equal_range( get_next_key( a_key ) );
try
{
c.at( get_next_key( a_key ) );
}
catch( const bad_ptr_container_operation& )
{ }
try
{
c2.at( get_next_key( a_key ) );
}
catch( const bad_ptr_container_operation& )
{ }
BOOST_TEST_MESSAGE( "finished algorithms interface test" );
typename C::iterator it = c.begin(), e = c.end();
for( ; it != e; ++it )
{
std::cout << "\n mapped value = " << *it->second << " key = " << it->first;
//std::cout << "\n mapped value = " << it.value() << " key = " << it.key();
}
BOOST_TEST_MESSAGE( "finished iterator test" );
a_key = get_next_key( a_key );
c.insert( a_key, new T );
c.erase( a_key );
c.erase( a_key );
}
