generic-library/cxx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Implement full support for non-pointer pointers in custom allocators for list.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@184859 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Howard Hinnant
2013-06-25 16:08:47 +00:00
parent 81381a932f
commit 29f7432ff3
65 changed files with 2001 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
test/containers/sequences/list/db_back.pass.cpp
View File

@@ -21,8 +21,11 @@
#include <exception>
#include <cstdlib>
#include "../../min_allocator.h"
int main()
{
{
typedef int T;
typedef std::list<T> C;
C c(1);
@@ -30,6 +33,18 @@ int main()
c.clear();
assert(c.back() == 0);
assert(false);
}
#if __cplusplus >= 201103L
{
typedef int T;
typedef std::list<T, min_allocator<T>> C;
C c(1);
assert(c.back() == 0);
c.clear();
assert(c.back() == 0);
assert(false);
}
#endif
}
#else

13
test/containers/sequences/list/db_cback.pass.cpp
View File

@@ -21,13 +21,26 @@
#include <exception>
#include <cstdlib>
#include "../../min_allocator.h"
int main()
{
{
typedef int T;
typedef std::list<T> C;
const C c;
assert(c.back() == 0);
assert(false);
}
#if __cplusplus >= 201103L
{
typedef int T;
typedef std::list<T, min_allocator<T>> C;
const C c;
assert(c.back() == 0);
assert(false);
}
#endif
}
#else

13
test/containers/sequences/list/db_cfront.pass.cpp
View File

@@ -21,13 +21,26 @@
#include <exception>
#include <cstdlib>
#include "../../min_allocator.h"
int main()
{
{
typedef int T;
typedef std::list<T> C;
const C c;
assert(c.front() == 0);
assert(false);
}
#if __cplusplus >= 201103L
{
typedef int T;
typedef std::list<T, min_allocator<T>> C;
const C c;
assert(c.front() == 0);
assert(false);
}
#endif
}
#else

15
test/containers/sequences/list/db_front.pass.cpp
View File

@@ -21,8 +21,11 @@
#include <exception>
#include <cstdlib>
#include "../../min_allocator.h"
int main()
{
{
typedef int T;
typedef std::list<T> C;
C c(1);
@@ -30,6 +33,18 @@ int main()
c.clear();
assert(c.front() == 0);
assert(false);
}
#if __cplusplus >= 201103L
{
typedef int T;
typedef std::list<T, min_allocator<T>> C;
C c(1);
assert(c.front() == 0);
c.clear();
assert(c.front() == 0);
assert(false);
}
#endif
}
#else

14
test/containers/sequences/list/db_iterators_1.pass.cpp
View File

@@ -21,14 +21,28 @@
#include <exception>
#include <cstdlib>
#include "../../min_allocator.h"
int main()
{
{
typedef int T;
typedef std::list<T> C;
C c1;
C c2;
bool b = c1.begin() != c2.begin();
assert(false);
}
#if __cplusplus >= 201103L
{
typedef int T;
typedef std::list<T, min_allocator<T>> C;
C c1;
C c2;
bool b = c1.begin() != c2.begin();
assert(false);
}
#endif
}
#else

16
test/containers/sequences/list/db_iterators_6.pass.cpp
View File

@@ -21,8 +21,11 @@
#include <exception>
#include <cstdlib>
#include "../../min_allocator.h"
int main()
{
{
typedef int T;
typedef std::list<T> C;
C c(1);
@@ -31,6 +34,19 @@ int main()
assert(i == c.begin());
--i;
assert(false);
}
#if __cplusplus >= 201103L
{
typedef int T;
typedef std::list<T, min_allocator<T>> C;
C c(1);
C::iterator i = c.end();
--i;
assert(i == c.begin());
--i;
assert(false);
}
#endif
}
#else

16
test/containers/sequences/list/db_iterators_7.pass.cpp
View File

@@ -21,8 +21,11 @@
#include <exception>
#include <cstdlib>
#include "../../min_allocator.h"
int main()
{
{
typedef int T;
typedef std::list<T> C;
C c(1);
@@ -31,6 +34,19 @@ int main()
assert(i == c.end());
++i;
assert(false);
}
#if __cplusplus >= 201103L
{
typedef int T;
typedef std::list<T, min_allocator<T>> C;
C c(1);
C::iterator i = c.begin();
++i;
assert(i == c.end());
++i;
assert(false);
}
#endif
}
#else

14
test/containers/sequences/list/db_iterators_8.pass.cpp
View File

@@ -21,14 +21,28 @@
#include <exception>
#include <cstdlib>
#include "../../min_allocator.h"
int main()
{
{
typedef int T;
typedef std::list<T> C;
C c(1);
C::iterator i = c.end();
T j = *i;
assert(false);
}
#if __cplusplus >= 201103L
{
typedef int T;
typedef std::list<T, min_allocator<T>> C;
C c(1);
C::iterator i = c.end();
T j = *i;
assert(false);
}
#endif
}
#else

66
test/containers/sequences/list/iterators.pass.cpp
View File

@@ -20,6 +20,14 @@
#include <cassert>
#include <iterator>
#include "../../min_allocator.h"
struct A
{
int first;
int second;
};
int main()
{
{
@@ -69,4 +77,62 @@ int main()
C::iterator i;
C::const_iterator j;
}
#if __cplusplus >= 201103L
{
typedef int T;
typedef std::list<T, min_allocator<T>> C;
C c;
C::iterator i = c.begin();
C::iterator j = c.end();
assert(std::distance(i, j) == 0);
assert(i == j);
}
{
typedef int T;
typedef std::list<T, min_allocator<T>> C;
const C c;
C::const_iterator i = c.begin();
C::const_iterator j = c.end();
assert(std::distance(i, j) == 0);
assert(i == j);
}
{
typedef int T;
typedef std::list<T, min_allocator<T>> C;
C c;
C::const_iterator i = c.cbegin();
C::const_iterator j = c.cend();
assert(std::distance(i, j) == 0);
assert(i == j);
assert(i == c.end());
}
{
typedef int T;
typedef std::list<T, min_allocator<T>> C;
const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
C c(std::begin(t), std::end(t));
C::iterator i = c.begin();
assert(*i == 0);
++i;
assert(*i == 1);
*i = 10;
assert(*i == 10);
assert(std::distance(c.begin(), c.end()) == 10);
}
{
typedef int T;
typedef std::list<T, min_allocator<T>> C;
C::iterator i;
C::const_iterator j;
}
{
typedef A T;
typedef std::list<T, min_allocator<T>> C;
C c = {A{1, 2}};
C::iterator i = c.begin();
i->first = 3;
C::const_iterator j = i;
assert(j->first == 3);
}
#endif
}

32
test/containers/sequences/list/list.capacity/resize_size.pass.cpp
View File

@@ -14,6 +14,7 @@
#include <list>
#include <cassert>
#include "../../../DefaultOnly.h"
#include "../../../min_allocator.h"
int main()
{
@@ -46,4 +47,35 @@ int main()
assert(std::distance(l.begin(), l.end()) == 20);
}
#endif // __LIBCPP_MOVE
#if __cplusplus >= 201103L
{
std::list<int, min_allocator<int>> l(5, 2);
l.resize(2);
assert(l.size() == 2);
assert(std::distance(l.begin(), l.end()) == 2);
assert((l == std::list<int, min_allocator<int>>(2, 2)));
}
{
std::list<int, min_allocator<int>> l(5, 2);
l.resize(10);
assert(l.size() == 10);
assert(std::distance(l.begin(), l.end()) == 10);
assert(l.front() == 2);
assert(l.back() == 0);
}
#ifdef __LIBCPP_MOVE
{
std::list<DefaultOnly, min_allocator<DefaultOnly>> l(10);
l.resize(5);
assert(l.size() == 5);
assert(std::distance(l.begin(), l.end()) == 5);
}
{
std::list<DefaultOnly, min_allocator<DefaultOnly>> l(10);
l.resize(20);
assert(l.size() == 20);
assert(std::distance(l.begin(), l.end()) == 20);
}
#endif // __LIBCPP_MOVE
#endif
}

18
test/containers/sequences/list/list.capacity/resize_size_value.pass.cpp
View File

@@ -14,6 +14,7 @@
#include <list>
#include <cassert>
#include "../../../DefaultOnly.h"
#include "../../../min_allocator.h"
int main()
{
@@ -32,4 +33,21 @@ int main()
assert(l.front() == 2);
assert(l.back() == 3.5);
}
#if __cplusplus >= 201103L
{
std::list<double, min_allocator<double>> l(5, 2);
l.resize(2, 3.5);
assert(l.size() == 2);
assert(std::distance(l.begin(), l.end()) == 2);
assert((l == std::list<double, min_allocator<double>>(2, 2)));
}
{
std::list<double, min_allocator<double>> l(5, 2);
l.resize(10, 3.5);
assert(l.size() == 10);
assert(std::distance(l.begin(), l.end()) == 10);
assert(l.front() == 2);
assert(l.back() == 3.5);
}
#endif
}

