+2009-05-19 Benjamin Kosnik <bkoz@redhat.com>
+
+ * testsuite/23_containers/list/14340.cc: Abstract list type.
+ * testsuite/23_containers/list/init-list.cc: Same.
+ * testsuite/23_containers/list/pthread5.cc: Same.
+ * testsuite/23_containers/list/invalidation/1.cc: Same.
+ * testsuite/23_containers/list/invalidation/2.cc: Same.
+ * testsuite/23_containers/list/invalidation/3.cc: Same.
+ * testsuite/23_containers/list/invalidation/4.cc: Same.
+ * testsuite/23_containers/list/modifiers/insert/25288.cc: Same.
+ * testsuite/23_containers/list/modifiers/1.cc: Same.
+ * testsuite/23_containers/list/modifiers/2.cc: Same.
+ * testsuite/23_containers/list/modifiers/3.cc: Same.
+ * testsuite/23_containers/list/modifiers/swap/1.cc: Same.
+ * testsuite/23_containers/list/modifiers/swap/2.cc: Same.
+ * testsuite/23_containers/list/modifiers/swap/3.cc: Same.
+ * testsuite/23_containers/list/cons/1.cc: Same.
+ * testsuite/23_containers/list/cons/2.cc: Same.
+ * testsuite/23_containers/list/cons/3.cc: Same.
+ * testsuite/23_containers/list/cons/4.cc: Same.
+ * testsuite/23_containers/list/cons/5.cc: Same.
+ * testsuite/23_containers/list/cons/6.cc: Same.
+ * testsuite/23_containers/list/cons/7.cc: Same.
+ * testsuite/23_containers/list/cons/clear_allocator.cc: Same.
+ * testsuite/23_containers/list/cons/8.cc: Same.
+ * testsuite/23_containers/list/cons/9.cc: Same.
+ * testsuite/23_containers/list/operations/1.cc: Same.
+ * testsuite/23_containers/list/operations/2.cc: Same.
+ * testsuite/23_containers/list/operations/3.cc: Same.
+ * testsuite/23_containers/list/operations/4.cc: Same.
+ * testsuite/23_containers/list/operations/5.cc: Same.
+ * testsuite/23_containers/list/requirements/citerators.cc: Same.
+ * testsuite/23_containers/list/requirements/dr438/assign_neg.cc: Same.
+ * testsuite/23_containers/list/requirements/dr438/insert_neg.cc: Same.
+ * testsuite/23_containers/list/requirements/dr438/
+ constructor_1_neg.cc: Same.
+ * testsuite/23_containers/list/requirements/dr438/
+ constructor_2_neg.cc: Same.
+ * testsuite/23_containers/list/requirements/dr438/constructor.cc: Same.
+ * testsuite/23_containers/list/requirements/
+ partial_specialization/1.cc: Same.
+ * testsuite/23_containers/list/23781.cc: Same.
+ * testsuite/23_containers/list/pthread1.cc: Same.
+ * testsuite/23_containers/list/capacity/1.cc: Same.
+ * testsuite/23_containers/list/capacity/29134.cc: Same.
+ * testsuite/23_containers/list/check_construct_destroy.cc: Same.
+ * testsuite/23_containers/list/moveable.cc: Same.
+
+ * testsuite/util/common_type/assoc/common_type.hpp: Re-break lines.
+
2009-05-19 Paolo Carlini <paolo.carlini@oracle.com>
PR libstdc++/40184
// libstdc++/14340
int main()
{
- typedef std::list<int> container;
- __gnu_test::conversion<container>::iterator_to_const_iterator();
+ typedef std::list<int> list_type;
+ __gnu_test::conversion<list_type>::iterator_to_const_iterator();
return 0;
}
// libstdc++/23781
#include <list>
-std::list<int>::iterator it = NULL; // { dg-error "conversion" }
-std::list<int>::const_iterator cit = NULL; // { dg-error "conversion" }
+typedef std::list<int> list_type;
+list_type::iterator it = NULL; // { dg-error "conversion" }
+list_type::const_iterator cit = NULL; // { dg-error "conversion" }
#include <list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
// This test verifies the following.
//
// 23.2.2 bool empty() const
// 23.2.2 size_type max_size() const
// 23.2.2.2 void resize(size_type s, T c = T())
//
+template<typename _Tp>
void
-test01()
+capacity01()
{
- std::list<int> list0101;
+ bool test __attribute__((unused)) = true;
+ typedef _Tp list_type;
+ typedef typename list_type::iterator iterator_type;
+
+ list_type list0101;
VERIFY(list0101.empty());
VERIFY(list0101.size() == 0);
VERIFY(!list0101.empty());
VERIFY(list0101.size() == 3);
- std::list<int>::iterator i = list0101.begin();
+ iterator_type i = list0101.begin();
VERIFY(*i == 1); ++i;
VERIFY(*i == 2); ++i;
VERIFY(*i == 2); ++i;
int
main()
{
- test01();
+ capacity01<std::list<int> >();
return 0;
}
-
-// vi:set sw=2 ts=2:
{
bool test __attribute__((unused)) = true;
- std::list<int> l;
+ typedef std::list<int> list_type;
+ list_type l;
#ifndef _GLIBCXX_DEBUG
using std::_List_node;
#include <iterator>
#include <testsuite_allocator.h>
-using namespace __gnu_test;
-int main()
+template<typename _Tp>
+bool
+construct_destroy()
{
- typedef std::list<int, tracker_allocator<int> > Container;
+ typedef _Tp list_type;
+ typedef typename list_type::iterator iterator_type;
+
+ using namespace __gnu_test;
const int arr10[10] = { 2, 4, 1, 7, 3, 8, 10, 5, 9, 6 };
bool ok = true;
tracker_allocator_counter::reset();
{
- Container c;
+ list_type c;
ok = check_construct_destroy("empty container", 0, 0) && ok;
}
ok = check_construct_destroy("empty container", 0, 0) && ok;
tracker_allocator_counter::reset();
{
- Container c(arr10, arr10 + 10);
+ list_type c(arr10, arr10 + 10);
ok = check_construct_destroy("Construct from range", 10, 0) && ok;
}
ok = check_construct_destroy("Construct from range", 10, 10) && ok;
{
- Container c(arr10, arr10 + 10);
+ list_type c(arr10, arr10 + 10);
tracker_allocator_counter::reset();
c.insert(c.begin(), arr10[0]);
ok = check_construct_destroy("Insert element", 1, 0) && ok;
ok = check_construct_destroy("Insert element", 1, 11) && ok;
{
- Container c(arr10, arr10 + 10);
+ list_type c(arr10, arr10 + 10);
tracker_allocator_counter::reset();
- Container::iterator i5 = c.begin();
+ iterator_type i5 = c.begin();
std::advance(i5, 5);
c.insert(i5, arr10, arr10+3);
ok = check_construct_destroy("Insert short range", 3, 0) && ok;
ok = check_construct_destroy("Insert short range", 3, 13) && ok;
{
- Container c(arr10, arr10 + 10);
+ list_type c(arr10, arr10 + 10);
tracker_allocator_counter::reset();
- Container::iterator i7 = c.begin();
+ iterator_type i7 = c.begin();
std::advance(i7, 5);
c.insert(i7, arr10, arr10+10);
ok = check_construct_destroy("Insert long range", 10, 0) && ok;
return ok ? 0 : 1;
}
+int main()
+{
+ construct_destroy<std::list<int, __gnu_test::tracker_allocator<int> > >();
+ return 0;
+}
#include <list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
// A nontrivial type.
template<typename T>
struct A { };
// Another nontrivial type
struct B { };
-// A nontrivial type convertible from an int
-struct C {
- C(int i) : i_(i) { }
- bool operator==(const C& rhs) { return i_ == rhs.i_; }
- int i_;
-};
-
// Default constructor, basic properties
//
// This test verifies the following.
// 23.2.2 size_type size() const
// 23.2.2 existence of required typedefs
//
+template<typename _Tp>
void
-test01()
+cons01()
{
- std::list< A<B> > list0101;
+ bool test __attribute__((unused)) = true;
+ typedef _Tp list_type;
+
+ list_type list0101;
VERIFY(list0101.begin() == list0101.end());
VERIFY(list0101.size() == 0);
// check type definitions -- will fail compile if missing
- typedef std::list< A<B> >::reference reference;
- typedef std::list< A<B> >::const_reference const_reference;
- typedef std::list< A<B> >::iterator iterator;
- typedef std::list< A<B> >::const_iterator const_iterator;
- typedef std::list< A<B> >::size_type size_type;
- typedef std::list< A<B> >::difference_type difference_type;
- typedef std::list< A<B> >::value_type value_type;
- typedef std::list< A<B> >::allocator_type allocator_type;
- typedef std::list< A<B> >::pointer pointer;
- typedef std::list< A<B> >::const_pointer const_pointer;
- typedef std::list< A<B> >::reverse_iterator reverse_iterator;
- typedef std::list< A<B> >::const_reverse_iterator const_reverse_iterator;
+ typedef typename list_type::reference reference;
+ typedef typename list_type::const_reference const_reference;
+ typedef typename list_type::iterator iterator;
+ typedef typename list_type::const_iterator const_iterator;
+ typedef typename list_type::size_type size_type;
+ typedef typename list_type::difference_type difference_type;
+ typedef typename list_type::value_type value_type;
+ typedef typename list_type::allocator_type allocator_type;
+ typedef typename list_type::pointer pointer;
+ typedef typename list_type::const_pointer const_pointer;
+ typedef typename list_type::reverse_iterator reverse_iterator;
+ typedef typename list_type::const_reverse_iterator const_reverse_iterator;
// allocator checks?
}
int main()
{
- test01();
+ cons01<std::list< A<B> > >();
return 0;
}
#include <list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
// A nontrivial type.
template<typename T>
struct A { };
// Another nontrivial type
struct B { };
-// A nontrivial type convertible from an int
-struct C {
- C(int i) : i_(i) { }
- bool operator==(const C& rhs) { return i_ == rhs.i_; }
- int i_;
-};
-
// Fill constructor
//
// This test verifies the following.
-// 23.2.2.1 explicit list(size_type n, const T& v = T(), const a& = Allocator())
-// 23.2.2 const_iterator begin() const
-// 23.2.2 const_iterator end() const
-// 23.2.2 size_type size() const
+// 23.2.2.1 explicit list(size_type n, const T& v = T(), const a& = Allocator())
+// 23.2.2 const_iterator begin() const
+// 23.2.2 const_iterator end() const
+// 23.2.2 size_type size() const
//
+template<typename _Tp>
void
-test02()
+cons021()
{
+ bool test __attribute__((unused)) = true;
const std::size_t LIST_SIZE = 5;
const int INIT_VALUE = 7;
std::size_t count;
- std::list<int>::const_iterator i;
- // nontrivial value_type
- std::list< A<B> > list0201(LIST_SIZE);
+ typedef _Tp list_type;
+ typedef typename list_type::const_iterator const_iterator;
+ const_iterator i;
// default value
- std::list<int> list0202(LIST_SIZE);
+ list_type list0202(LIST_SIZE);
for (i = list0202.begin(), count = 0;
i != list0202.end();
++i, ++count)
VERIFY(list0202.size() == LIST_SIZE);
// explicit value
- std::list<int> list0203(LIST_SIZE, INIT_VALUE);
+ list_type list0203(LIST_SIZE, INIT_VALUE);
for (i = list0203.begin(), count = 0;
i != list0203.end();
++i, ++count)
VERIFY(list0203.size() == LIST_SIZE);
}
+template<typename _Tp>
+void
+cons022()
+{
+ // nontrivial value_type
+ typedef _Tp list_type;
+ const std::size_t LIST_SIZE = 5;
+ list_type list0201(LIST_SIZE);
+}
+
int main()
{
- test02();
+ cons021<std::list<int> >();
+ cons022<std::list< A<B> > >();
return 0;
}
#include <list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
-// A nontrivial type.
-template<typename T>
- struct A { };
-
-// Another nontrivial type
-struct B { };
-
// A nontrivial type convertible from an int
-struct C {
+struct C
+{
C(int i) : i_(i) { }
bool operator==(const C& rhs) { return i_ == rhs.i_; }
int i_;
};
// Fill constructor disguised as a range constructor
+template<typename _Tp>
void
-test02D()
+cons03()
{
+ bool test __attribute__((unused)) = true;
+ typedef _Tp list_type;
+ typedef typename list_type::iterator iterator;
+
const std::size_t LIST_SIZE = 5;
const int INIT_VALUE = 7;
std::size_t count = 0;
- std::list<C> list0204(LIST_SIZE, INIT_VALUE);
- std::list<C>::iterator i = list0204.begin();
+ list_type list0204(LIST_SIZE, INIT_VALUE);
+ iterator i = list0204.begin();
for (; i != list0204.end(); ++i, ++count)
VERIFY(*i == INIT_VALUE);
VERIFY(count == LIST_SIZE);
int main()
{
- test02D();
+ cons03<std::list<C> >();
return 0;
}
-// vi:set sw=2 ts=2:
#include <list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
// Range constructor
//
// This test verifies the following.
-// 23.2.2.1 template list(InputIterator f, InputIterator l, const Allocator& a = Allocator())
+// 23.2.2.1 template list(InputIterator f, InputIterator l,
+// const Allocator& a = Allocator())
// 23.2.2 const_iterator begin() const
// 23.2.2 const_iterator end() const
// 23.2.2 size_type size() const
//
+template<typename _Tp>
void
-test03()
+cons04()
{
+ bool test __attribute__((unused)) = true;
const int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17};
const std::size_t N = sizeof(A) / sizeof(int);
std::size_t count;
- std::list<int>::const_iterator i;
+
+ typedef std::list<int> list_type;
+ typedef typename list_type::const_iterator const_iterator;
+ const_iterator i;
// construct from a dissimilar range
- std::list<int> list0301(A, A + N);
+ list_type list0301(A, A + N);
for (i = list0301.begin(), count = 0;
i != list0301.end();
++i, ++count)
VERIFY(list0301.size() == N);
// construct from a similar range
- std::list<int> list0302(list0301.begin(), list0301.end());
+ list_type list0302(list0301.begin(), list0301.end());
for (i = list0302.begin(), count = 0;
i != list0302.end();
++i, ++count)
int main()
{
- test03();
+ cons04<std::list<int> >();
return 0;
}
#include <list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
// Copy constructor
//
// This test verifies the following.
// 23.2.2 reverse_iterator rend()
// 23.2.2 size_type size() const
//
+template<typename _Tp>
void
-test04()
+cons05()
{
+ bool test __attribute__((unused)) = true;
const int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17};
const std::size_t N = sizeof(A) / sizeof(int);
int count;
- std::list<int>::reverse_iterator i;
- std::list<int> list0401(A, A + N);
- std::list<int> list0402(list0401);
+ typedef _Tp list_type;
+ typedef typename list_type::reverse_iterator reverse_iterator;
+ reverse_iterator i;
+ list_type list0401(A, A + N);
+
+ list_type list0402(list0401);
for (i = list0401.rbegin(), count = N - 1;
i != list0401.rend();
++i, --count)
int main()
{
- test04();
+ cons05<std::list<int> >();
return 0;
}
#include <list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
// Range assign
//
// This test verifies the following.
// 23.2.2 const_iterator end() const
// 23.2.2 size_type size() const
//
+template<typename _Tp>
void
-test05()
+cons05()
{
+ bool test __attribute__((unused)) = true;
const int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17};
const int B[] = {101, 102, 103, 104, 105};
const std::size_t N = sizeof(A) / sizeof(int);
const std::size_t M = sizeof(B) / sizeof(int);
std::size_t count;
- std::list<int>::const_iterator i;
- std::list<int> list0501;
+ typedef _Tp list_type;
+ typedef typename list_type::const_iterator const_iterator;
+ const_iterator i;
+
+ list_type list0501;
// make it bigger
list0501.assign(A, A + N);
int main()
{
- test05();
+ cons05<std::list<int> >();
return 0;
}
#include <list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
// Fill assign
//
// This test verifies the following.
// 23.2.2 const_iterator end() const
// 23.2.2 size_type size() const
//
+template<typename _Tp>
void
-test06()
+cons07()
{
+ bool test __attribute__((unused)) = true;
const std::size_t BIG_LIST_SIZE = 11;
const int BIG_INIT_VALUE = 7;
const std::size_t SMALL_LIST_SIZE = 5;
const int SMALL_INIT_VALUE = 17;
std::size_t count;
- std::list<int>::const_iterator i;
- std::list<int> list0601;
+ typedef _Tp list_type;
+ typedef typename list_type::const_iterator const_iterator;
+ const_iterator i;
+
+ list_type list0601;
VERIFY(list0601.size() == 0);
// make it bigger
int main()
{
- test06();
+ cons07<std::list<int> >();
return 0;
}
#include <list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
-
-// A nontrivial type.
-template<typename T>
- struct A { };
-
-// Another nontrivial type
-struct B { };
-
// A nontrivial type convertible from an int
-struct C {
+struct C
+{
C(int i) : i_(i) { }
bool operator==(const C& rhs) { return i_ == rhs.i_; }
int i_;
};
// Fill Assignment disguised as a Range Assignment
+template<typename _Tp>
void
-test06D()
+cons08()
{
+ typedef _Tp list_type;
+ typedef typename list_type::iterator iterator;
+ bool test __attribute__((unused)) = true;
const std::size_t LIST_SIZE = 5;
const int INIT_VALUE = 7;
std::size_t count = 0;
- std::list<C> list0604;
+
+ list_type list0604;
VERIFY(list0604.size() == 0);
list0604.assign(LIST_SIZE, INIT_VALUE);
- std::list<C>::iterator i = list0604.begin();
+ iterator i = list0604.begin();
for (; i != list0604.end(); ++i, ++count)
VERIFY(*i == INIT_VALUE);
VERIFY(count == LIST_SIZE);
int main()
{
- test06D();
+ cons08<std::list<C> >();
return 0;
}
#include <list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
// Assignment operator
//
// This test verifies the following.
// 23.2.2 size_type size() const
// 23.2.2 bool operator==(const list& x, const list& y)
//
+template<typename _Tp>
void
-test07()
+cons09()
{
+ bool test __attribute__((unused)) = true;
+ typedef _Tp list_type;
+ typedef typename list_type::iterator iterator;
+
const int A[] = {701, 702, 703, 704, 705};
const std::size_t N = sizeof(A) / sizeof(int);
std::size_t count;
- std::list<int>::iterator i;
- std::list<int> list0701(A, A + N);
+ iterator i;
+
+ list_type list0701(A, A + N);
VERIFY(list0701.size() == N);
- std::list<int> list0702;
+ list_type list0702;
VERIFY(list0702.size() == 0);
list0702 = list0701;
int main()
{
- test07();
+ cons09<std::list<int> >();
return 0;
}
-// vi:set sw=2 ts=2:
int main()
{
- Check_Container<std::list<int, clear_alloc<int> > >();
+ typedef std::list<int, clear_alloc<int> > list_type;
+ Check_Container<list_type>();
return 0;
}
#include <list>
#include <testsuite_allocator.h>
-using namespace __gnu_test;
-
-int main()
+template<typename _Tp>
+bool
+init_list()
{
- typedef std::list<int, tracker_allocator<int> > Container;
+ using namespace __gnu_test;
+ typedef _Tp list_type;
+ typedef typename list_type::iterator iterator;
+
const int arr10[10] = { 2, 4, 1, 7, 3, 8, 10, 5, 9, 6 };
bool ok = true;
tracker_allocator_counter::reset();
{
- Container c({ 2, 4, 1 });
+ list_type c({ 2, 4, 1 });
ok = check_construct_destroy("Construct from init-list", 3, 0) && ok;
- Container::iterator i = c.begin();
+ iterator i = c.begin();
ok &= (*i++ == 2);
ok &= (*i++ == 4);
}
ok = check_construct_destroy("Construct from init-list", 3, 3) && ok;
{
- Container c(arr10, arr10 + 10);
+ list_type c(arr10, arr10 + 10);
tracker_allocator_counter::reset();
- Container::iterator i = c.begin();
+ iterator i = c.begin();
++i; ++i; ++i; ++i; ++i; ++i; ++i;
c.insert(i, { 234, 42, 1 });
ok = check_construct_destroy("Insert init-list", 3, 0) && ok;
ok = check_construct_destroy("Insert init-list", 3, 13) && ok;
{
- Container c;
+ list_type c;
tracker_allocator_counter::reset();
c = { 13, 0, 42 };
ok = check_construct_destroy("Assign init-list", 3, 0) && ok;
- Container::iterator i = c.begin();
+ iterator i = c.begin();
ok &= (*i++ == 13);
}
ok = check_construct_destroy("Assign init-list", 3, 3) && ok;
- return ok ? 0 : 1;;
+ return ok ? 0 : 1;
+}
+
+int main()
+{
+ typedef int value_type;
+ typedef __gnu_test::tracker_allocator<int> allocator_type;
+ typedef std::list<value_type, allocator_type> list_type;
+ init_list<list_type>();
+ return 0;
}
#include <iterator>
#include <testsuite_hooks.h>
-using __gnu_debug::list;
-using std::advance;
-
-bool test = true;
-
// Assignment
void test01()
{
- list<int> v1;
- list<int> v2;
+ using std::advance;
+
+ bool test = true;
+
+ typedef __gnu_debug::list<int> list_type;
+ list_type v1;
+ list_type v2;
v1.push_front(17);
- list<int>::iterator start = v1.begin();
- list<int>::iterator finish = v1.end();
+ list_type::iterator start = v1.begin();
+ list_type::iterator finish = v1.end();
VERIFY(start._M_dereferenceable());
VERIFY(!finish._M_dereferenceable() && !finish._M_singular());
#include <iterator>
#include <testsuite_hooks.h>
-using __gnu_debug::list;
-using std::advance;
-
-bool test = true;
-
// Resize
void test02()
{
- list<int> v(10, 17);
+ using std::advance;
+
+ bool test = true;
+
+ typedef __gnu_debug::list<int> list_type;
+
+ list_type v(10, 17);
- list<int>::iterator before = v.begin();
+ list_type::iterator before = v.begin();
advance(before, 6);
- list<int>::iterator at = before;
+ list_type::iterator at = before;
advance(at, 1);
- list<int>::iterator after = at;
+ list_type::iterator after = at;
advance(after, 1);
- list<int>::iterator finish = v.end();
+ list_type::iterator finish = v.end();
// Shrink
v.resize(7);
#include <iterator>
#include <testsuite_hooks.h>
-using __gnu_debug::list;
-using std::advance;
-
-bool test = true;
-
// Erase
void test03()
{
- list<int> v(20, 42);
+ using std::advance;
+
+ bool test = true;
+ typedef __gnu_debug::list<int> list_type;
+
+ list_type v(20, 42);
// Single element erase (middle)
- list<int>::iterator before = v.begin();
- list<int>::iterator at = before;
+ list_type::iterator before = v.begin();
+ list_type::iterator at = before;
advance(at, 3);
- list<int>::iterator after = at;
+ list_type::iterator after = at;
at = v.erase(at);
VERIFY(before._M_dereferenceable());
VERIFY(at._M_dereferenceable());
// clear()
before = v.begin();
- list<int>::iterator finish = v.end();
+ list_type::iterator finish = v.end();
VERIFY(before._M_dereferenceable());
v.clear();
VERIFY(before._M_singular());
#include <iterator>
#include <testsuite_hooks.h>
-using __gnu_debug::list;
-using std::advance;
-
-bool test = true;
-
// Splice
void test04()
{
- list<int> l1(10, 17);
- list<int> l2(10, 42);
+ using std::advance;
+
+ bool test = true;
+
+ typedef __gnu_debug::list<int> list_type;
+
+ list_type l1(10, 17);
+ list_type l2(10, 42);
- list<int>::iterator start2 = l2.begin();
- list<int>::iterator end2 = start2;
+ list_type::iterator start2 = l2.begin();
+ list_type::iterator end2 = start2;
advance(end2, 5);
- list<int>::iterator after2 = end2;
+ list_type::iterator after2 = end2;
advance(after2, 2);
l1.splice(l1.begin(), l2, start2, end2);
#include <list>
#include <testsuite_hooks.h>
-typedef __gnu_test::copy_tracker T;
-
-bool test __attribute__((unused)) = true;
-
// range and fill insert/erase + clear
// missing: o fill insert disguised as a range insert in all its variants
// o exception effects
+template<typename _Tp>
void
-test03()
+modifiers1()
{
- std::list<T> list0301;
- T::reset();
+ bool test __attribute__((unused)) = true;
+ typedef _Tp list_type;
+ typedef typename list_type::iterator iterator;
+ typedef typename list_type::value_type value_type;
+
+ list_type list0301;
+ value_type::reset();
// fill insert at beginning of list / empty list
- list0301.insert(list0301.begin(), 3, T(11)); // should be [11 11 11]
+ list0301.insert(list0301.begin(), 3, value_type(11)); // should be [11 11 11]
VERIFY(list0301.size() == 3);
- VERIFY(T::copyCount() == 3);
+ VERIFY(value_type::copyCount() == 3);
// save iterators to verify post-insert validity
- std::list<T>::iterator b = list0301.begin();
- std::list<T>::iterator m = list0301.end(); --m;
- std::list<T>::iterator e = list0301.end();
+ iterator b = list0301.begin();
+ iterator m = list0301.end(); --m;
+ iterator e = list0301.end();
// fill insert at end of list
- T::reset();
- list0301.insert(list0301.end(), 3, T(13)); // should be [11 11 11 13 13 13]
+ value_type::reset();
+ list0301.insert(list0301.end(), 3, value_type(13)); // should be [11 11 11 13 13 13]
VERIFY(list0301.size() == 6);
- VERIFY(T::copyCount() == 3);
+ VERIFY(value_type::copyCount() == 3);
VERIFY(b == list0301.begin() && b->id() == 11);
VERIFY(e == list0301.end());
VERIFY(m->id() == 11);
// fill insert in the middle of list
++m;
- T::reset();
- list0301.insert(m, 3, T(12)); // should be [11 11 11 12 12 12 13 13 13]
+ value_type::reset();
+ list0301.insert(m, 3, value_type(12)); // should be [11 11 11 12 12 12 13 13 13]
VERIFY(list0301.size() == 9);
- VERIFY(T::copyCount() == 3);
+ VERIFY(value_type::copyCount() == 3);
VERIFY(b == list0301.begin() && b->id() == 11);
VERIFY(e == list0301.end());
VERIFY(m->id() == 13);
// single erase
- T::reset();
+ value_type::reset();
m = list0301.erase(m); // should be [11 11 11 12 12 12 13 13]
VERIFY(list0301.size() == 8);
- VERIFY(T::dtorCount() == 1);
+ VERIFY(value_type::dtorCount() == 1);
VERIFY(b == list0301.begin() && b->id() == 11);
VERIFY(e == list0301.end());
VERIFY(m->id() == 13);
// range erase
- T::reset();
+ value_type::reset();
m = list0301.erase(list0301.begin(), m); // should be [13 13]
VERIFY(list0301.size() == 2);
- VERIFY(T::dtorCount() == 6);
+ VERIFY(value_type::dtorCount() == 6);
VERIFY(m->id() == 13);
// range fill at beginning
const int A[] = {321, 322, 333};
const int N = sizeof(A) / sizeof(int);
- T::reset();
- b = list0301.begin();
+ value_type::reset();
+ b = list0301.begin();
list0301.insert(b, A, A + N); // should be [321 322 333 13 13]
VERIFY(list0301.size() == 5);
- VERIFY(T::copyCount() == 3);
+ VERIFY(value_type::copyCount() == 3);
VERIFY(m->id() == 13);
-
+
// range fill at end
- T::reset();
+ value_type::reset();
list0301.insert(e, A, A + N); // should be [321 322 333 13 13 321 322 333]
VERIFY(list0301.size() == 8);
- VERIFY(T::copyCount() == 3);
+ VERIFY(value_type::copyCount() == 3);
VERIFY(e == list0301.end());
VERIFY(m->id() == 13);
-
+
// range fill in middle
- T::reset();
- list0301.insert(m, A, A + N);
+ value_type::reset();
+ list0301.insert(m, A, A + N);
VERIFY(list0301.size() == 11);
- VERIFY(T::copyCount() == 3);
+ VERIFY(value_type::copyCount() == 3);
VERIFY(e == list0301.end());
VERIFY(m->id() == 13);
- T::reset();
+ value_type::reset();
list0301.clear();
VERIFY(list0301.size() == 0);
- VERIFY(T::dtorCount() == 11);
+ VERIFY(value_type::dtorCount() == 11);
VERIFY(e == list0301.end());
}
int main()
{
- test03();
+ modifiers1<std::list<__gnu_test::copy_tracker> >();
return 0;
}
#include <list>
#include <testsuite_hooks.h>
-typedef __gnu_test::copy_tracker T;
-
-bool test __attribute__((unused)) = true;
-
// general single insert/erase + swap
+template<typename _Tp>
void
-test02()
+modifiers2()
{
- std::list<T> list0201;
- T::reset();
+ bool test __attribute__((unused)) = true;
+ typedef _Tp list_type;
+ typedef typename list_type::value_type value_type;
+ typedef typename list_type::iterator iterator;
+ typedef typename list_type::const_iterator const_iterator;
+
+ list_type list0201;
+ value_type::reset();
- list0201.insert(list0201.begin(), T(1)); // list should be [1]
+ list0201.insert(list0201.begin(), value_type(1)); // list should be [1]
VERIFY(list0201.size() == 1);
- VERIFY(T::copyCount() == 1);
+ VERIFY(value_type::copyCount() == 1);
- list0201.insert(list0201.end(), T(2)); // list should be [1 2]
+ list0201.insert(list0201.end(), value_type(2)); // list should be [1 2]
VERIFY(list0201.size() == 2);
- VERIFY(T::copyCount() == 2);
+ VERIFY(value_type::copyCount() == 2);
- std::list<T>::iterator i = list0201.begin();
- std::list<T>::const_iterator j = i;
+ iterator i = list0201.begin();
+ const_iterator j = i;
VERIFY(i->id() == 1); ++i;
VERIFY(i->id() == 2);
- list0201.insert(i, T(3)); // list should be [1 3 2]
+ list0201.insert(i, value_type(3)); // list should be [1 3 2]
VERIFY(list0201.size() == 3);
- VERIFY(T::copyCount() == 3);
+ VERIFY(value_type::copyCount() == 3);
- std::list<T>::const_iterator k = i;
+ const_iterator k = i;
VERIFY(i->id() == 2); --i;
VERIFY(i->id() == 3); --i;
- VERIFY(i->id() == 1);
- VERIFY(j->id() == 1);
+ VERIFY(i->id() == 1);
+ VERIFY(j->id() == 1);
++i; // will point to '3'
- T::reset();
+ value_type::reset();
list0201.erase(i); // should be [1 2]
VERIFY(list0201.size() == 2);
- VERIFY(T::dtorCount() == 1);
+ VERIFY(value_type::dtorCount() == 1);
VERIFY(k->id() == 2);
- VERIFY(j->id() == 1);
+ VERIFY(j->id() == 1);
- std::list<T> list0202;
- T::reset();
+ list_type list0202;
+ value_type::reset();
VERIFY(list0202.size() == 0);
- VERIFY(T::copyCount() == 0);
- VERIFY(T::dtorCount() == 0);
+ VERIFY(value_type::copyCount() == 0);
+ VERIFY(value_type::dtorCount() == 0);
// member swap
list0202.swap(list0201);
VERIFY(list0201.size() == 0);
VERIFY(list0202.size() == 2);
- VERIFY(T::copyCount() == 0);
- VERIFY(T::dtorCount() == 0);
+ VERIFY(value_type::copyCount() == 0);
+ VERIFY(value_type::dtorCount() == 0);
// specialized swap
swap(list0201, list0202);
VERIFY(list0201.size() == 2);
VERIFY(list0202.size() == 0);
- VERIFY(T::copyCount() == 0);
- VERIFY(T::dtorCount() == 0);
+ VERIFY(value_type::copyCount() == 0);
+ VERIFY(value_type::dtorCount() == 0);
}
int main()
{
- test02();
+ modifiers2<std::list<__gnu_test::copy_tracker> >();
return 0;
}
#include <list>
#include <testsuite_hooks.h>
-typedef __gnu_test::copy_tracker T;
-
-bool test __attribute__((unused)) = true;
-
-
// This test verifies the following.
//
// 23.2.2.3 void push_front(const T& x)
// 23.2.2.3 void push_back(const T& x)
-// 23.2.2.3 (1) iterator and reference non-invalidation
+// 23.2.2.3 (1) iterator and reference non-invalidation
// 23.2.2.3 (1) exception effects
// 23.2.2.3 (2) complexity requirements
//
// 23.2.2.3 void pop_front()
// 23.2.2.3 void pop_back()
-// 23.2.2.3 (3) iterator and reference non-invalidation
+// 23.2.2.3 (3) iterator and reference non-invalidation
// 23.2.2.3 (5) complexity requirements
//
// 23.2.2 const_iterator begin() const
-// 23.2.2 iterator end()
+// 23.2.2 iterator end()
// 23.2.2 const_reverse_iterator rbegin() const
-// 23.2.2 _reference front()
+// 23.2.2 _reference front()
// 23.2.2 const_reference front() const
-// 23.2.2 reference back()
+// 23.2.2 reference back()
// 23.2.2 const_reference back() const
//
+template<typename _Tp>
void
-test01()
+modifiers3()
{
- std::list<T> list0101;
- std::list<T>::const_iterator i;
- std::list<T>::const_reverse_iterator j;
- std::list<T>::iterator k;
- T::reset();
-
- list0101.push_back(T(1)); // list should be [1]
+ bool test __attribute__((unused)) = true;
+ typedef _Tp list_type;
+ typedef typename list_type::iterator iterator;
+ typedef typename list_type::value_type value_type;
+ typedef typename list_type::const_iterator const_iterator;
+ typedef typename list_type::const_reverse_iterator const_reverse_iterator;
+
+ list_type list0101;
+ const_iterator i;
+ const_reverse_iterator j;
+ iterator k;
+ value_type::reset();
+
+ list0101.push_back(value_type(1)); // list should be [1]
VERIFY(list0101.size() == 1);
- VERIFY(T::copyCount() == 1);
+ VERIFY(value_type::copyCount() == 1);
k = list0101.end();
--k;
VERIFY(k->id() == list0101.front().id());
VERIFY(k->id() == list0101.back().id());
- list0101.push_front(T(2)); // list should be [2 1]
+ list0101.push_front(value_type(2)); // list should be [2 1]
VERIFY(list0101.size() == 2);
- VERIFY(T::copyCount() == 2);
+ VERIFY(value_type::copyCount() == 2);
VERIFY(k->id() == 1);
- list0101.push_back(T(3)); // list should be [2 1 3]
+ list0101.push_back(value_type(3)); // list should be [2 1 3]
VERIFY(list0101.size() == 3);
- VERIFY(T::copyCount() == 3);
+ VERIFY(value_type::copyCount() == 3);
VERIFY(k->id() == 1);
try
{
- list0101.push_back(T(4, true));
+ list0101.push_back(value_type(4, true));
VERIFY(false);
}
catch (...)
{
VERIFY(list0101.size() == 3);
- VERIFY(T::copyCount() == 4);
+ VERIFY(value_type::copyCount() == 4);
}
i = list0101.begin();
++j;
VERIFY(j->id() == 1);
- T::reset();
+ value_type::reset();
list0101.pop_back(); // list should be [2 1]
VERIFY(list0101.size() == 2);
- VERIFY(T::dtorCount() == 1);
+ VERIFY(value_type::dtorCount() == 1);
VERIFY(i->id() == 1);
VERIFY(k->id() == 1);
list0101.pop_front(); // list should be [1]
VERIFY(list0101.size() == 1);
- VERIFY(T::dtorCount() == 2);
+ VERIFY(value_type::dtorCount() == 2);
VERIFY(i->id() == 1);
VERIFY(k->id() == 1);
}
int main()
{
- test01();
+ modifiers3<std::list<__gnu_test::copy_tracker> >();
return 0;
}
#include <ext/throw_allocator.h>
// libstdc++/25288
-void test01()
+template<typename _Tp>
+void insert1()
{
bool test __attribute__((unused)) = true;
- typedef int value_type;
- typedef __gnu_cxx::throw_allocator<value_type> allocator_type;
- typedef std::list<value_type, allocator_type> list_type;
+ typedef _Tp list_type;
+ typedef typename _Tp::value_type value_type;
+ typedef typename _Tp::allocator_type allocator_type;
+ typedef typename _Tp::size_type size_type;
for (int j = 0; j < 10; ++j)
for (int i = 0; i < 10; ++i)
{
allocator_type alloc1;
- allocator_type::zero_throw_prob_adjustor adjust1;
+ typename allocator_type::zero_throw_prob_adjustor adjust1;
list_type list1(alloc1);
for (int k = 0; k < j; ++k)
VERIFY( false );
}
- VERIFY( list1.size() == list_type::size_type(j) );
+ VERIFY( list1.size() == size_type(j) );
VERIFY( list1.size() == 0 || list1.back() == -j );
VERIFY( list1.size() == 0 || list1.front() == -1 );
allocator_type alloc2;
- allocator_type::zero_throw_prob_adjustor adjust2;
+ typename allocator_type::zero_throw_prob_adjustor adjust2;
list_type list2(alloc2);
const int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
VERIFY( false );
}
- VERIFY( list2.size() == list_type::size_type(j) );
+ VERIFY( list2.size() == size_type(j) );
VERIFY( list2.size() == 0 || list2.back() == -j );
VERIFY( list2.size() == 0 || list2.front() == -1 );
}
int main()
{
- test01();
+ typedef int value_type;
+ typedef __gnu_cxx::throw_allocator<value_type> allocator_type;
+ typedef std::list<value_type, allocator_type> list_type;
+
+ insert1<list_type>();
return 0;
}
}
// Should use list specialization for swap.
-void test01()
+template<typename _Tp>
+void
+swap11()
{
bool test __attribute__((unused)) = true;
- std::list<T> A;
- std::list<T> B;
+ typedef _Tp list_type;
+
+ list_type A;
+ list_type B;
swap_calls = 0;
std::swap(A, B);
VERIFY(1 == swap_calls);
}
// Should use list specialization for swap.
-void test02()
+template<typename _Tp>
+void
+swap12()
{
- bool test __attribute__((unused)) = true;
using namespace std;
- list<T> A;
- list<T> B;
+ bool test __attribute__((unused)) = true;
+ typedef _Tp list_type;
+
+ list_type A;
+ list_type B;
swap_calls = 0;
swap(A, B);
VERIFY(1 == swap_calls);
// See c++/13658 for background info.
int main()
{
- test01();
- test02();
+ swap11<std::list<T> >();
+ swap12<std::list<T> >();
return 0;
}
#include <testsuite_allocator.h>
// uneq_allocator as a non-empty allocator.
+template<typename _Tp>
void
-test01()
+swap2()
{
bool test __attribute__((unused)) = true;
using namespace std;
- typedef __gnu_test::uneq_allocator<char> my_alloc;
- typedef list<char, my_alloc> my_list;
+ typedef _Tp list_type;
+ typedef typename list_type::allocator_type allocator_type;
+ typedef typename list_type::size_type size_type;
const char title01[] = "Rivers of sand";
const char title02[] = "Concret PH";
const size_t N3 = sizeof(title03);
const size_t N4 = sizeof(title04);
- my_list::size_type size01, size02;
+ size_type size01, size02;
- my_alloc alloc01(1);
+ allocator_type alloc01(1);
- my_list lis01(alloc01);
+ list_type lis01(alloc01);
size01 = lis01.size();
- my_list lis02(alloc01);
+ list_type lis02(alloc01);
size02 = lis02.size();
lis01.swap(lis02);
VERIFY( lis02.size() == size01 );
VERIFY( lis02.empty() );
- my_list lis03(alloc01);
+ list_type lis03(alloc01);
size01 = lis03.size();
- my_list lis04(title02, title02 + N2, alloc01);
+ list_type lis04(title02, title02 + N2, alloc01);
size02 = lis04.size();
lis03.swap(lis04);
VERIFY( lis04.size() == size01 );
VERIFY( lis04.empty() );
- my_list lis05(title01, title01 + N1, alloc01);
+ list_type lis05(title01, title01 + N1, alloc01);
size01 = lis05.size();
- my_list lis06(title02, title02 + N2, alloc01);
+ list_type lis06(title02, title02 + N2, alloc01);
size02 = lis06.size();
lis05.swap(lis06);
VERIFY( lis06.size() == size01 );
VERIFY( equal(lis06.begin(), lis06.end(), title01) );
- my_list lis07(title01, title01 + N1, alloc01);
+ list_type lis07(title01, title01 + N1, alloc01);
size01 = lis07.size();
- my_list lis08(title03, title03 + N3, alloc01);
+ list_type lis08(title03, title03 + N3, alloc01);
size02 = lis08.size();
lis07.swap(lis08);
VERIFY( lis08.size() == size01 );
VERIFY( equal(lis08.begin(), lis08.end(), title01) );
- my_list lis09(title03, title03 + N3, alloc01);
+ list_type lis09(title03, title03 + N3, alloc01);
size01 = lis09.size();
- my_list lis10(title04, title04 + N4, alloc01);
+ list_type lis10(title04, title04 + N4, alloc01);
size02 = lis10.size();
lis09.swap(lis10);
VERIFY( lis10.size() == size01 );
VERIFY( equal(lis10.begin(), lis10.end(), title03) );
- my_list lis11(title04, title04 + N4, alloc01);
+ list_type lis11(title04, title04 + N4, alloc01);
size01 = lis11.size();
- my_list lis12(title01, title01 + N1, alloc01);
+ list_type lis12(title01, title01 + N1, alloc01);
size02 = lis12.size();
lis11.swap(lis12);
VERIFY( lis12.size() == size01 );
VERIFY( equal(lis12.begin(), lis12.end(), title04) );
- my_list lis13(title03, title03 + N3, alloc01);
+ list_type lis13(title03, title03 + N3, alloc01);
size01 = lis13.size();
- my_list lis14(title03, title03 + N3, alloc01);
+ list_type lis14(title03, title03 + N3, alloc01);
size02 = lis14.size();
lis13.swap(lis14);
int main()
{
- test01();
+ typedef char value_type;
+ typedef __gnu_test::uneq_allocator<value_type> allocator_type;
+ typedef std::list<value_type, allocator_type> list_type;
+
+ swap2<list_type>();
return 0;
}
#include <testsuite_allocator.h>
// uneq_allocator, two different personalities.
+template<typename _Tp>
void
-test01()
+swap3()
{
bool test __attribute__((unused)) = true;
using namespace std;
- typedef __gnu_test::uneq_allocator<char> my_alloc;
- typedef list<char, my_alloc> my_list;
+ typedef _Tp list_type;
+ typedef typename list_type::allocator_type allocator_type;
+ typedef typename list_type::size_type size_type;
const char title01[] = "Rivers of sand";
const char title02[] = "Concret PH";
const size_t N3 = sizeof(title03);
const size_t N4 = sizeof(title04);
- my_list::size_type size01, size02;
+ size_type size01, size02;
- my_alloc alloc01(1), alloc02(2);
+ allocator_type alloc01(1), alloc02(2);
int personality01, personality02;
- my_list lis01(alloc01);
+ list_type lis01(alloc01);
size01 = lis01.size();
personality01 = lis01.get_allocator().get_personality();
- my_list lis02(alloc02);
+ list_type lis02(alloc02);
size02 = lis02.size();
personality02 = lis02.get_allocator().get_personality();
VERIFY( lis01.get_allocator().get_personality() == personality02 );
VERIFY( lis02.get_allocator().get_personality() == personality01 );
- my_list lis03(alloc02);
+ list_type lis03(alloc02);
size01 = lis03.size();
personality01 = lis03.get_allocator().get_personality();
- my_list lis04(title02, title02 + N2, alloc01);
+ list_type lis04(title02, title02 + N2, alloc01);
size02 = lis04.size();
personality02 = lis04.get_allocator().get_personality();
VERIFY( lis03.get_allocator().get_personality() == personality02 );
VERIFY( lis04.get_allocator().get_personality() == personality01 );
- my_list lis05(title01, title01 + N1, alloc01);
+ list_type lis05(title01, title01 + N1, alloc01);
size01 = lis05.size();
personality01 = lis05.get_allocator().get_personality();
- my_list lis06(title02, title02 + N2, alloc02);
+ list_type lis06(title02, title02 + N2, alloc02);
size02 = lis06.size();
personality02 = lis06.get_allocator().get_personality();
VERIFY( lis05.get_allocator().get_personality() == personality02 );
VERIFY( lis06.get_allocator().get_personality() == personality01 );
- my_list lis07(title01, title01 + N1, alloc02);
+ list_type lis07(title01, title01 + N1, alloc02);
size01 = lis07.size();
personality01 = lis07.get_allocator().get_personality();
- my_list lis08(title03, title03 + N3, alloc01);
+ list_type lis08(title03, title03 + N3, alloc01);
size02 = lis08.size();
personality02 = lis08.get_allocator().get_personality();
VERIFY( lis07.get_allocator().get_personality() == personality02 );
VERIFY( lis08.get_allocator().get_personality() == personality01 );
- my_list lis09(title03, title03 + N3, alloc01);
+ list_type lis09(title03, title03 + N3, alloc01);
size01 = lis09.size();
personality01 = lis09.get_allocator().get_personality();
- my_list lis10(title04, title04 + N4, alloc02);
+ list_type lis10(title04, title04 + N4, alloc02);
size02 = lis10.size();
personality02 = lis10.get_allocator().get_personality();
VERIFY( lis09.get_allocator().get_personality() == personality02 );
VERIFY( lis10.get_allocator().get_personality() == personality01 );
- my_list lis11(title04, title04 + N4, alloc02);
+ list_type lis11(title04, title04 + N4, alloc02);
size01 = lis11.size();
personality01 = lis11.get_allocator().get_personality();
- my_list lis12(title01, title01 + N1, alloc01);
+ list_type lis12(title01, title01 + N1, alloc01);
size02 = lis12.size();
personality02 = lis12.get_allocator().get_personality();
VERIFY( lis11.get_allocator().get_personality() == personality02 );
VERIFY( lis12.get_allocator().get_personality() == personality01 );
- my_list lis13(title03, title03 + N3, alloc01);
+ list_type lis13(title03, title03 + N3, alloc01);
size01 = lis13.size();
personality01 = lis13.get_allocator().get_personality();
- my_list lis14(title03, title03 + N3, alloc02);
+ list_type lis14(title03, title03 + N3, alloc02);
size02 = lis14.size();
personality02 = lis14.get_allocator().get_personality();
int main()
{
- test01();
+ typedef char value_type;
+ typedef __gnu_test::uneq_allocator<value_type> allocator_type;
+ typedef std::list<value_type, allocator_type> list_type;
+
+ swap3<list_type>();
return 0;
}
// { dg-options "-std=gnu++0x" }
-// Copyright (C) 2005, 2007, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
-
// NOTE: This makes use of the fact that we know how moveable
// is implemented on list (via swap). If the implementation changed
// this test may begin to fail.
#include <utility>
#include <testsuite_hooks.h>
+template<typename _Tp>
+ void
+ test_moveable()
+ {
+ bool test __attribute__((unused)) = true;
+
+ typedef _Tp list_type;
+
+ list_type a,b;
+ a.push_back(1);
+ b = std::move(a);
+ VERIFY( b.size() == 1 && *b.begin() == 1 && a.size() == 0 );
+
+ list_type c(std::move(b));
+ VERIFY( c.size() == 1 && *c.begin() == 1 );
+ VERIFY( b.size() == 0 );
+ }
+
int main()
{
- bool test __attribute__((unused)) = true;
-
- std::list<int> a,b;
- a.push_back(1);
- b = std::move(a);
- VERIFY( b.size() == 1 && *b.begin() == 1 && a.size() == 0 );
-
- std::list<int> c(std::move(b));
- VERIFY( c.size() == 1 && *c.begin() == 1 );
- VERIFY( b.size() == 0 );
+ test_moveable<std::list<int> >();
return 0;
}
#include <list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
// splice(p, x) + remove + reverse
+template<typename _Tp>
void
-test01()
+operations01()
{
+ bool test __attribute__((unused)) = true;
+ typedef _Tp list_type;
+ typedef typename list_type::iterator iterator;
+
const int K = 417;
const int A[] = {1, 2, 3, 4, 5};
const int B[] = {K, K, K, K, K};
const std::size_t N = sizeof(A) / sizeof(int);
const std::size_t M = sizeof(B) / sizeof(int);
- std::list<int> list0101(A, A + N);
- std::list<int> list0102(B, B + M);
- std::list<int>::iterator p = list0101.begin();
+ list_type list0101(A, A + N);
+ list_type list0102(B, B + M);
+ iterator p = list0101.begin();
VERIFY(list0101.size() == N);
VERIFY(list0102.size() == M);
VERIFY(p == list0101.end());
}
-int main(void)
+int main()
{
- test01();
+ operations01<std::list<int> >();
return 0;
}
#include <list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
// splice(p, x, i) + remove_if + operator==
+template<typename _Tp>
void
-test02()
+operations02()
{
+ bool test __attribute__((unused)) = true;
+ typedef _Tp list_type;
+ typedef typename list_type::iterator iterator;
+
const int A[] = {1, 2, 3, 4, 5};
const int B[] = {2, 1, 3, 4, 5};
const int C[] = {1, 3, 4, 5, 2};
const int N = sizeof(A) / sizeof(int);
- std::list<int> list0201(A, A + N);
- std::list<int> list0202(A, A + N);
- std::list<int> list0203(B, B + N);
- std::list<int> list0204(C, C + N);
- std::list<int>::iterator i = list0201.begin();
+ list_type list0201(A, A + N);
+ list_type list0202(A, A + N);
+ list_type list0203(B, B + N);
+ list_type list0204(C, C + N);
+ iterator i = list0201.begin();
// result should be unchanged
list0201.splice(list0201.begin(), list0201, i);
int main()
{
- test02();
+ operations02<std::list<int> >();
return 0;
}
#include <list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
// splice(p, x, f, l) + sort + merge + unique
+template<typename _Tp>
void
-test03()
+operations03()
{
+ bool test __attribute__((unused)) = true;
+ typedef _Tp list_type;
+ typedef typename list_type::iterator iterator;
+
const int A[] = {103, 203, 603, 303, 403, 503};
const int B[] = {417, 417, 417, 417, 417};
const int E[] = {103, 417, 417, 203, 603, 303, 403, 503};
const int Q = sizeof(D) / sizeof(int);
const int R = sizeof(E) / sizeof(int);
- std::list<int> list0301(A, A + N);
- std::list<int> list0302(B, B + M);
- std::list<int> list0303(C, C + P);
- std::list<int> list0304(D, D + Q);
- std::list<int> list0305(E, E + R);
- std::list<int> list0306(F, F + R);
- std::list<int>::iterator p = list0301.begin();
- std::list<int>::iterator q = list0302.begin();
+ list_type list0301(A, A + N);
+ list_type list0302(B, B + M);
+ list_type list0303(C, C + P);
+ list_type list0304(D, D + Q);
+ list_type list0305(E, E + R);
+ list_type list0306(F, F + R);
+ iterator p = list0301.begin();
+ iterator q = list0302.begin();
++p; ++q; ++q;
list0301.splice(p, list0302, list0302.begin(), q);
int main(void)
{
- test03();
+ operations03<std::list<int> >();
return 0;
}
#include <list>
#include <testsuite_hooks.h>
-bool test __attribute__((unused)) = true;
-
-// A comparison predicate to order by rightmost digit. Tracks call counts for
-// performance checks.
+// A comparison predicate to order by rightmost digit. Tracks call
+// counts for performance checks.
struct CompLastLt
{
bool operator()(const int x, const int y)
// sort(pred) + merge(pred) + unique(pred)
// also checks performance requirements
+template<typename _Tp>
void
-test04()
+operations04()
{
+ bool test __attribute__((unused)) = true;
+ typedef _Tp list_type;
+
const int A[] = {1, 2, 3, 4, 5, 6};
const int B[] = {12, 15, 13, 14, 11};
const int C[] = {11, 12, 13, 14, 15};
const int M = sizeof(B) / sizeof(int);
const int Q = sizeof(D) / sizeof(int);
- std::list<int> list0401(A, A + N);
- std::list<int> list0402(B, B + M);
- std::list<int> list0403(C, C + M);
- std::list<int> list0404(D, D + Q);
- std::list<int> list0405(A, A + N);
+ list_type list0401(A, A + N);
+ list_type list0402(B, B + M);
+ list_type list0403(C, C + M);
+ list_type list0404(D, D + Q);
+ list_type list0405(A, A + N);
// sort B
CompLastLt lt;
int main()
{
- test04();
+ operations04<std::list<int> >();
return 0;
}
#include <testsuite_allocator.h>
// Check the splice (and merge) bits of N1599.
+template<typename _Tp>
void
-test01()
+operations05()
{
bool test __attribute__((unused)) = true;
- typedef __gnu_test::uneq_allocator<int> my_alloc;
- typedef std::list<int, my_alloc> my_list;
+ typedef _Tp list_type;
+ typedef typename list_type::allocator_type allocator_type;
const int data1[] = {1, 2, 3, 4, 5};
const int data2[] = {6, 7, 8, 9, 10};
const size_t N1 = sizeof(data1) / sizeof(int);
const size_t N2 = sizeof(data2) / sizeof(int);
- my_alloc alloc01(1), alloc02(2);
+ allocator_type alloc01(1), alloc02(2);
- my_list l01(data1, data1 + N1, alloc01);
- const my_list l01_ref = l01;
+ list_type l01(data1, data1 + N1, alloc01);
+ const list_type l01_ref = l01;
- my_list l02(data2, data2 + N2, alloc02);
- const my_list l02_ref = l02;
+ list_type l02(data2, data2 + N2, alloc02);
+ const list_type l02_ref = l02;
bool catched = false;
int main()
{
- test01();
+ typedef int value_type;
+ typedef __gnu_test::uneq_allocator<value_type> allocator_type;
+ typedef std::list<value_type, allocator_type> list_type;
+
+ operations05<list_type>();
return 0;
}
#include <cstdlib>
#include <pthread.h>
-using namespace std;
-
const int thread_cycles = 10;
const int thread_pairs = 10;
const unsigned max_size = 100;
class task_queue
{
+ typedef std::list<int> list_type;
+
public:
task_queue ()
{
pthread_cond_destroy (&fooCond1);
pthread_cond_destroy (&fooCond2);
}
- list<int> foo;
- pthread_mutex_t fooLock;
- pthread_cond_t fooCond1;
- pthread_cond_t fooCond2;
+
+ list_type foo;
+ pthread_mutex_t fooLock;
+ pthread_cond_t fooCond1;
+ pthread_cond_t fooCond2;
};
void*
-produce (void* t)
+produce(void* t)
{
task_queue& tq = *(static_cast<task_queue*> (t));
int num = 0;
}
void*
-consume (void* t)
+consume(void* t)
{
task_queue& tq = *(static_cast<task_queue*> (t));
int num = 0;
}
int
-main ()
+main()
{
pthread_t prod[thread_pairs];
pthread_t cons[thread_pairs];
#include <unistd.h> // To test for _POSIX_THREAD_PRIORITY_SCHEDULING
#endif
-using namespace std;
-
#define NTHREADS 8
#define LOOPS 20
void*
thread_function (void* arg)
{
+ typedef std::vector<tt_t> vector_type;
+ typedef std::list<std::string*> list_type;
+
int myid __attribute__((unused)) = *(int*) arg;
for (int i = 0; i < LOOPS; i++)
{
- vector<tt_t> myvect1;
+ vector_type myvect1;
for (int j = 0; j < 2000; j++)
{
- vector<tt_t> myvect2;
+ vector_type myvect2;
tt_t v;
v.i = j;
myvect1.push_back (v);
myvect2.push_back (v);
- list<std::string *> mylist;
+ list_type mylist;
std::string string_array[4];
string_array[0] = "toto";
string_array[1] = "titi";
{
if (mylist.size ())
{
- list<std::string *>::iterator aIt;
+ list_type::iterator aIt;
for (aIt = mylist.begin (); aIt != mylist.end (); ++aIt)
{
if ((*aIt) == &(string_array[k]))
{
bool test __attribute__((unused)) = true;
- std::list<int> l(7);
+ typedef std::list<int> list_type;
+ list_type l(7);
+
VERIFY( l.cbegin() == l.begin() );
VERIFY( l.cend() == l.end() );
VERIFY( l.crbegin() == l.rbegin() );
void f()
{
- std::list<A> l;
+ typedef std::list<A> list_type;
+ list_type l;
l.assign(10, 1);
}
void f()
{
- std::list<int> l(10, 1);
+ typedef std::list<int> list_type;
+ list_type l(10, 1);
}
void f()
{
- std::list<std::list<int> > l(10, 1);
+ typedef std::list<std::list<int> > list_type;
+ list_type l(10, 1);
}
void f()
{
- std::list<std::list<std::pair<char, char> > > l('a', 'b');
+ typedef std::list<std::list<std::pair<char, char> > > list_type;
+ list_type l('a', 'b');
}
void f()
{
- std::list<A> l;
+ typedef std::list<A> list_type;
+ list_type l;
l.insert(l.begin(), 10, 1);
}
namespace std
{
template<typename Allocator>
- class list<user_type, Allocator> {};
+ class list<user_type, Allocator> { };
}
typedef typename __gnu_cxx::typelist::create1<cnt_5_u>::type lu_policy1;
typedef
- typename __gnu_cxx::typelist::create2<
- lu_policy0,
- lu_policy1>::type
+ typename __gnu_cxx::typelist::create2<lu_policy0, lu_policy1>::type
lu_policies;
template<typename Policy_Tl>
{
private:
typedef
- typename __gnu_cxx::typelist::at_index<
- Policy_Tl, 0>::type
+ typename __gnu_cxx::typelist::at_index<Policy_Tl, 0>::type
update_policy_t;
public:
typedef
- __gnu_pbds::list_update<
- Key,
- Data,
- Eq_Fn,
- update_policy_t,
- Allocator>
+ __gnu_pbds::list_update<Key, Data, Eq_Fn, update_policy_t, Allocator>
type;
};
OSDN Git Service
