townforge/phoenix
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
cc
phoenix/test/container/container_tests.hpp
Kohei Takahashi 5d8a6b4c42 Added tests for unordered containers.
2017-05-16 00:15:12 +09:00

948 lines
27 KiB
C++
Raw Permalink Blame History

/*=============================================================================
Copyright (c) 2004 Angus Leeming
Copyright (c) 2017 Kohei Takahashi
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(CONTAINER_TESTS_HPP)
#define CONTAINER_TESTS_HPP
#include <boost/detail/lightweight_test.hpp>
#include <boost/phoenix/core.hpp>
#include <boost/phoenix/stl/container/container.hpp>
#include <iostream>
#include <typeinfo>
#include <deque>
#include <list>
#include <map>
#include <set>
#include <vector>
#include <utility>
#ifndef BOOST_NO_CXX11_HDR_UNORDERED_MAP
#include <unordered_map>
#endif
#ifndef BOOST_NO_CXX11_HDR_UNORDERED_SET
#include <unordered_set>
#endif
#ifdef BOOST_MSVC
#pragma warning(disable : 4800)
#endif
using std::cerr;
namespace phx = boost::phoenix;
template <typename T> inline T const build_assoc();
std::deque<int> const build_deque();
std::list<int> const build_list();
std::map<int, int> const build_map();
std::multimap<int, int> const build_multimap();
std::vector<int> const build_vector();
std::set<int> const build_set();
std::multiset<int> const build_multiset();
template <> inline std::map<int, int> const build_assoc() { return build_map(); }
template <> inline std::multimap<int, int> const build_assoc() { return build_multimap(); }
template <> inline std::set<int> const build_assoc() { return build_set(); }
template <> inline std::multiset<int> const build_assoc() { return build_multiset(); }
#ifndef BOOST_NO_CXX11_HDR_UNORDERED_MAP
std::unordered_map<int, int> const build_unordered_map();
std::unordered_multimap<int, int> const build_unordered_multimap();
template <> inline std::unordered_map<int, int> const build_assoc() { return build_unordered_map(); }
template <> inline std::unordered_multimap<int, int> const build_assoc() { return build_unordered_multimap(); }
#endif
#ifndef BOOST_NO_CXX11_HDR_UNORDERED_SET
std::unordered_set<int> const build_unordered_set();
std::unordered_multiset<int> const build_unordered_multiset();
template <> inline std::unordered_set<int> const build_assoc() { return build_unordered_set(); }
template <> inline std::unordered_multiset<int> const build_assoc() { return build_unordered_multiset(); }
#endif
inline bool
test(bool fail)
{
BOOST_TEST(!fail);
return fail;
}
template <typename Container>
void test_assign(Container c)
{
using phx::arg_names::arg1;
typename Container::size_type count = 2;
typename Container::const_iterator first = c.begin();
typename Container::const_iterator second = first;
typename Container::value_type value = *first;
phx::assign(arg1, count, value)(c);
// iterators may be invalidated!
first = c.begin();
second = first;
std::advance(second, 1);
if (test(*first != *second)) {
cerr << "Failed " << typeid(Container).name() << " test_assign 1\n";
return;
}
#if defined(BOOST_PHOENIX_COMPILE_FAIL_TEST)
// Should not --- does not, Yay! --- compile.
Container const const_c = c;
phx::assign(const_c, count, value);
#endif
}
template <typename Container>
void test_assign2(Container c)
{
using phx::arg_names::arg1;
using phx::arg_names::arg2;
using phx::arg_names::arg3;
Container c2 = c;
typename Container::const_iterator first = c2.begin();
typename Container::const_iterator last = c2.end();
typename Container::size_type size = c2.size();
c.clear();
phx::assign(arg1, arg2, arg3)(c, first, last);
if (test(c.size() != size)) {
cerr << "Failed " << typeid(Container).name()
<< " test_assign2 1\n"
<< "size == " << c.size() << '\n';
return;
}
#if defined(BOOST_PHOENIX_COMPILE_FAIL_TEST)
// Should not --- does not, Yay! --- compile.
Container const const_c = c;
phx::assign(const_c, first, second);
#endif
}
template <typename Container>
void test_at(Container c)
{
using phx::arg_names::arg1;
using phx::at;
typename Container::reference r1 = at(arg1, 0)(c);
if (test(r1 != c.at(0))) {
cerr << "Failed " << typeid(Container).name() << " test_at 1\n";
return;
}
typename Container::const_reference r2 = at(arg1, 0)(c);
if (test(r2 != c.at(0))) {
cerr << "Failed " << typeid(Container).name() << " test_at 2\n";
return;
}
Container const const_c = c;
#if defined(BOOST_PHOENIX_COMPILE_FAIL_TEST)
// Should not --- does not, Yay! --- compile.
typename Container::reference r3 = at(arg1, 0)(const_c);
#endif
typename Container::const_reference r4 = at(arg1, 0)(const_c);
if (test(r4 != c.at(0))) {
cerr << "Failed " << typeid(Container).name() << " test_at 4\n";
return;
}
}
template <typename Container>
void test_back(Container c)
{
using phx::arg_names::arg1;
using phx::back;
typename Container::reference r1 = back(arg1)(c);
if (test(r1 != c.back())) {
cerr << "Failed " << typeid(Container).name() << " test_back 1\n";
return;
}
typename Container::const_reference r2 = back(arg1)(c);
if (test(r2 != c.back())) {
cerr << "Failed " << typeid(Container).name() << " test_back 2\n";
return;
}
Container const const_c = c;
#if defined(BOOST_PHOENIX_COMPILE_FAIL_TEST)
// Should not --- does not, Yay! --- compile.
typename Container::reference r3 = back(arg1)(const_c);
#endif
typename Container::const_reference r4 = back(arg1)(const_c);
if (test(r4 != c.back())) {
cerr << "Failed " << typeid(Container).name() << " test_back 4\n";
return;
}
}
template <typename Container>
void test_begin(Container c)
{
using phx::arg_names::arg1;
using phx::begin;
typename Container::iterator it1 = begin(arg1)(c);
if (test(it1 != c.begin())) {
cerr << "Failed " << typeid(Container).name() << " test_begin 1\n";
return;
}
typename Container::const_iterator it2 = begin(arg1)(c);
if (test(it2 != c.begin())) {
cerr << "Failed " << typeid(Container).name() << " test_begin 2\n";
return;
}
Container const const_c = c;
#if defined(BOOST_PHOENIX_COMPILE_FAIL_TEST)
// Should not --- does not, Yay! --- compile.
typename Container::iterator it3 = begin(arg1)(const_c);
#endif
typename Container::const_iterator it4 = begin(arg1)(const_c);
if (test(it4 != const_c.begin())) {
cerr << "Failed " << typeid(Container).name() << " test_begin 4\n";
return;
}
}
template <typename Container>
void test_capacity(Container c)
{
using phx::arg_names::arg1;
using phx::capacity;
typename Container::size_type s1 = capacity(arg1)(c);
if (test(s1 != c.capacity())) {
cerr << "Failed " << typeid(Container).name() << " test_capacity 1\n";
return;
}
Container const const_c = c;
typename Container::size_type s2 = capacity(arg1)(const_c);
if (test(s2 != const_c.capacity())) {
cerr << "Failed " << typeid(Container).name() << " test_capacity 2\n";
return;
}
}
template <typename Container>
void test_clear(Container c)
{
using phx::arg_names::arg1;
using phx::clear;
clear(arg1)(c);
if (test(!c.empty())) {
cerr << "Failed " << typeid(Container).name() << " test_clear 1\n";
return;
}
#if defined(BOOST_PHOENIX_COMPILE_FAIL_TEST)
Container const const_c = c;
clear(arg1)(const_c);
#endif
}
template <typename Container>
void test_empty(Container c)
{
using phx::arg_names::arg1;
using phx::empty;
typename Container::size_type s1 = empty(arg1)(c);
if (test(bool(s1) != c.empty())) {
cerr << "Failed " << typeid(Container).name() << " test_empty 1\n";
return;
}
Container const const_c = c;
typename Container::size_type s2 = empty(arg1)(const_c);
if (test(bool(s2) != const_c.empty())) {
cerr << "Failed " << typeid(Container).name() << " test_empty 2\n";
return;
}
}
template <typename Container>
void test_end(Container c)
{
using phx::arg_names::arg1;
using phx::end;
typename Container::iterator it1 = end(arg1)(c);
if (test(it1 != c.end())) {
cerr << "Failed " << typeid(Container).name() << " test_end 1\n";
return;
}
typename Container::const_iterator it2 = end(arg1)(c);
if (test(it2 != c.end())) {
cerr << "Failed " << typeid(Container).name() << " test_end 2\n";
return;
}
Container const const_c = c;
#if defined(BOOST_PHOENIX_COMPILE_FAIL_TEST)
// Should not --- does not, Yay! --- compile.
typename Container::iterator it3 = end(arg1)(const_c);
#endif
typename Container::const_iterator it4 = end(arg1)(const_c);
if (test(it4 != const_c.end())) {
cerr << "Failed " << typeid(Container).name() << " test_end 4\n";
return;
}
}
template <typename Container>
void test_erase(Container c)
{
using phx::arg_names::arg1;
using phx::arg_names::arg2;
using phx::arg_names::arg3;
using phx::erase;
Container const const_c = c;
typename Container::size_type size = c.size();
typename Container::iterator c_begin = c.begin();
erase(arg1, arg2)(c, c_begin);
if (test(c.size() + 1 != size)) {
cerr << "Failed " << typeid(Container).name() << " test_erase 1\n";
return;
}
c_begin = c.begin();
typename Container::iterator c_end = c.end();
erase(arg1, arg2, arg3)(c, c_begin, c_end);
if (test(!c.empty())) {
cerr << "Failed " << typeid(Container).name() << " test_erase 2\n";
return;
}
#if defined(BOOST_PHOENIX_COMPILE_FAIL_TEST)
erase(arg1, const_c.begin())(const_c);
erase(arg1, const_c.begin(), const_c.end())(const_c);
#endif
}
template <typename Container>
void test_map_erase(Container c)
{
test_erase(c);
if (boost::report_errors() != 0)
return;
using phx::arg_names::arg1;
using phx::arg_names::arg2;
using phx::erase;
typename Container::value_type const value = *c.begin();
typename Container::key_type const key = value.first;
typename Container::size_type const removed =
erase(arg1, arg2)(c, key);
if (test(removed != 1)) {
cerr << "Failed " << typeid(Container).name() << " test_map_erase 1\n";
return;
}
}
template <typename Container>
void test_set_erase(Container c)
{
test_erase(c);
if (boost::report_errors() != 0)
return;
using phx::arg_names::arg1;
using phx::arg_names::arg2;
using phx::erase;
typename Container::value_type const value = *c.begin();
typename Container::key_type const key = value;
typename Container::size_type const removed =
erase(arg1, arg2)(c, key);
if (test(removed != 1)) {
cerr << "Failed " << typeid(Container).name() << " test_set_erase 1\n";
return;
}
}
template <typename Container>
void test_front(Container c)
{
using phx::arg_names::arg1;
using phx::front;
typename Container::reference r1 = front(arg1)(c);
if (test(r1 != c.front())) {
cerr << "Failed " << typeid(Container).name() << " test_front 1\n";
return;
}
typename Container::const_reference r2 = front(arg1)(c);
if (test(r2 != c.front())) {
cerr << "Failed " << typeid(Container).name() << " test_front 2\n";
return;
}
Container const const_c = c;
#if defined(BOOST_PHOENIX_COMPILE_FAIL_TEST)
// Should not --- does not, Yay! --- compile.
typename Container::reference r3 = front(arg1)(const_c);
#endif
typename Container::const_reference r4 = front(arg1)(const_c);
if (test(r4 != c.front())) {
cerr << "Failed " << typeid(Container).name() << " test_front 4\n";
return;
}
}
template <typename Container>
void test_get_allocator(Container c)
{
using phx::arg_names::arg1;
using phx::get_allocator;
Container const const_c = c;
typename Container::allocator_type a1 = get_allocator(arg1)(c);
if (test(a1 != c.get_allocator())) {
cerr << "Failed " << typeid(Container).name() << " test_get_allocator 1\n";
return;
}
typename Container::allocator_type a2 = get_allocator(arg1)(const_c);
if (test(a2 != const_c.get_allocator())) {
cerr << "Failed " << typeid(Container).name() << " test_get_allocator 2\n";
return;
}
}
template <typename Container>
void test_insert(Container c)
{
using phx::arg_names::arg1;
using phx::insert;
typename Container::value_type const value = *c.begin();
typename Container::iterator it = insert(arg1, c.begin(), value)(c);
if (test(it != c.begin() || *it != *(++it))) {
cerr << "Failed " << typeid(Container).name() << " test_insert 1\n";
return;
}
typename Container::size_type size = c.size();
insert(arg1, c.begin(), 3, value)(c);
if (test(c.size() != size + 3)) {
cerr << "Failed " << typeid(Container).name() << " test_insert 2\n";
return;
}
Container const const_c = c;
size = c.size();
insert(arg1, c.begin(), const_c.begin(), const_c.end())(c);
if (test(c.size() != 2 * size)) {
cerr << "Failed " << typeid(Container).name() << " test_insert 3\n";
return;
}
}
template <typename Map>
inline void test_map_insert(Map c)
{
using phx::arg_names::arg1;
using phx::arg_names::arg2;
using phx::arg_names::arg3;
typename Map::value_type const value = *c.begin();
typename Map::iterator c_begin = c.begin();
// wrapper for
// iterator insert(iterator where, const value_type& val);
typename Map::iterator it =
phx::insert(arg1, arg2, arg3)(c, c_begin, value);
if (test(it != c.begin() /*|| *it != *(++it)*/)) {
cerr << "Failed " << typeid(Map).name() << " test_map_insert 1\n";
return;
}
// wrapper for
// pair<iterator, bool> insert(const value_type& val);
typename Map::value_type const value2(1400, 2200);
std::pair<typename Map::iterator, bool> result =
phx::insert(arg1, arg2)(c, value2);
if (test(!result.second)) {
cerr << "Failed " << typeid(Map).name() << " test_map_insert 2\n";
return;
}
// wrapper for
// template<class InIt>
// void insert(InIt first, InIt last);
Map const const_c = build_assoc<Map>();
typename Map::size_type size = c.size();
phx::insert(arg1, const_c.begin(), const_c.end())(c);
if (test(c.size() != size + const_c.size())) {
cerr << "Failed " << typeid(Map).name() << " test_map_insert 3\n";
return;
}
}
template <typename Multimap>
inline void test_multimap_insert(Multimap c)
{
using phx::arg_names::arg1;
using phx::arg_names::arg2;
using phx::arg_names::arg3;
typename Multimap::value_type const value = *c.begin();
typename Multimap::iterator c_begin = c.begin();
std::size_t old_size = c.size();
// wrapper for
// iterator insert(iterator where, const value_type& val);
typename Multimap::iterator it =
phx::insert(arg1, arg2, arg3)(c, c_begin, value);
if (test(*it != value || c.size() != old_size + 1)) {
cerr << "Failed " << typeid(Multimap).name()
<< " test_multimap_insert 1\n";
return;
}
// wrapper for
// iterator insert(const value_type& val);
typename Multimap::value_type const value2(1400, 2200);
it = phx::insert(arg1, arg2)(c, value2);
if (test(it == c.end())) {
cerr << "Failed " << typeid(Multimap).name()
<< " test_multimap_insert 2\n";
return;
}
// wrapper for
// template<class InIt>
// void insert(InIt first, InIt last);
Multimap const const_c = build_assoc<Multimap>();
typename Multimap::size_type size = c.size();
phx::insert(arg1, const_c.begin(), const_c.end())(c);
if (test(c.size() != size + const_c.size())) {
cerr << "Failed " << typeid(Multimap).name()
<< " test_multimap_insert 3\n";
return;
}
}
template <typename Set>
inline void test_set_insert(Set c)
{
using phx::arg_names::arg1;
using phx::arg_names::arg2;
using phx::arg_names::arg3;
typename Set::value_type const value = *c.begin();
typename Set::iterator c_begin = c.begin();
// wrapper for
// iterator insert(iterator where, const value_type& val);
typename Set::iterator it =
phx::insert(arg1, arg2, arg3)(c, c_begin, value);
if (test(it != c.begin() /*|| *it != *(++it)*/)) {
cerr << "Failed " << typeid(Set).name() << " test_set_insert 1\n";
return;
}
// wrapper for
// pair<iterator, bool> insert(const value_type& val);
typename Set::value_type const value2(1400);
std::pair<typename Set::iterator, bool> result =
phx::insert(arg1, arg2)(c, value2);
if (test(!result.second)) {
cerr << "Failed " << typeid(Set).name() << " test_set_insert 2\n";
return;
}
// wrapper for
// template<class InIt>
// void insert(InIt first, InIt last);
Set const const_c = build_assoc<Set>();
typename Set::size_type size = c.size();
phx::insert(arg1, const_c.begin(), const_c.end())(c);
if (test(c.size() != size + const_c.size())) {
cerr << "Failed " << typeid(Set).name() << " test_set_insert 3\n";
return;
}
}
template <typename Multiset>
inline void test_multiset_insert(Multiset c)
{
using phx::arg_names::arg1;
using phx::arg_names::arg2;
using phx::arg_names::arg3;
typename Multiset::value_type const value = *c.begin();
typename Multiset::iterator c_begin = c.begin();
std::size_t old_size = c.size();
// wrapper for
// iterator insert(iterator where, const value_type& val);
typename Multiset::iterator it =
phx::insert(arg1, arg2, arg3)(c, c_begin, value);
if (test(*it != value || c.size() != old_size + 1)) {
cerr << "Failed " << typeid(Multiset).name()
<< " test_multiset_insert 1\n";
return;
}
// wrapper for
// iterator insert(const value_type& val);
typename Multiset::value_type const value2(1400);
it = phx::insert(arg1, arg2)(c, value2);
if (test(it == c.end())) {
cerr << "Failed " << typeid(Multiset).name()
<< " test_multiset_insert 2\n";
return;
}
// wrapper for
// template<class InIt>
// void insert(InIt first, InIt last);
Multiset const const_c = build_assoc<Multiset>();
typename Multiset::size_type size = c.size();
phx::insert(arg1, const_c.begin(), const_c.end())(c);
if (test(c.size() != size + const_c.size())) {
cerr << "Failed " << typeid(Multiset).name()
<< " test_multiset_insert 3\n";
return;
}
}
template <typename Container>
void test_key_comp(Container c)
{
using phx::arg_names::arg1;
using phx::key_comp;
typename Container::key_compare comp = key_comp(arg1)(c);
Container const const_c = c;
comp = key_comp(arg1)(const_c);
}
template <typename Container>
void test_max_size(Container c)
{
using phx::arg_names::arg1;
using phx::max_size;
Container const const_c = c;
typename Container::size_type s1 = max_size(arg1)(c);
if (test(s1 != c.max_size())) {
cerr << "Failed " << typeid(Container).name() << " test_max_size 1\n";
return;
}
typename Container::size_type s2 = max_size(arg1)(const_c);
if (test(s2 != const_c.max_size())) {
cerr << "Failed " << typeid(Container).name() << " test_max_size 2\n";
return;
}
}
template <typename Container>
void test_pop_back(Container c)
{
using phx::arg_names::arg1;
using phx::pop_back;
Container const const_c = c;
typename Container::size_type size = c.size();
pop_back(arg1)(c);
if (test(c.size() + 1 != size)) {
cerr << "Failed " << typeid(Container).name() << " test_pop_back 1\n";
return;
}
#if defined(BOOST_PHOENIX_COMPILE_FAIL_TEST)
pop_back(arg1)(const_c);
#endif
}
template <typename Container>
void test_pop_front(Container c)
{
using phx::arg_names::arg1;
using phx::pop_front;
Container const const_c = c;
typename Container::size_type size = c.size();
pop_front(arg1)(c);
if (test(c.size() + 1 != size)) {
cerr << "Failed " << typeid(Container).name() << " test_pop_front 1\n";
return;
}
#if defined(BOOST_PHOENIX_COMPILE_FAIL_TEST)
pop_front(arg1)(const_c);
#endif
}
template <typename Container>
void test_push_back(Container c)
{
using phx::arg_names::arg1;
using phx::arg_names::arg2;
using phx::push_back;
Container const const_c = c;
typename Container::value_type data = *c.begin();
typename Container::size_type size = c.size();
push_back(arg1, arg2)(c, data);
if (test(c.size() != size + 1)) {
cerr << "Failed " << typeid(Container).name() << " test_push_back 1\n";
return;
}
#if defined(BOOST_PHOENIX_COMPILE_FAIL_TEST)
push_back(arg1, arg2)(const_c, data);
#endif
}
template <typename Container>
void test_push_front(Container c)
{
using phx::arg_names::arg1;
using phx::arg_names::arg2;
using phx::push_front;
Container const const_c = c;
typename Container::value_type data = *c.begin();
typename Container::size_type size = c.size();
push_front(arg1, arg2)(c, data);
if (test(c.size() != size + 1)) {
cerr << "Failed " << typeid(Container).name() << " test_push_front 1\n";
return;
}
#if defined(BOOST_PHOENIX_COMPILE_FAIL_TEST)
push_front(arg1, arg2)(const_c, data);
#endif
}
template <typename Container>
void test_rbegin(Container c)
{
using phx::arg_names::arg1;
using phx::rbegin;
typename Container::reverse_iterator it1 = rbegin(arg1)(c);
typename Container::reverse_iterator it1_test = c.rbegin();
if (test(it1 != it1_test)) {
cerr << "Failed " << typeid(Container).name() << " test_rbegin 1\n";
return;
}
typename Container::const_reverse_iterator it2 = rbegin(arg1)(c);
typename Container::const_reverse_iterator it2_test = c.rbegin();
if (test(it2 != it2_test)) {
cerr << "Failed " << typeid(Container).name() << " test_rbegin 2\n";
return;
}
Container const const_c = c;
#if defined(BOOST_PHOENIX_COMPILE_FAIL_TEST)
// Should not --- does not, Yay! --- compile.
typename Container::reverse_iterator it3 = rbegin(arg1)(const_c);
#endif
typename Container::const_reverse_iterator it4 = rbegin(arg1)(const_c);
it2_test = const_c.rbegin();
if (test(it4 != it2_test)) {
cerr << "Failed " << typeid(Container).name() << " test_rbegin 4\n";
return;
}
}
template <typename Container>
void test_rend(Container c)
{
using phx::arg_names::arg1;
using phx::rend;
typename Container::reverse_iterator it1 = rend(arg1)(c);
typename Container::reverse_iterator it1_test = c.rend();
if (test(it1 != it1_test)) {
cerr << "Failed " << typeid(Container).name() << " test_rend 1\n";
return;
}
typename Container::const_reverse_iterator it2 = rend(arg1)(c);
typename Container::const_reverse_iterator it2_test = c.rend();
if (test(it2 != it2_test)) {
cerr << "Failed " << typeid(Container).name() << " test_rend 2\n";
return;
}
Container const const_c = c;
#if defined(BOOST_PHOENIX_COMPILE_FAIL_TEST)
// Should not --- does not, Yay! --- compile.
typename Container::reverse_iterator it3 = rend(arg1)(const_c);
#endif
typename Container::const_reverse_iterator it4 = rend(arg1)(const_c);
it2_test = const_c.rend();
if (test(it4 != it2_test)) {
cerr << "Failed " << typeid(Container).name() << " test_rend 4\n";
return;
}
}
template <typename Container>
void test_reserve(Container c)
{
using phx::arg_names::arg1;
using phx::reserve;
Container const const_c = c;
typename Container::size_type count = 2 * c.size();
reserve(arg1, count)(c);
if (test(c.capacity() < count)) {
cerr << "Failed " << typeid(Container).name() << " test_reserve 1\n";
return;
}
#if defined(BOOST_PHOENIX_COMPILE_FAIL_TEST)
reserve(arg1, count)(const_c)(const_c);
#endif
}
template <typename Container>
void test_resize(Container c)
{
using phx::arg_names::arg1;
using phx::resize;
Container const const_c = c;
typename Container::size_type new_size = 2 * c.size();
resize(arg1, new_size)(c);
if (test(c.size() != new_size)) {
cerr << "Failed " << typeid(Container).name() << " test_resize 1\n";
return;
}
new_size = 2 * c.size();
typename Container::value_type value = *c.begin();
resize(arg1, new_size, value)(c);
if (test(c.size() != new_size)) {
cerr << "Failed " << typeid(Container).name() << " test_resize 2\n";
return;
}
#if defined(BOOST_PHOENIX_COMPILE_FAIL_TEST)
new_size = 2 * const_c.size();
resize(arg1, new_size)(const_c);
new_size = 2 * const_c.size();
resize(arg1, new_size, value)(const_c);
#endif
}
template <typename Container>
void test_size(Container c)
{
using phx::arg_names::arg1;
using phx::size;
Container const const_c = c;
typename Container::size_type s1 = size(arg1)(c);
if (test(s1 != c.size())) {
cerr << "Failed " << typeid(Container).name() << " test_size 1\n";
return;
}
typename Container::size_type s2 = size(arg1)(const_c);
if (test(s2 != const_c.size())) {
cerr << "Failed " << typeid(Container).name() << " test_size 2\n";
return;
}
}
template <typename Container>
void test_splice(Container c)
{
using phx::arg_names::arg1;
using phx::arg_names::arg2;
using phx::arg_names::arg3;
using phx::arg_names::arg4;
using phx::arg_names::arg5;
using phx::splice;
typename Container::iterator c_end;
typename Container::iterator c2_begin;
typename Container::iterator c2_end;
typename Container::size_type size = c.size();
Container const copy = c;
Container const copy2 = build_list();
Container c2 = copy2;
size = c.size();
c_end = c.end();
splice(arg1, arg2, arg3)(c, c_end, c2);
if (test(c.size() != 2 * size)) {
cerr << "Failed " << typeid(Container).name() << " test_splice 1\n";
return;
}
c = copy;
c_end = c.end();
c2 = copy2;
c2_begin = c2.begin();
size = c.size() + 1;
splice(arg1, arg2, arg3, arg4)(c, c_end, c2, c2_begin);
if (test(c.size() != size)) {
cerr << "Failed " << typeid(Container).name() << " test_splice 2\n";
return;
}
c = copy;
c_end = c.end();
c2 = copy2;
c2_begin = c2.begin();
c2_end = c2.end();
size = c.size() + c2.size();
/*
splice(arg1, arg2, arg3, arg4, arg5)(c, c_end, c2, c2_begin, c2_end);
if (test(c.size() != size)) {
cerr << "Failed " << typeid(Container).name() << " test_splice 3\n";
return;
}
*/
}
template <typename Container>
void test_value_comp(Container c)
{
using phx::arg_names::arg1;
using phx::value_comp;
typename Container::value_compare comp = value_comp(arg1)(c);
Container const const_c = c;
comp = value_comp(arg1)(const_c);
}
#endif
Reference in New Issue View Git Blame Copy Permalink