10
test/containers/sequences/list/list.cons/assign_copy.pass.cpp
View File

@@ -14,6 +14,7 @@
#include <list>
#include <cassert>
#include "../../../test_allocator.h"
#include "../../../min_allocator.h"
int main()
{
@@ -31,4 +32,13 @@ int main()
assert(l2 == l);
assert(l2.get_allocator() == other_allocator<int>(5));
}
#if __cplusplus >= 201103L
{
std::list<int, min_allocator<int> > l(3, 2, min_allocator<int>());
std::list<int, min_allocator<int> > l2(l, min_allocator<int>());
l2 = l;
assert(l2 == l);
assert(l2.get_allocator() == min_allocator<int>());
}
#endif
}

16
test/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp
View File

@@ -14,9 +14,12 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
int main()
{
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
{
std::list<int> d;
d.assign({3, 4, 5, 6});
assert(d.size() == 4);
@@ -25,5 +28,18 @@ int main()
assert(*i++ == 4);
assert(*i++ == 5);
assert(*i++ == 6);
}
#if __cplusplus >= 201103L
{
std::list<int, min_allocator<int>> d;
d.assign({3, 4, 5, 6});
assert(d.size() == 4);
std::list<int, min_allocator<int>>::iterator i = d.begin();
assert(*i++ == 3);
assert(*i++ == 4);
assert(*i++ == 5);
assert(*i++ == 6);
}
#endif
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

17
test/containers/sequences/list/list.cons/assign_move.pass.cpp
View File

@@ -15,6 +15,7 @@
#include <cassert>
#include "../../../MoveOnly.h"
#include "../../../test_allocator.h"
#include "../../../min_allocator.h"
int main()
{
@@ -61,5 +62,21 @@ int main()
assert(l.empty());
assert(l2.get_allocator() == lo.get_allocator());
}
#if __cplusplus >= 201103L
{
std::list<MoveOnly, min_allocator<MoveOnly> > l(min_allocator<MoveOnly>{});
std::list<MoveOnly, min_allocator<MoveOnly> > lo(min_allocator<MoveOnly>{});
for (int i = 1; i <= 3; ++i)
{
l.push_back(i);
lo.push_back(i);
}
std::list<MoveOnly, min_allocator<MoveOnly> > l2(min_allocator<MoveOnly>{});
l2 = std::move(l);
assert(l2 == lo);
assert(l.empty());
assert(l2.get_allocator() == lo.get_allocator());
}
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}

14
test/containers/sequences/list/list.cons/copy.pass.cpp
View File

@@ -15,6 +15,7 @@
#include <cassert>
#include "../../../DefaultOnly.h"
#include "../../../test_allocator.h"
#include "../../../min_allocator.h"
int main()
{
@@ -37,4 +38,17 @@ int main()
assert(l2.get_allocator() == other_allocator<int>(-2));
}
#endif // _LIBCPP_HAS_NO_ADVANCED_SFINAE
#if __cplusplus >= 201103L
{
std::list<int, min_allocator<int>> l(3, 2);
std::list<int, min_allocator<int>> l2 = l;
assert(l2 == l);
}
{
std::list<int, min_allocator<int> > l(3, 2, min_allocator<int>());
std::list<int, min_allocator<int> > l2 = l;
assert(l2 == l);
assert(l2.get_allocator() == l.get_allocator());
}
#endif
}

9
test/containers/sequences/list/list.cons/copy_alloc.pass.cpp
View File

@@ -15,6 +15,7 @@
#include <cassert>
#include "../../../DefaultOnly.h"
#include "../../../test_allocator.h"
#include "../../../min_allocator.h"
int main()
{
@@ -30,4 +31,12 @@ int main()
assert(l2 == l);
assert(l2.get_allocator() == other_allocator<int>(3));
}
#if __cplusplus >= 201103L
{
std::list<int, min_allocator<int> > l(3, 2, min_allocator<int>());
std::list<int, min_allocator<int> > l2(l, min_allocator<int>());
assert(l2 == l);
assert(l2.get_allocator() == min_allocator<int>());
}
#endif
}

18
test/containers/sequences/list/list.cons/default.pass.cpp
View File

@@ -14,6 +14,7 @@
#include <list>
#include <cassert>
#include "../../../DefaultOnly.h"
#include "../../../min_allocator.h"
int main()
{
@@ -32,4 +33,21 @@ int main()
assert(l.size() == 0);
assert(std::distance(l.begin(), l.end()) == 0);
}
#if __cplusplus >= 201103L
{
std::list<int, min_allocator<int>> l;
assert(l.size() == 0);
assert(std::distance(l.begin(), l.end()) == 0);
}
{
std::list<DefaultOnly, min_allocator<DefaultOnly>> l;
assert(l.size() == 0);
assert(std::distance(l.begin(), l.end()) == 0);
}
{
std::list<int, min_allocator<int>> l((min_allocator<int>()));
assert(l.size() == 0);
assert(std::distance(l.begin(), l.end()) == 0);
}
#endif
}

15
test/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp
View File

@@ -14,8 +14,7 @@
#include <list>
#include <cassert>
#include "../../../stack_allocator.h"
#include <iostream>
#include "../../../min_allocator.h"
int main()
{
@@ -34,4 +33,16 @@ int main()
assert(l.size() == 0);
assert(std::distance(l.begin(), l.end()) == 0);
}
#if __cplusplus >= 201103L
{
std::list<int, min_allocator<int>> l;
assert(l.size() == 0);
assert(std::distance(l.begin(), l.end()) == 0);
}
{
std::list<int, min_allocator<int>> l((min_allocator<int>()));
assert(l.size() == 0);
assert(std::distance(l.begin(), l.end()) == 0);
}
#endif
}

15
test/containers/sequences/list/list.cons/initializer_list.pass.cpp
View File

@@ -14,9 +14,12 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
int main()
{
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
{
std::list<int> d = {3, 4, 5, 6};
assert(d.size() == 4);
std::list<int>::iterator i = d.begin();
@@ -24,5 +27,17 @@ int main()
assert(*i++ == 4);
assert(*i++ == 5);
assert(*i++ == 6);
}
#if __cplusplus >= 201103L
{
std::list<int, min_allocator<int>> d = {3, 4, 5, 6};
assert(d.size() == 4);
std::list<int, min_allocator<int>>::iterator i = d.begin();
assert(*i++ == 3);
assert(*i++ == 4);
assert(*i++ == 5);
assert(*i++ == 6);
}
#endif
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

15
test/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp
View File

@@ -15,10 +15,12 @@
#include <cassert>
#include "../../../test_allocator.h"
#include "../../../min_allocator.h"
int main()
{
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
{
std::list<int, test_allocator<int>> d({3, 4, 5, 6}, test_allocator<int>(3));
assert(d.get_allocator() == test_allocator<int>(3));
assert(d.size() == 4);
@@ -27,5 +29,18 @@ int main()
assert(*i++ == 4);
assert(*i++ == 5);
assert(*i++ == 6);
}
#if __cplusplus >= 201103L
{
std::list<int, min_allocator<int>> d({3, 4, 5, 6}, min_allocator<int>());
assert(d.get_allocator() == min_allocator<int>());
assert(d.size() == 4);
std::list<int, min_allocator<int>>::iterator i = d.begin();
assert(*i++ == 3);
assert(*i++ == 4);
assert(*i++ == 5);
assert(*i++ == 6);
}
#endif
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

24
test/containers/sequences/list/list.cons/input_iterator.pass.cpp
View File

@@ -16,6 +16,7 @@
#include <cassert>
#include "test_iterators.h"
#include "../../../stack_allocator.h"
#include "../../../min_allocator.h"
int main()
{
@@ -50,4 +51,27 @@ int main()
for (std::list<int>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
assert(*i == j);
}
#if __cplusplus >= 201103L
{
int a[] = {0, 1, 2, 3};
std::list<int, min_allocator<int>> l(input_iterator<const int*>(a),
input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])));
assert(l.size() == sizeof(a)/sizeof(a[0]));
assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
int j = 0;
for (std::list<int, min_allocator<int>>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
assert(*i == j);
}
{
int a[] = {0, 1, 2, 3};
std::list<int, min_allocator<int>> l(input_iterator<const int*>(a),
input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])),
min_allocator<int>());
assert(l.size() == sizeof(a)/sizeof(a[0]));
assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
int j = 0;
for (std::list<int, min_allocator<int>>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
assert(*i == j);
}
#endif
}

16
test/containers/sequences/list/list.cons/move.pass.cpp
View File

@@ -15,6 +15,7 @@
#include <cassert>
#include "../../../MoveOnly.h"
#include "../../../test_allocator.h"
#include "../../../min_allocator.h"
int main()
{
@@ -45,5 +46,20 @@ int main()
assert(l.empty());
assert(l2.get_allocator() == lo.get_allocator());
}
#if __cplusplus >= 201103L
{
std::list<MoveOnly, min_allocator<MoveOnly> > l(min_allocator<MoveOnly>{});
std::list<MoveOnly, min_allocator<MoveOnly> > lo(min_allocator<MoveOnly>{});
for (int i = 1; i <= 3; ++i)
{
l.push_back(i);
lo.push_back(i);
}
std::list<MoveOnly, min_allocator<MoveOnly> > l2 = std::move(l);
assert(l2 == lo);
assert(l.empty());
assert(l2.get_allocator() == lo.get_allocator());
}
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}

16
test/containers/sequences/list/list.cons/move_alloc.pass.cpp
View File

@@ -15,6 +15,7 @@
#include <cassert>
#include "../../../MoveOnly.h"
#include "../../../test_allocator.h"
#include "../../../min_allocator.h"
int main()
{
@@ -58,5 +59,20 @@ int main()
assert(!l.empty());
assert(l2.get_allocator() == other_allocator<MoveOnly>(4));
}
#if __cplusplus >= 201103L
{
std::list<MoveOnly, min_allocator<MoveOnly> > l(min_allocator<MoveOnly>{});
std::list<MoveOnly, min_allocator<MoveOnly> > lo(min_allocator<MoveOnly>{});
for (int i = 1; i <= 3; ++i)
{
l.push_back(i);
lo.push_back(i);
}
std::list<MoveOnly, min_allocator<MoveOnly> > l2(std::move(l), min_allocator<MoveOnly>());
assert(l2 == lo);
assert(l.empty());
assert(l2.get_allocator() == min_allocator<MoveOnly>());
}
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}

15
test/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp
View File

@@ -13,10 +13,12 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
int main()
{
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
{
std::list<int> d;
d = {3, 4, 5, 6};
assert(d.size() == 4);
@@ -25,5 +27,18 @@ int main()
assert(*i++ == 4);
assert(*i++ == 5);
assert(*i++ == 6);
}
#if __cplusplus >= 201103L
{
std::list<int, min_allocator<int>> d;
d = {3, 4, 5, 6};
assert(d.size() == 4);
std::list<int, min_allocator<int>>::iterator i = d.begin();
assert(*i++ == 3);
assert(*i++ == 4);
assert(*i++ == 5);
assert(*i++ == 6);
}
#endif
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

21
test/containers/sequences/list/list.cons/size_type.pass.cpp
View File

@@ -15,6 +15,7 @@
#include <cassert>
#include "../../../DefaultOnly.h"
#include "../../../stack_allocator.h"
#include "../../../min_allocator.h"
int main()
{
@@ -47,4 +48,24 @@ int main()
assert(std::distance(l.begin(), l.end()) == 3);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#if __cplusplus >= 201103L
{
std::list<int, min_allocator<int>> l(3);
assert(l.size() == 3);
assert(std::distance(l.begin(), l.end()) == 3);
std::list<int, min_allocator<int>>::const_iterator i = l.begin();
assert(*i == 0);
++i;
assert(*i == 0);
++i;
assert(*i == 0);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
std::list<DefaultOnly, min_allocator<DefaultOnly>> l(3);
assert(l.size() == 3);
assert(std::distance(l.begin(), l.end()) == 3);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
}

25
test/containers/sequences/list/list.cons/size_value_alloc.pass.cpp
View File

@@ -15,6 +15,7 @@
#include <cassert>
#include "../../../DefaultOnly.h"
#include "../../../stack_allocator.h"
#include "../../../min_allocator.h"
int main()
{
@@ -51,4 +52,28 @@ int main()
++i;
assert(*i == 2);
}
#if __cplusplus >= 201103L
{
std::list<int, min_allocator<int>> l(3, 2);
assert(l.size() == 3);
assert(std::distance(l.begin(), l.end()) == 3);
std::list<int, min_allocator<int>>::const_iterator i = l.begin();
assert(*i == 2);
++i;
assert(*i == 2);
++i;
assert(*i == 2);
}
{
std::list<int, min_allocator<int>> l(3, 2, min_allocator<int>());
assert(l.size() == 3);
assert(std::distance(l.begin(), l.end()) == 3);
std::list<int, min_allocator<int>>::const_iterator i = l.begin();
assert(*i == 2);
++i;
assert(*i == 2);
++i;
assert(*i == 2);
}
#endif
}

12
test/containers/sequences/list/list.modifiers/clear.pass.cpp
View File

@@ -14,10 +14,22 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
int main()
{
{
int a[] = {1, 2, 3};
std::list<int> c(a, a+3);
c.clear();
assert(c.empty());
}
#if __cplusplus >= 201103L
{
int a[] = {1, 2, 3};
std::list<int, min_allocator<int>> c(a, a+3);
c.clear();
assert(c.empty());
}
#endif
}

31
test/containers/sequences/list/list.modifiers/emplace.pass.cpp
View File

@@ -18,6 +18,8 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
class A
{
int i_;
@@ -36,6 +38,7 @@ public:
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
std::list<A> c;
c.emplace(c.cbegin(), 2, 3.5);
assert(c.size() == 1);
@@ -47,7 +50,7 @@ int main()
assert(c.front().getd() == 3.5);
assert(c.back().geti() == 3);
assert(c.back().getd() == 4.5);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}
#if _LIBCPP_DEBUG2 >= 1
{
std::list<A> c1;
@@ -56,4 +59,30 @@ int main()
assert(false);
}
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#if __cplusplus >= 201103L
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
std::list<A, min_allocator<A>> c;
c.emplace(c.cbegin(), 2, 3.5);
assert(c.size() == 1);
assert(c.front().geti() == 2);
assert(c.front().getd() == 3.5);
c.emplace(c.cend(), 3, 4.5);
assert(c.size() == 2);
assert(c.front().geti() == 2);
assert(c.front().getd() == 3.5);
assert(c.back().geti() == 3);
assert(c.back().getd() == 4.5);
}
#if _LIBCPP_DEBUG2 >= 1
{
std::list<A, min_allocator<A>> c1;
std::list<A, min_allocator<A>> c2;
std::list<A, min_allocator<A>>::iterator i = c1.emplace(c2.cbegin(), 2, 3.5);
assert(false);
}
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif
}

19
test/containers/sequences/list/list.modifiers/emplace_back.pass.cpp
View File

@@ -14,6 +14,8 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
class A
{
int i_;
@@ -32,6 +34,7 @@ public:
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
std::list<A> c;
c.emplace_back(2, 3.5);
assert(c.size() == 1);
@@ -43,5 +46,21 @@ int main()
assert(c.front().getd() == 3.5);
assert(c.back().geti() == 3);
assert(c.back().getd() == 4.5);
}
#if __cplusplus >= 201103L
{
std::list<A, min_allocator<A>> c;
c.emplace_back(2, 3.5);
assert(c.size() == 1);
assert(c.front().geti() == 2);
assert(c.front().getd() == 3.5);
c.emplace_back(3, 4.5);
assert(c.size() == 2);
assert(c.front().geti() == 2);
assert(c.front().getd() == 3.5);
assert(c.back().geti() == 3);
assert(c.back().getd() == 4.5);
}
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}

19
test/containers/sequences/list/list.modifiers/emplace_front.pass.cpp
View File

@@ -14,6 +14,8 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
class A
{
int i_;
@@ -32,6 +34,7 @@ public:
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
std::list<A> c;
c.emplace_front(2, 3.5);
assert(c.size() == 1);
@@ -43,5 +46,21 @@ int main()
assert(c.front().getd() == 4.5);
assert(c.back().geti() == 2);
assert(c.back().getd() == 3.5);
}
#if __cplusplus >= 201103L
{
std::list<A, min_allocator<A>> c;
c.emplace_front(2, 3.5);
assert(c.size() == 1);
assert(c.front().geti() == 2);
assert(c.front().getd() == 3.5);
c.emplace_front(3, 4.5);
assert(c.size() == 2);
assert(c.front().geti() == 3);
assert(c.front().getd() == 4.5);
assert(c.back().geti() == 2);
assert(c.back().getd() == 3.5);
}
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}

27
test/containers/sequences/list/list.modifiers/erase_iter.pass.cpp
View File

@@ -14,8 +14,11 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
int main()
{
{
int a1[] = {1, 2, 3};
std::list<int> l1(a1, a1+3);
std::list<int>::const_iterator i = l1.begin();
@@ -35,4 +38,28 @@ int main()
assert(j == l1.end());
assert(l1.size() == 0);
assert(distance(l1.begin(), l1.end()) == 0);
}
#if __cplusplus >= 201103L
{
int a1[] = {1, 2, 3};
std::list<int, min_allocator<int>> l1(a1, a1+3);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
++i;
std::list<int, min_allocator<int>>::iterator j = l1.erase(i);
assert(l1.size() == 2);
assert(distance(l1.begin(), l1.end()) == 2);
assert(*j == 3);
assert(*l1.begin() == 1);
assert(*next(l1.begin()) == 3);
j = l1.erase(j);
assert(j == l1.end());
assert(l1.size() == 1);
assert(distance(l1.begin(), l1.end()) == 1);
assert(*l1.begin() == 1);
j = l1.erase(l1.begin());
assert(j == l1.end());
assert(l1.size() == 0);
assert(distance(l1.begin(), l1.end()) == 0);
}
#endif
}

13
test/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp
View File

@@ -20,13 +20,26 @@
#include <cstdlib>
#include <exception>
#include "../../../min_allocator.h"
int main()
{
{
int a1[] = {1, 2, 3};
std::list<int> l1(a1, a1+3);
std::list<int>::const_iterator i = l1.end();
l1.erase(i);
assert(false);
}
#if __cplusplus >= 201103L
{
int a1[] = {1, 2, 3};
std::list<int, min_allocator<int>> l1(a1, a1+3);
std::list<int, min_allocator<int>>::const_iterator i = l1.end();
l1.erase(i);
assert(false);
}
#endif
}
#else

14
test/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp
View File

@@ -20,14 +20,28 @@
#include <cstdlib>
#include <exception>
#include "../../../min_allocator.h"
int main()
{
{
int a1[] = {1, 2, 3};
std::list<int> l1(a1, a1+3);
std::list<int> l2(a1, a1+3);
std::list<int>::const_iterator i = l2.begin();
l1.erase(i);
assert(false);
}
#if __cplusplus >= 201103L
{
int a1[] = {1, 2, 3};
std::list<int, min_allocator<int>> l1(a1, a1+3);
std::list<int, min_allocator<int>> l2(a1, a1+3);
std::list<int, min_allocator<int>>::const_iterator i = l2.begin();
l1.erase(i);
assert(false);
}
#endif
}
#else

34
test/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp
View File

@@ -14,6 +14,8 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
int main()
{
int a1[] = {1, 2, 3};
@@ -47,4 +49,36 @@ int main()
assert(distance(l1.cbegin(), l1.cend()) == 0);
assert(i == l1.begin());
}
#if __cplusplus >= 201103L
{
std::list<int, min_allocator<int>> l1(a1, a1+3);
std::list<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), l1.cbegin());
assert(l1.size() == 3);
assert(distance(l1.cbegin(), l1.cend()) == 3);
assert(i == l1.begin());
}
{
std::list<int, min_allocator<int>> l1(a1, a1+3);
std::list<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin()));
assert(l1.size() == 2);
assert(distance(l1.cbegin(), l1.cend()) == 2);
assert(i == l1.begin());
assert((l1 == std::list<int, min_allocator<int>>(a1+1, a1+3)));
}
{
std::list<int, min_allocator<int>> l1(a1, a1+3);
std::list<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 2));
assert(l1.size() == 1);
assert(distance(l1.cbegin(), l1.cend()) == 1);
assert(i == l1.begin());
assert((l1 == std::list<int, min_allocator<int>>(a1+2, a1+3)));
}
{
std::list<int, min_allocator<int>> l1(a1, a1+3);
std::list<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 3));
assert(l1.size() == 0);
assert(distance(l1.cbegin(), l1.cend()) == 0);
assert(i == l1.begin());
}
#endif
}

13
test/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp
View File

@@ -20,13 +20,26 @@
#include <exception>
#include <cstdlib>
#include "../../../min_allocator.h"
int main()
{
{
int a1[] = {1, 2, 3};
std::list<int> l1(a1, a1+3);
std::list<int> l2(a1, a1+3);
std::list<int>::iterator i = l1.erase(l2.cbegin(), next(l1.cbegin()));
assert(false);
}
#if __cplusplus >= 201103L
{
int a1[] = {1, 2, 3};
std::list<int, min_allocator<int>> l1(a1, a1+3);
std::list<int, min_allocator<int>> l2(a1, a1+3);
std::list<int, min_allocator<int>>::iterator i = l1.erase(l2.cbegin(), next(l1.cbegin()));
assert(false);
}
#endif
}
#else

13
test/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp
View File

@@ -20,13 +20,26 @@
#include <exception>
#include <cstdlib>
#include "../../../min_allocator.h"
int main()
{
{
int a1[] = {1, 2, 3};
std::list<int> l1(a1, a1+3);
std::list<int> l2(a1, a1+3);
std::list<int>::iterator i = l1.erase(l1.cbegin(), next(l2.cbegin()));
assert(false);
}
#if __cplusplus >= 201103L
{
int a1[] = {1, 2, 3};
std::list<int, min_allocator<int>> l1(a1, a1+3);
std::list<int, min_allocator<int>> l2(a1, a1+3);
std::list<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), next(l2.cbegin()));
assert(false);
}
#endif
}
#else

13
test/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp
View File

@@ -20,13 +20,26 @@
#include <exception>
#include <cstdlib>
#include "../../../min_allocator.h"
int main()
{
{
int a1[] = {1, 2, 3};
std::list<int> l1(a1, a1+3);
std::list<int> l2(a1, a1+3);
std::list<int>::iterator i = l1.erase(l2.cbegin(), next(l2.cbegin()));
assert(false);
}
#if __cplusplus >= 201103L
{
int a1[] = {1, 2, 3};
std::list<int, min_allocator<int>> l1(a1, a1+3);
std::list<int, min_allocator<int>> l2(a1, a1+3);
std::list<int, min_allocator<int>>::iterator i = l1.erase(l2.cbegin(), next(l2.cbegin()));
assert(false);
}
#endif
}
#else

12
test/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp
View File

@@ -20,12 +20,24 @@
#include <exception>
#include <cstdlib>
#include "../../../min_allocator.h"
int main()
{
{
int a1[] = {1, 2, 3};
std::list<int> l1(a1, a1+3);
std::list<int>::iterator i = l1.erase(next(l1.cbegin()), l1.cbegin());
assert(false);
}
#if __cplusplus >= 201103L
{
int a1[] = {1, 2, 3};
std::list<int, min_allocator<int>> l1(a1, a1+3);
std::list<int, min_allocator<int>>::iterator i = l1.erase(next(l1.cbegin()), l1.cbegin());
assert(false);
}
#endif
}
#else

27
test/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp
View File

@@ -14,9 +14,12 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
int main()
{
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
{
std::list<int> d(10, 1);
std::list<int>::iterator i = d.insert(next(d.cbegin(), 2), {3, 4, 5, 6});
assert(d.size() == 14);
@@ -36,5 +39,29 @@ int main()
assert(*i++ == 1);
assert(*i++ == 1);
assert(*i++ == 1);
}
#if __cplusplus >= 201103L
{
std::list<int, min_allocator<int>> d(10, 1);
std::list<int, min_allocator<int>>::iterator i = d.insert(next(d.cbegin(), 2), {3, 4, 5, 6});
assert(d.size() == 14);
assert(i == next(d.begin(), 2));
i = d.begin();
assert(*i++ == 1);
assert(*i++ == 1);
assert(*i++ == 3);
assert(*i++ == 4);
assert(*i++ == 5);
assert(*i++ == 6);
assert(*i++ == 1);
assert(*i++ == 1);
assert(*i++ == 1);
assert(*i++ == 1);
assert(*i++ == 1);
assert(*i++ == 1);
assert(*i++ == 1);
assert(*i++ == 1);
}
#endif
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

73
test/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp
View File

@@ -20,6 +20,7 @@
#include <cstdlib>
#include <cassert>
#include "test_iterators.h"
#include "../../../min_allocator.h"
int throw_next = 0xFFFF;
int count = 0;
@@ -97,9 +98,9 @@ int main()
++i;
assert(*i == 3);
}
throw_next = 0xFFFF;
#if _LIBCPP_DEBUG2 >= 1
{
throw_next = 0xFFFF;
std::list<int> v(100);
std::list<int> v2(100);
int a[] = {1, 2, 3, 4, 5};
@@ -109,4 +110,74 @@ int main()
assert(false);
}
#endif
#if __cplusplus >= 201103L
{
int a1[] = {1, 2, 3};
std::list<int, min_allocator<int>> l1;
std::list<int, min_allocator<int>>::iterator i = l1.insert(l1.begin(), a1, a1+3);
assert(i == l1.begin());
assert(l1.size() == 3);
assert(distance(l1.begin(), l1.end()) == 3);
i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 2);
++i;
assert(*i == 3);
int a2[] = {4, 5, 6};
i = l1.insert(i, a2, a2+3);
assert(*i == 4);
assert(l1.size() == 6);
assert(distance(l1.begin(), l1.end()) == 6);
i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 2);
++i;
assert(*i == 4);
++i;
assert(*i == 5);
++i;
assert(*i == 6);
++i;
assert(*i == 3);
throw_next = 2;
int save_count = count;
try
{
i = l1.insert(i, a2, a2+3);
assert(false);
}
catch (...)
{
}
assert(save_count == count);
assert(l1.size() == 6);
assert(distance(l1.begin(), l1.end()) == 6);
i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 2);
++i;
assert(*i == 4);
++i;
assert(*i == 5);
++i;
assert(*i == 6);
++i;
assert(*i == 3);
}
#if _LIBCPP_DEBUG2 >= 1
{
throw_next = 0xFFFF;
std::list<int, min_allocator<int>> v(100);
std::list<int, min_allocator<int>> v2(100);
int a[] = {1, 2, 3, 4, 5};
const int N = sizeof(a)/sizeof(a[0]);
std::list<int, min_allocator<int>>::iterator i = v.insert(next(v2.cbegin(), 10), input_iterator<const int*>(a),
input_iterator<const int*>(a+N));
assert(false);
}
#endif
#endif
}

25
test/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp
View File

@@ -19,10 +19,12 @@
#include <cassert>
#include "../../../MoveOnly.h"
#include "../../../min_allocator.h"
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
std::list<MoveOnly> l1;
l1.insert(l1.cend(), MoveOnly(1));
assert(l1.size() == 1);
@@ -31,6 +33,7 @@ int main()
assert(l1.size() == 2);
assert(l1.front() == MoveOnly(2));
assert(l1.back() == MoveOnly(1));
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#if _LIBCPP_DEBUG2 >= 1
{
@@ -40,4 +43,26 @@ int main()
assert(false);
}
#endif
#if __cplusplus >= 201103L
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
std::list<MoveOnly, min_allocator<MoveOnly>> l1;
l1.insert(l1.cend(), MoveOnly(1));
assert(l1.size() == 1);
assert(l1.front() == MoveOnly(1));
l1.insert(l1.cbegin(), MoveOnly(2));
assert(l1.size() == 2);
assert(l1.front() == MoveOnly(2));
assert(l1.back() == MoveOnly(1));
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#if _LIBCPP_DEBUG2 >= 1
{
std::list<int, min_allocator<int>> v1(3);
std::list<int, min_allocator<int>> v2(3);
v1.insert(v2.begin(), 4);
assert(false);
}
#endif
#endif
}

35
test/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp
View File

@@ -19,6 +19,8 @@
#include <cstdlib>
#include <cassert>
#include "../../../min_allocator.h"
int throw_next = 0xFFFF;
int count = 0;
@@ -39,6 +41,7 @@ void operator delete(void* p) throw()
int main()
{
{
int a1[] = {1, 2, 3};
int a2[] = {1, 4, 4, 4, 4, 4, 2, 3};
std::list<int> l1(a1, a1+3);
@@ -58,6 +61,7 @@ int main()
throw_next = 0xFFFF;
assert(save_count == count);
assert(l1 == std::list<int>(a2, a2+8));
}
#if _LIBCPP_DEBUG2 >= 1
{
std::list<int> c1(100);
@@ -66,4 +70,35 @@ int main()
assert(false);
}
#endif
#if __cplusplus >= 201103L
{
int a1[] = {1, 2, 3};
int a2[] = {1, 4, 4, 4, 4, 4, 2, 3};
std::list<int, min_allocator<int>> l1(a1, a1+3);
std::list<int, min_allocator<int>>::iterator i = l1.insert(next(l1.cbegin()), 5, 4);
assert(i == next(l1.begin()));
assert((l1 == std::list<int, min_allocator<int>>(a2, a2+8)));
throw_next = 4;
int save_count = count;
try
{
i = l1.insert(i, 5, 5);
assert(false);
}
catch (...)
{
}
throw_next = 0xFFFF;
assert(save_count == count);
assert((l1 == std::list<int, min_allocator<int>>(a2, a2+8)));
}
#if _LIBCPP_DEBUG2 >= 1
{
std::list<int, min_allocator<int>> c1(100);
std::list<int, min_allocator<int>> c2;
std::list<int, min_allocator<int>>::iterator i = c1.insert(next(c2.cbegin(), 10), 5, 1);
assert(false);
}
#endif
#endif
}

38
test/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp
View File

@@ -19,6 +19,8 @@
#include <cstdlib>
#include <cassert>
#include "../../../min_allocator.h"
int throw_next = 0xFFFF;
int count = 0;
@@ -39,6 +41,7 @@ void operator delete(void* p) throw()
int main()
{
{
int a1[] = {1, 2, 3};
int a2[] = {1, 4, 2, 3};
std::list<int> l1(a1, a1+3);
@@ -60,6 +63,7 @@ int main()
throw_next = 0xFFFF;
assert(save_count == count);
assert(l1 == std::list<int>(a2, a2+4));
}
#if _LIBCPP_DEBUG2 >= 1
{
std::list<int> v1(3);
@@ -69,4 +73,38 @@ int main()
assert(false);
}
#endif
#if __cplusplus >= 201103L
{
int a1[] = {1, 2, 3};
int a2[] = {1, 4, 2, 3};
std::list<int, min_allocator<int>> l1(a1, a1+3);
std::list<int, min_allocator<int>>::iterator i = l1.insert(next(l1.cbegin()), 4);
assert(i == next(l1.begin()));
assert(l1.size() == 4);
assert(distance(l1.begin(), l1.end()) == 4);
assert((l1 == std::list<int, min_allocator<int>>(a2, a2+4)));
throw_next = 0;
int save_count = count;
try
{
i = l1.insert(i, 5);
assert(false);
}
catch (...)
{
}
throw_next = 0xFFFF;
assert(save_count == count);
assert((l1 == std::list<int, min_allocator<int>>(a2, a2+4)));
}
#if _LIBCPP_DEBUG2 >= 1
{
std::list<int, min_allocator<int>> v1(3);
std::list<int, min_allocator<int>> v2(3);
int i = 4;
v1.insert(v2.begin(), i);
assert(false);
}
#endif
#endif
}

20
test/containers/sequences/list/list.modifiers/pop_back.pass.cpp
View File

@@ -18,8 +18,11 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
int main()
{
{
int a[] = {1, 2, 3};
std::list<int> c(a, a+3);
c.pop_back();
@@ -32,4 +35,21 @@ int main()
c.pop_back();
assert(false);
#endif
}
#if __cplusplus >= 201103L
{
int a[] = {1, 2, 3};
std::list<int, min_allocator<int>> c(a, a+3);
c.pop_back();
assert((c == std::list<int, min_allocator<int>>(a, a+2)));
c.pop_back();
assert((c == std::list<int, min_allocator<int>>(a, a+1)));
c.pop_back();
assert(c.empty());
#if _LIBCPP_DEBUG2 >= 1
c.pop_back();
assert(false);
#endif
}
#endif
}

16
test/containers/sequences/list/list.modifiers/pop_front.pass.cpp
View File

@@ -14,8 +14,11 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
int main()
{
{
int a[] = {1, 2, 3};
std::list<int> c(a, a+3);
c.pop_front();
@@ -24,4 +27,17 @@ int main()
assert(c == std::list<int>(a+2, a+3));
c.pop_front();
assert(c.empty());
}
#if __cplusplus >= 201103L
{
int a[] = {1, 2, 3};
std::list<int, min_allocator<int>> c(a, a+3);
c.pop_front();
assert((c == std::list<int, min_allocator<int>>(a+1, a+3)));
c.pop_front();
assert((c == std::list<int, min_allocator<int>>(a+2, a+3)));
c.pop_front();
assert(c.empty());
}
#endif
}

13
test/containers/sequences/list/list.modifiers/push_back.pass.cpp
View File

@@ -14,11 +14,24 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
int main()
{
{
std::list<int> c;
for (int i = 0; i < 5; ++i)
c.push_back(i);
int a[] = {0, 1, 2, 3, 4};
assert(c == std::list<int>(a, a+5));
}
#if __cplusplus >= 201103L
{
std::list<int, min_allocator<int>> c;
for (int i = 0; i < 5; ++i)
c.push_back(i);
int a[] = {0, 1, 2, 3, 4};
assert((c == std::list<int, min_allocator<int>>(a, a+5)));
}
#endif
}

15
test/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp
View File

@@ -15,10 +15,12 @@
#include <cassert>
#include "../../../MoveOnly.h"
#include "../../../min_allocator.h"
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
std::list<MoveOnly> l1;
l1.push_back(MoveOnly(1));
assert(l1.size() == 1);
@@ -27,5 +29,18 @@ int main()
assert(l1.size() == 2);
assert(l1.front() == MoveOnly(1));
assert(l1.back() == MoveOnly(2));
}
#if __cplusplus >= 201103L
{
std::list<MoveOnly, min_allocator<MoveOnly>> l1;
l1.push_back(MoveOnly(1));
assert(l1.size() == 1);
assert(l1.front() == MoveOnly(1));
l1.push_back(MoveOnly(2));
assert(l1.size() == 2);
assert(l1.front() == MoveOnly(1));
assert(l1.back() == MoveOnly(2));
}
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}

13
test/containers/sequences/list/list.modifiers/push_front.pass.cpp
View File

@@ -14,11 +14,24 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
int main()
{
{
std::list<int> c;
for (int i = 0; i < 5; ++i)
c.push_front(i);
int a[] = {4, 3, 2, 1, 0};
assert(c == std::list<int>(a, a+5));
}
#if __cplusplus >= 201103L
{
std::list<int, min_allocator<int>> c;
for (int i = 0; i < 5; ++i)
c.push_front(i);
int a[] = {4, 3, 2, 1, 0};
assert((c == std::list<int, min_allocator<int>>(a, a+5)));
}
#endif
}

15
test/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp
View File

@@ -15,10 +15,12 @@
#include <cassert>
#include "../../../MoveOnly.h"
#include "../../../min_allocator.h"
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
std::list<MoveOnly> l1;
l1.push_front(MoveOnly(1));
assert(l1.size() == 1);
@@ -27,5 +29,18 @@ int main()
assert(l1.size() == 2);
assert(l1.front() == MoveOnly(2));
assert(l1.back() == MoveOnly(1));
}
#if __cplusplus >= 201103L
{
std::list<MoveOnly, min_allocator<MoveOnly>> l1;
l1.push_front(MoveOnly(1));
assert(l1.size() == 1);
assert(l1.front() == MoveOnly(1));
l1.push_front(MoveOnly(2));
assert(l1.size() == 2);
assert(l1.front() == MoveOnly(2));
assert(l1.back() == MoveOnly(1));
}
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}

15
test/containers/sequences/list/list.ops/merge.pass.cpp
View File

@@ -14,8 +14,11 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
int main()
{
{
int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11};
int a3[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
@@ -23,4 +26,16 @@ int main()
std::list<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
c1.merge(c2);
assert(c1 == std::list<int>(a3, a3+sizeof(a3)/sizeof(a3[0])));
}
#if __cplusplus >= 201103L
{
int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11};
int a3[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
std::list<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
std::list<int, min_allocator<int>> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
c1.merge(c2);
assert((c1 == std::list<int, min_allocator<int>>(a3, a3+sizeof(a3)/sizeof(a3[0]))));
}
#endif
}

15
test/containers/sequences/list/list.ops/merge_comp.pass.cpp
View File

@@ -15,8 +15,11 @@
#include <functional>
#include <cassert>
#include "../../../min_allocator.h"
int main()
{
{
int a1[] = {10, 9, 7, 3, 1};
int a2[] = {11, 8, 6, 5, 4, 2, 0};
int a3[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
@@ -24,4 +27,16 @@ int main()
std::list<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
c1.merge(c2, std::greater<int>());
assert(c1 == std::list<int>(a3, a3+sizeof(a3)/sizeof(a3[0])));
}
#if __cplusplus >= 201103L
{
int a1[] = {10, 9, 7, 3, 1};
int a2[] = {11, 8, 6, 5, 4, 2, 0};
int a3[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
std::list<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
std::list<int, min_allocator<int>> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
c1.merge(c2, std::greater<int>());
assert((c1 == std::list<int, min_allocator<int>>(a3, a3+sizeof(a3)/sizeof(a3[0]))));
}
#endif
}

13
test/containers/sequences/list/list.ops/remove.pass.cpp
View File

@@ -14,11 +14,24 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
int main()
{
{
int a1[] = {1, 2, 3, 4};
int a2[] = {1, 2, 4};
std::list<int> c(a1, a1+4);
c.remove(3);
assert(c == std::list<int>(a2, a2+3));
}
#if __cplusplus >= 201103L
{
int a1[] = {1, 2, 3, 4};
int a2[] = {1, 2, 4};
std::list<int, min_allocator<int>> c(a1, a1+4);
c.remove(3);
assert((c == std::list<int, min_allocator<int>>(a2, a2+3)));
}
#endif
}

13
test/containers/sequences/list/list.ops/remove_if.pass.cpp
View File

@@ -15,6 +15,8 @@
#include <cassert>
#include <functional>
#include "../../../min_allocator.h"
bool g(int i)
{
return i < 3;
@@ -22,9 +24,20 @@ bool g(int i)
int main()
{
{
int a1[] = {1, 2, 3, 4};
int a2[] = {3, 4};
std::list<int> c(a1, a1+4);
c.remove_if(g);
assert(c == std::list<int>(a2, a2+2));
}
#if __cplusplus >= 201103L
{
int a1[] = {1, 2, 3, 4};
int a2[] = {3, 4};
std::list<int, min_allocator<int>> c(a1, a1+4);
c.remove_if(g);
assert((c == std::list<int, min_allocator<int>>(a2, a2+2)));
}
#endif
}

13
test/containers/sequences/list/list.ops/reverse.pass.cpp
View File

@@ -14,11 +14,24 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
int main()
{
{
int a1[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
int a2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
std::list<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
c1.reverse();
assert(c1 == std::list<int>(a2, a2+sizeof(a2)/sizeof(a2[0])));
}
#if __cplusplus >= 201103L
{
int a1[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
int a2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
std::list<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
c1.reverse();
assert((c1 == std::list<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
}
#endif
}

13
test/containers/sequences/list/list.ops/sort.pass.cpp
View File

@@ -14,11 +14,24 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
int main()
{
{
int a1[] = {4, 8, 1, 0, 5, 7, 2, 3, 6, 11, 10, 9};
int a2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
std::list<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
c1.sort();
assert(c1 == std::list<int>(a2, a2+sizeof(a2)/sizeof(a2[0])));
}
#if __cplusplus >= 201103L
{
int a1[] = {4, 8, 1, 0, 5, 7, 2, 3, 6, 11, 10, 9};
int a2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
std::list<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
c1.sort();
assert((c1 == std::list<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
}
#endif
}

13
test/containers/sequences/list/list.ops/sort_comp.pass.cpp
View File

@@ -15,11 +15,24 @@
#include <functional>
#include <cassert>
#include "../../../min_allocator.h"
int main()
{
{
int a1[] = {4, 8, 1, 0, 5, 7, 2, 3, 6, 11, 10, 9};
int a2[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
std::list<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
c1.sort(std::greater<int>());
assert(c1 == std::list<int>(a2, a2+sizeof(a2)/sizeof(a2[0])));
}
#if __cplusplus >= 201103L
{
int a1[] = {4, 8, 1, 0, 5, 7, 2, 3, 6, 11, 10, 9};
int a2[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
std::list<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
c1.sort(std::greater<int>());
assert((c1 == std::list<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
}
#endif
}

391
test/containers/sequences/list/list.ops/splice_pos_list.pass.cpp
View File

@@ -18,6 +18,8 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
int main()
{
int a1[] = {1, 2, 3};
@@ -409,4 +411,393 @@ int main()
assert(false);
}
#endif
#if __cplusplus >= 201103L
{
std::list<int, min_allocator<int>> l1;
std::list<int, min_allocator<int>> l2;
l1.splice(l1.end(), l2);
assert(l1.size() == 0);
assert(distance(l1.begin(), l1.end()) == 0);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
}
{
std::list<int, min_allocator<int>> l1;
std::list<int, min_allocator<int>> l2(a2, a2+1);
l1.splice(l1.end(), l2);
assert(l1.size() == 1);
assert(distance(l1.begin(), l1.end()) == 1);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 4);
}
{
std::list<int, min_allocator<int>> l1;
std::list<int, min_allocator<int>> l2(a2, a2+2);
l1.splice(l1.end(), l2);
assert(l1.size() == 2);
assert(distance(l1.begin(), l1.end()) == 2);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 4);
++i;
assert(*i == 5);
}
{
std::list<int, min_allocator<int>> l1;
std::list<int, min_allocator<int>> l2(a2, a2+3);
l1.splice(l1.end(), l2);
assert(l1.size() == 3);
assert(distance(l1.begin(), l1.end()) == 3);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 4);
++i;
assert(*i == 5);
++i;
assert(*i == 6);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+1);
std::list<int, min_allocator<int>> l2;
l1.splice(l1.begin(), l2);
assert(l1.size() == 1);
assert(distance(l1.begin(), l1.end()) == 1);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+1);
std::list<int, min_allocator<int>> l2;
l1.splice(l1.end(), l2);
assert(l1.size() == 1);
assert(distance(l1.begin(), l1.end()) == 1);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+1);
std::list<int, min_allocator<int>> l2(a2, a2+1);
l1.splice(l1.begin(), l2);
assert(l1.size() == 2);
assert(distance(l1.begin(), l1.end()) == 2);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 4);
++i;
assert(*i == 1);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+1);
std::list<int, min_allocator<int>> l2(a2, a2+1);
l1.splice(l1.end(), l2);
assert(l1.size() == 2);
assert(distance(l1.begin(), l1.end()) == 2);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 4);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+1);
std::list<int, min_allocator<int>> l2(a2, a2+2);
l1.splice(l1.begin(), l2);
assert(l1.size() == 3);
assert(distance(l1.begin(), l1.end()) == 3);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 4);
++i;
assert(*i == 5);
++i;
assert(*i == 1);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+1);
std::list<int, min_allocator<int>> l2(a2, a2+2);
l1.splice(l1.end(), l2);
assert(l1.size() == 3);
assert(distance(l1.begin(), l1.end()) == 3);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 4);
++i;
assert(*i == 5);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+1);
std::list<int, min_allocator<int>> l2(a2, a2+3);
l1.splice(l1.begin(), l2);
assert(l1.size() == 4);
assert(distance(l1.begin(), l1.end()) == 4);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 4);
++i;
assert(*i == 5);
++i;
assert(*i == 6);
++i;
assert(*i == 1);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+1);
std::list<int, min_allocator<int>> l2(a2, a2+3);
l1.splice(l1.end(), l2);
assert(l1.size() == 4);
assert(distance(l1.begin(), l1.end()) == 4);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 4);
++i;
assert(*i == 5);
++i;
assert(*i == 6);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+2);
std::list<int, min_allocator<int>> l2;
l1.splice(l1.begin(), l2);
assert(l1.size() == 2);
assert(distance(l1.begin(), l1.end()) == 2);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 2);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+2);
std::list<int, min_allocator<int>> l2;
l1.splice(next(l1.begin()), l2);
assert(l1.size() == 2);
assert(distance(l1.begin(), l1.end()) == 2);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 2);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+2);
std::list<int, min_allocator<int>> l2;
l1.splice(next(l1.begin(), 2), l2);
assert(l1.size() == 2);
assert(distance(l1.begin(), l1.end()) == 2);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 2);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+2);
std::list<int, min_allocator<int>> l2(a2, a2+1);
l1.splice(l1.begin(), l2);
assert(l1.size() == 3);
assert(distance(l1.begin(), l1.end()) == 3);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 4);
++i;
assert(*i == 1);
++i;
assert(*i == 2);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+2);
std::list<int, min_allocator<int>> l2(a2, a2+1);
l1.splice(next(l1.begin()), l2);
assert(l1.size() == 3);
assert(distance(l1.begin(), l1.end()) == 3);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 4);
++i;
assert(*i == 2);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+2);
std::list<int, min_allocator<int>> l2(a2, a2+1);
l1.splice(next(l1.begin(), 2), l2);
assert(l1.size() == 3);
assert(distance(l1.begin(), l1.end()) == 3);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 2);
++i;
assert(*i == 4);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+2);
std::list<int, min_allocator<int>> l2(a2, a2+2);
l1.splice(l1.begin(), l2);
assert(l1.size() == 4);
assert(distance(l1.begin(), l1.end()) == 4);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 4);
++i;
assert(*i == 5);
++i;
assert(*i == 1);
++i;
assert(*i == 2);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+2);
std::list<int, min_allocator<int>> l2(a2, a2+2);
l1.splice(next(l1.begin()), l2);
assert(l1.size() == 4);
assert(distance(l1.begin(), l1.end()) == 4);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 4);
++i;
assert(*i == 5);
++i;
assert(*i == 2);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+2);
std::list<int, min_allocator<int>> l2(a2, a2+2);
l1.splice(next(l1.begin(), 2), l2);
assert(l1.size() == 4);
assert(distance(l1.begin(), l1.end()) == 4);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 2);
++i;
assert(*i == 4);
++i;
assert(*i == 5);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+3);
std::list<int, min_allocator<int>> l2(a2, a2+3);
l1.splice(l1.begin(), l2);
assert(l1.size() == 6);
assert(distance(l1.begin(), l1.end()) == 6);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 4);
++i;
assert(*i == 5);
++i;
assert(*i == 6);
++i;
assert(*i == 1);
++i;
assert(*i == 2);
++i;
assert(*i == 3);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+3);
std::list<int, min_allocator<int>> l2(a2, a2+3);
l1.splice(next(l1.begin()), l2);
assert(l1.size() == 6);
assert(distance(l1.begin(), l1.end()) == 6);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 4);
++i;
assert(*i == 5);
++i;
assert(*i == 6);
++i;
assert(*i == 2);
++i;
assert(*i == 3);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+3);
std::list<int, min_allocator<int>> l2(a2, a2+3);
l1.splice(next(l1.begin(), 2), l2);
assert(l1.size() == 6);
assert(distance(l1.begin(), l1.end()) == 6);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 2);
++i;
assert(*i == 4);
++i;
assert(*i == 5);
++i;
assert(*i == 6);
++i;
assert(*i == 3);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+3);
std::list<int, min_allocator<int>> l2(a2, a2+3);
l1.splice(next(l1.begin(), 3), l2);
assert(l1.size() == 6);
assert(distance(l1.begin(), l1.end()) == 6);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 2);
++i;
assert(*i == 3);
++i;
assert(*i == 4);
++i;
assert(*i == 5);
++i;
assert(*i == 6);
}
#if _LIBCPP_DEBUG2 >= 1
{
std::list<int, min_allocator<int>> v1(3);
std::list<int, min_allocator<int>> v2(3);
v1.splice(v2.begin(), v2);
assert(false);
}
#endif
#endif
}

168
test/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp
View File

@@ -18,6 +18,8 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
int main()
{
int a1[] = {1, 2, 3};
@@ -186,4 +188,170 @@ int main()
assert(false);
}
#endif
#if __cplusplus >= 201103L
{
std::list<int, min_allocator<int>> l1;
std::list<int, min_allocator<int>> l2(a2, a2+1);
l1.splice(l1.end(), l2, l2.begin());
assert(l1.size() == 1);
assert(distance(l1.begin(), l1.end()) == 1);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 4);
}
{
std::list<int, min_allocator<int>> l1;
std::list<int, min_allocator<int>> l2(a2, a2+2);
l1.splice(l1.end(), l2, l2.begin());
assert(l1.size() == 1);
assert(distance(l1.begin(), l1.end()) == 1);
assert(l2.size() == 1);
assert(distance(l2.begin(), l2.end()) == 1);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 4);
i = l2.begin();
assert(*i == 5);
}
{
std::list<int, min_allocator<int>> l1;
std::list<int, min_allocator<int>> l2(a2, a2+2);
l1.splice(l1.end(), l2, next(l2.begin()));
assert(l1.size() == 1);
assert(distance(l1.begin(), l1.end()) == 1);
assert(l2.size() == 1);
assert(distance(l2.begin(), l2.end()) == 1);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 5);
i = l2.begin();
assert(*i == 4);
}
{
std::list<int, min_allocator<int>> l1;
std::list<int, min_allocator<int>> l2(a2, a2+3);
l1.splice(l1.end(), l2, l2.begin());
assert(l1.size() == 1);
assert(distance(l1.begin(), l1.end()) == 1);
assert(l2.size() == 2);
assert(distance(l2.begin(), l2.end()) == 2);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 4);
i = l2.begin();
assert(*i == 5);
++i;
assert(*i == 6);
}
{
std::list<int, min_allocator<int>> l1;
std::list<int, min_allocator<int>> l2(a2, a2+3);
l1.splice(l1.end(), l2, next(l2.begin()));
assert(l1.size() == 1);
assert(distance(l1.begin(), l1.end()) == 1);
assert(l2.size() == 2);
assert(distance(l2.begin(), l2.end()) == 2);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 5);
i = l2.begin();
assert(*i == 4);
++i;
assert(*i == 6);
}
{
std::list<int, min_allocator<int>> l1;
std::list<int, min_allocator<int>> l2(a2, a2+3);
l1.splice(l1.end(), l2, next(l2.begin(), 2));
assert(l1.size() == 1);
assert(distance(l1.begin(), l1.end()) == 1);
assert(l2.size() == 2);
assert(distance(l2.begin(), l2.end()) == 2);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 6);
i = l2.begin();
assert(*i == 4);
++i;
assert(*i == 5);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+1);
l1.splice(l1.begin(), l1, l1.begin());
assert(l1.size() == 1);
assert(distance(l1.begin(), l1.end()) == 1);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+1);
std::list<int, min_allocator<int>> l2(a2, a2+1);
l1.splice(l1.begin(), l2, l2.begin());
assert(l1.size() == 2);
assert(distance(l1.begin(), l1.end()) == 2);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 4);
++i;
assert(*i == 1);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+1);
std::list<int, min_allocator<int>> l2(a2, a2+1);
l1.splice(next(l1.begin()), l2, l2.begin());
assert(l1.size() == 2);
assert(distance(l1.begin(), l1.end()) == 2);
assert(l2.size() == 0);
assert(distance(l2.begin(), l2.end()) == 0);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 4);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+2);
l1.splice(l1.begin(), l1, l1.begin());
assert(l1.size() == 2);
assert(distance(l1.begin(), l1.end()) == 2);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 2);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+2);
l1.splice(l1.begin(), l1, next(l1.begin()));
assert(l1.size() == 2);
assert(distance(l1.begin(), l1.end()) == 2);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 2);
++i;
assert(*i == 1);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+2);
l1.splice(next(l1.begin()), l1, l1.begin());
assert(l1.size() == 2);
assert(distance(l1.begin(), l1.end()) == 2);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 2);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+2);
l1.splice(next(l1.begin()), l1, next(l1.begin()));
assert(l1.size() == 2);
assert(distance(l1.begin(), l1.end()) == 2);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 2);
}
#if _LIBCPP_DEBUG2 >= 1
{
std::list<int, min_allocator<int>> v1(3);
std::list<int, min_allocator<int>> v2(3);
v1.splice(v1.begin(), v2, v1.begin());
assert(false);
}
#endif
#endif
}

108
test/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp
View File

@@ -18,6 +18,8 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
int main()
{
int a1[] = {1, 2, 3};
@@ -126,4 +128,110 @@ int main()
assert(false);
}
#endif
#if __cplusplus >= 201103L
{
std::list<int, min_allocator<int>> l1(a1, a1+3);
l1.splice(l1.begin(), l1, next(l1.begin()), next(l1.begin()));
assert(l1.size() == 3);
assert(distance(l1.begin(), l1.end()) == 3);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 2);
++i;
assert(*i == 3);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+3);
l1.splice(l1.begin(), l1, next(l1.begin()), next(l1.begin(), 2));
assert(l1.size() == 3);
assert(distance(l1.begin(), l1.end()) == 3);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 2);
++i;
assert(*i == 1);
++i;
assert(*i == 3);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+3);
l1.splice(l1.begin(), l1, next(l1.begin()), next(l1.begin(), 3));
assert(l1.size() == 3);
assert(distance(l1.begin(), l1.end()) == 3);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 2);
++i;
assert(*i == 3);
++i;
assert(*i == 1);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+3);
std::list<int, min_allocator<int>> l2(a2, a2+3);
l1.splice(l1.begin(), l2, next(l2.begin()), l2.end());
assert(l1.size() == 5);
assert(distance(l1.begin(), l1.end()) == 5);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 5);
++i;
assert(*i == 6);
++i;
assert(*i == 1);
++i;
assert(*i == 2);
++i;
assert(*i == 3);
assert(l2.size() == 1);
i = l2.begin();
assert(*i == 4);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+3);
std::list<int, min_allocator<int>> l2(a2, a2+3);
l1.splice(next(l1.begin()), l2, next(l2.begin()), l2.end());
assert(l1.size() == 5);
assert(distance(l1.begin(), l1.end()) == 5);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 5);
++i;
assert(*i == 6);
++i;
assert(*i == 2);
++i;
assert(*i == 3);
assert(l2.size() == 1);
i = l2.begin();
assert(*i == 4);
}
{
std::list<int, min_allocator<int>> l1(a1, a1+3);
std::list<int, min_allocator<int>> l2(a2, a2+3);
l1.splice(l1.end(), l2, next(l2.begin()), l2.end());
assert(l1.size() == 5);
assert(distance(l1.begin(), l1.end()) == 5);
std::list<int, min_allocator<int>>::const_iterator i = l1.begin();
assert(*i == 1);
++i;
assert(*i == 2);
++i;
assert(*i == 3);
++i;
assert(*i == 5);
++i;
assert(*i == 6);
assert(l2.size() == 1);
i = l2.begin();
assert(*i == 4);
}
#if _LIBCPP_DEBUG2 >= 1
{
std::list<int, min_allocator<int>> v1(3);
std::list<int, min_allocator<int>> v2(3);
v1.splice(v1.begin(), v2, v2.begin(), v1.end());
assert(false);
}
#endif
#endif
}

13
test/containers/sequences/list/list.ops/unique.pass.cpp
View File

@@ -14,11 +14,24 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
int main()
{
{
int a1[] = {2, 1, 1, 4, 4, 4, 4, 3, 3};
int a2[] = {2, 1, 4, 3};
std::list<int> c(a1, a1+sizeof(a1)/sizeof(a1[0]));
c.unique();
assert(c == std::list<int>(a2, a2+4));
}
#if __cplusplus >= 201103L
{
int a1[] = {2, 1, 1, 4, 4, 4, 4, 3, 3};
int a2[] = {2, 1, 4, 3};
std::list<int, min_allocator<int>> c(a1, a1+sizeof(a1)/sizeof(a1[0]));
c.unique();
assert((c == std::list<int, min_allocator<int>>(a2, a2+4)));
}
#endif
}

13
test/containers/sequences/list/list.ops/unique_pred.pass.cpp
View File

@@ -14,6 +14,8 @@
#include <list>
#include <cassert>
#include "../../../min_allocator.h"
bool g(int x, int y)
{
return x == y;
@@ -21,9 +23,20 @@ bool g(int x, int y)
int main()
{
{
int a1[] = {2, 1, 1, 4, 4, 4, 4, 3, 3};
int a2[] = {2, 1, 4, 3};
std::list<int> c(a1, a1+sizeof(a1)/sizeof(a1[0]));
c.unique(g);
assert(c == std::list<int>(a2, a2+4));
}
#if __cplusplus >= 201103L
{
int a1[] = {2, 1, 1, 4, 4, 4, 4, 3, 3};
int a2[] = {2, 1, 4, 3};
std::list<int, min_allocator<int>> c(a1, a1+sizeof(a1)/sizeof(a1[0]));
c.unique(g);
assert((c == std::list<int, min_allocator<int>>(a2, a2+4)));
}
#endif
}

17
test/containers/sequences/list/list.special/db_swap_1.pass.cpp
View File

@@ -20,6 +20,7 @@
#include <cassert>
#include <__debug>
#include "../../../min_allocator.h"
int main()
{
@@ -38,5 +39,21 @@ int main()
c1.erase(i1);
assert(false);
}
#if __cplusplus >= 201103L
{
int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11};
std::list<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
std::list<int, min_allocator<int>> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
std::list<int, min_allocator<int>>::iterator i1 = c1.begin();
std::list<int, min_allocator<int>>::iterator i2 = c2.begin();
swap(c1, c2);
c1.erase(i2);
c2.erase(i1);
std::list<int, min_allocator<int>>::iterator j = i1;
c1.erase(i1);
assert(false);
}
#endif
#endif
}

58
test/containers/sequences/list/list.special/swap.pass.cpp
View File

@@ -15,6 +15,7 @@
#include <list>
#include <cassert>
#include "../../../test_allocator.h"
#include "../../../min_allocator.h"
int main()
{
@@ -85,4 +86,61 @@ int main()
assert((c2 == std::list<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
assert(c2.get_allocator() == A(1));
}
#if __cplusplus >= 201103L
{
int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11};
std::list<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
std::list<int, min_allocator<int>> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
swap(c1, c2);
assert((c1 == std::list<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
assert((c2 == std::list<int, min_allocator<int>>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
}
{
int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11};
std::list<int, min_allocator<int>> c1(a1, a1);
std::list<int, min_allocator<int>> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
swap(c1, c2);
assert((c1 == std::list<int, min_allocator<int>>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
assert(c2.empty());
assert(distance(c2.begin(), c2.end()) == 0);
}
{
int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11};
std::list<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
std::list<int, min_allocator<int>> c2(a2, a2);
swap(c1, c2);
assert(c1.empty());
assert(distance(c1.begin(), c1.end()) == 0);
assert((c2 == std::list<int, min_allocator<int>>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
}
{
int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11};
std::list<int, min_allocator<int>> c1(a1, a1);
std::list<int, min_allocator<int>> c2(a2, a2);
swap(c1, c2);
assert(c1.empty());
assert(distance(c1.begin(), c1.end()) == 0);
assert(c2.empty());
assert(distance(c2.begin(), c2.end()) == 0);
}
#ifndef _LIBCPP_DEBUG_LEVEL
// This test known to result in undefined behavior detected by _LIBCPP_DEBUG_LEVEL >= 1
{
int a1[] = {1, 3, 7, 9, 10};
int a2[] = {0, 2, 4, 5, 6, 8, 11};
typedef min_allocator<int> A;
std::list<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A());
std::list<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A());
swap(c1, c2);
assert((c1 == std::list<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0]))));
assert(c1.get_allocator() == A());
assert((c2 == std::list<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0]))));
assert(c2.get_allocator() == A());
}
#endif
#endif
}

10
test/containers/sequences/list/types.pass.cpp
View File

@@ -25,6 +25,8 @@
#include <list>
#include <type_traits>
#include "../../min_allocator.h"
int main()
{
static_assert((std::is_same<std::list<int>::value_type, int>::value), "");
@@ -33,4 +35,12 @@ int main()
static_assert((std::is_same<std::list<int>::const_reference, std::allocator<int>::const_reference>::value), "");
static_assert((std::is_same<std::list<int>::pointer, std::allocator<int>::pointer>::value), "");
static_assert((std::is_same<std::list<int>::const_pointer, std::allocator<int>::const_pointer>::value), "");
#if __cplusplus >= 201103L
static_assert((std::is_same<std::list<int, min_allocator<int>>::value_type, int>::value), "");
static_assert((std::is_same<std::list<int, min_allocator<int>>::allocator_type, min_allocator<int> >::value), "");
static_assert((std::is_same<std::list<int, min_allocator<int>>::reference, int&>::value), "");
static_assert((std::is_same<std::list<int, min_allocator<int>>::const_reference, const int&>::value), "");
static_assert((std::is_same<std::list<int, min_allocator<int>>::pointer, min_pointer<int>>::value), "");
static_assert((std::is_same<std::list<int, min_allocator<int>>::const_pointer, min_pointer<const int>>::value), "");
#endif
}