diff options
Diffstat (limited to 'test/std/containers/sequences/list')
72 files changed, 5692 insertions, 0 deletions
diff --git a/test/std/containers/sequences/list/db_back.pass.cpp b/test/std/containers/sequences/list/db_back.pass.cpp new file mode 100644 index 000000000000..b16c0e90701e --- /dev/null +++ b/test/std/containers/sequences/list/db_back.pass.cpp @@ -0,0 +1,56 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// Call back() on empty container. + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <list> +#include <cassert> +#include <iterator> +#include <exception> +#include <cstdlib> + +#include "min_allocator.h" + +int main() +{ + { + typedef int T; + typedef std::list<T> C; + C c(1); + assert(c.back() == 0); + 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 + +int main() +{ +} + +#endif diff --git a/test/std/containers/sequences/list/db_cback.pass.cpp b/test/std/containers/sequences/list/db_cback.pass.cpp new file mode 100644 index 000000000000..ba3977e16f48 --- /dev/null +++ b/test/std/containers/sequences/list/db_cback.pass.cpp @@ -0,0 +1,52 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// Call back() on empty const container. + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <list> +#include <cassert> +#include <iterator> +#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 + +int main() +{ +} + +#endif diff --git a/test/std/containers/sequences/list/db_cfront.pass.cpp b/test/std/containers/sequences/list/db_cfront.pass.cpp new file mode 100644 index 000000000000..d42290c43c08 --- /dev/null +++ b/test/std/containers/sequences/list/db_cfront.pass.cpp @@ -0,0 +1,52 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// Call front() on empty const container. + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <list> +#include <cassert> +#include <iterator> +#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 + +int main() +{ +} + +#endif diff --git a/test/std/containers/sequences/list/db_front.pass.cpp b/test/std/containers/sequences/list/db_front.pass.cpp new file mode 100644 index 000000000000..037b16035c66 --- /dev/null +++ b/test/std/containers/sequences/list/db_front.pass.cpp @@ -0,0 +1,56 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// Call front() on empty container. + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <list> +#include <cassert> +#include <iterator> +#include <exception> +#include <cstdlib> + +#include "min_allocator.h" + +int main() +{ + { + typedef int T; + typedef std::list<T> C; + C c(1); + assert(c.front() == 0); + 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 + +int main() +{ +} + +#endif diff --git a/test/std/containers/sequences/list/db_iterators_6.pass.cpp b/test/std/containers/sequences/list/db_iterators_6.pass.cpp new file mode 100644 index 000000000000..a5b8020b3733 --- /dev/null +++ b/test/std/containers/sequences/list/db_iterators_6.pass.cpp @@ -0,0 +1,58 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// Decrement iterator prior to begin. + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <list> +#include <cassert> +#include <iterator> +#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(); + --i; + 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 + +int main() +{ +} + +#endif diff --git a/test/std/containers/sequences/list/db_iterators_7.pass.cpp b/test/std/containers/sequences/list/db_iterators_7.pass.cpp new file mode 100644 index 000000000000..76a491b1184d --- /dev/null +++ b/test/std/containers/sequences/list/db_iterators_7.pass.cpp @@ -0,0 +1,58 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// Increment iterator past end. + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <list> +#include <cassert> +#include <iterator> +#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.begin(); + ++i; + 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 + +int main() +{ +} + +#endif diff --git a/test/std/containers/sequences/list/db_iterators_8.pass.cpp b/test/std/containers/sequences/list/db_iterators_8.pass.cpp new file mode 100644 index 000000000000..1d1ee23a393a --- /dev/null +++ b/test/std/containers/sequences/list/db_iterators_8.pass.cpp @@ -0,0 +1,54 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// Dereference non-dereferenceable iterator. + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <list> +#include <cassert> +#include <iterator> +#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 + +int main() +{ +} + +#endif diff --git a/test/std/containers/sequences/list/db_iterators_9.pass.cpp b/test/std/containers/sequences/list/db_iterators_9.pass.cpp new file mode 100644 index 000000000000..d02fcd6e4497 --- /dev/null +++ b/test/std/containers/sequences/list/db_iterators_9.pass.cpp @@ -0,0 +1,67 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// Operations on "NULL" iterators + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) do { if (!x) throw 1; } while(0) + +#include <list> +#include <cassert> +#include <iterator> +#include <exception> +#include <cstdlib> + +struct S { int val; }; + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + unsigned lib_asserts; + + typedef S T; + typedef std::list<T> C; + C::iterator i{}; + C::const_iterator ci{}; + + lib_asserts = 0; + try { ++i; } catch (int) { ++lib_asserts; } + try { i++; } catch (int) { ++lib_asserts; } + try { ++ci; } catch (int) { ++lib_asserts; } + try { ci++; } catch (int) { ++lib_asserts; } + assert(lib_asserts == 4); + + lib_asserts = 0; + try { --i; } catch (int) { ++lib_asserts; } + try { i--; } catch (int) { ++lib_asserts; } + try { --ci; } catch (int) { ++lib_asserts; } + try { ci--; } catch (int) { ++lib_asserts; } + assert(lib_asserts == 4); + + lib_asserts = 0; + try { *i; } catch (int) { ++lib_asserts; } + try { *ci; } catch (int) { ++lib_asserts; } + try { (void) i->val; } catch (int) { ++lib_asserts; } + try { (void) ci->val; } catch (int) { ++lib_asserts; } + assert(lib_asserts == 4); + } +#endif +} + +#else + +int main() +{ +} + +#endif diff --git a/test/std/containers/sequences/list/iterators.pass.cpp b/test/std/containers/sequences/list/iterators.pass.cpp new file mode 100644 index 000000000000..a33ee3ecd2db --- /dev/null +++ b/test/std/containers/sequences/list/iterators.pass.cpp @@ -0,0 +1,159 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// iterator begin(); +// iterator end(); +// const_iterator begin() const; +// const_iterator end() const; +// const_iterator cbegin() const; +// const_iterator cend() const; + +#include <list> +#include <cassert> +#include <iterator> + +#include "min_allocator.h" + +struct A +{ + int first; + int second; +}; + +int main() +{ + { + typedef int T; + typedef std::list<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> 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> 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> 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> C; + 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 +#if _LIBCPP_STD_VER > 11 + { + std::list<int> c; + std::list<int>::iterator ii1{}, ii2{}; + std::list<int>::iterator ii4 = ii1; + std::list<int>::const_iterator cii{}; + assert ( ii1 == ii2 ); + assert ( ii1 == ii4 ); + + assert (!(ii1 != ii2 )); + + assert ( (ii1 == cii )); + assert ( (cii == ii1 )); + assert (!(ii1 != cii )); + assert (!(cii != ii1 )); + + assert ( ii1 != c.cbegin()); + assert ( cii != c.begin()); + } +#endif + +} diff --git a/test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp b/test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp new file mode 100644 index 000000000000..14629b173a6c --- /dev/null +++ b/test/std/containers/sequences/list/list.capacity/resize_size.pass.cpp @@ -0,0 +1,81 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// void resize(size_type sz); + +#include <list> +#include <cassert> +#include "DefaultOnly.h" +#include "min_allocator.h" + +int main() +{ + { + std::list<int> l(5, 2); + l.resize(2); + assert(l.size() == 2); + assert(std::distance(l.begin(), l.end()) == 2); + assert(l == std::list<int>(2, 2)); + } + { + std::list<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> l(10); + l.resize(5); + assert(l.size() == 5); + assert(std::distance(l.begin(), l.end()) == 5); + } + { + std::list<DefaultOnly> l(10); + l.resize(20); + assert(l.size() == 20); + 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 +} diff --git a/test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp b/test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp new file mode 100644 index 000000000000..2738ffbbefdd --- /dev/null +++ b/test/std/containers/sequences/list/list.capacity/resize_size_value.pass.cpp @@ -0,0 +1,53 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// void resize(size_type sz, const value_type& x); + +#include <list> +#include <cassert> +#include "DefaultOnly.h" +#include "min_allocator.h" + +int main() +{ + { + std::list<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>(2, 2)); + } + { + std::list<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); + } +#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 +} diff --git a/test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp b/test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp new file mode 100644 index 000000000000..b851eb9dc5a0 --- /dev/null +++ b/test/std/containers/sequences/list/list.cons/assign_copy.pass.cpp @@ -0,0 +1,44 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// list& operator=(const list& c); + +#include <list> +#include <cassert> +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + std::list<int, test_allocator<int> > l(3, 2, test_allocator<int>(5)); + std::list<int, test_allocator<int> > l2(l, test_allocator<int>(3)); + l2 = l; + assert(l2 == l); + assert(l2.get_allocator() == test_allocator<int>(3)); + } + { + std::list<int, other_allocator<int> > l(3, 2, other_allocator<int>(5)); + std::list<int, other_allocator<int> > l2(l, other_allocator<int>(3)); + l2 = l; + 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 +} diff --git a/test/std/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp b/test/std/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp new file mode 100644 index 000000000000..24bd140c4e4f --- /dev/null +++ b/test/std/containers/sequences/list/list.cons/assign_initializer_list.pass.cpp @@ -0,0 +1,45 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// void assign(initializer_list<value_type> il); + +#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); + std::list<int>::iterator i = d.begin(); + assert(*i++ == 3); + 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 +} diff --git a/test/std/containers/sequences/list/list.cons/assign_move.pass.cpp b/test/std/containers/sequences/list/list.cons/assign_move.pass.cpp new file mode 100644 index 000000000000..0fd586f84af7 --- /dev/null +++ b/test/std/containers/sequences/list/list.cons/assign_move.pass.cpp @@ -0,0 +1,82 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// list& operator=(list&& c); + +#include <list> +#include <cassert> +#include "MoveOnly.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + { + std::list<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5)); + std::list<MoveOnly, test_allocator<MoveOnly> > lo(test_allocator<MoveOnly>(5)); + for (int i = 1; i <= 3; ++i) + { + l.push_back(i); + lo.push_back(i); + } + std::list<MoveOnly, test_allocator<MoveOnly> > l2(test_allocator<MoveOnly>(5)); + l2 = std::move(l); + assert(l2 == lo); + assert(l.empty()); + assert(l2.get_allocator() == lo.get_allocator()); + } + { + std::list<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5)); + std::list<MoveOnly, test_allocator<MoveOnly> > lo(test_allocator<MoveOnly>(5)); + for (int i = 1; i <= 3; ++i) + { + l.push_back(i); + lo.push_back(i); + } + std::list<MoveOnly, test_allocator<MoveOnly> > l2(test_allocator<MoveOnly>(6)); + l2 = std::move(l); + assert(l2 == lo); + assert(!l.empty()); + assert(l2.get_allocator() == test_allocator<MoveOnly>(6)); + } + { + std::list<MoveOnly, other_allocator<MoveOnly> > l(other_allocator<MoveOnly>(5)); + std::list<MoveOnly, other_allocator<MoveOnly> > lo(other_allocator<MoveOnly>(5)); + for (int i = 1; i <= 3; ++i) + { + l.push_back(i); + lo.push_back(i); + } + std::list<MoveOnly, other_allocator<MoveOnly> > l2(other_allocator<MoveOnly>(6)); + l2 = std::move(l); + assert(l2 == lo); + 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 +} diff --git a/test/std/containers/sequences/list/list.cons/copy.pass.cpp b/test/std/containers/sequences/list/list.cons/copy.pass.cpp new file mode 100644 index 000000000000..530690a925d4 --- /dev/null +++ b/test/std/containers/sequences/list/list.cons/copy.pass.cpp @@ -0,0 +1,54 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// list(const list& c); + +#include <list> +#include <cassert> +#include "DefaultOnly.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + std::list<int> l(3, 2); + std::list<int> l2 = l; + assert(l2 == l); + } + { + std::list<int, test_allocator<int> > l(3, 2, test_allocator<int>(5)); + std::list<int, test_allocator<int> > l2 = l; + assert(l2 == l); + assert(l2.get_allocator() == l.get_allocator()); + } +#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE + { + std::list<int, other_allocator<int> > l(3, 2, other_allocator<int>(5)); + std::list<int, other_allocator<int> > l2 = l; + assert(l2 == l); + 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 +} diff --git a/test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp b/test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp new file mode 100644 index 000000000000..99fe9f115f94 --- /dev/null +++ b/test/std/containers/sequences/list/list.cons/copy_alloc.pass.cpp @@ -0,0 +1,42 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// list(const list& c, const allocator_type& a); + +#include <list> +#include <cassert> +#include "DefaultOnly.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + std::list<int, test_allocator<int> > l(3, 2, test_allocator<int>(5)); + std::list<int, test_allocator<int> > l2(l, test_allocator<int>(3)); + assert(l2 == l); + assert(l2.get_allocator() == test_allocator<int>(3)); + } + { + std::list<int, other_allocator<int> > l(3, 2, other_allocator<int>(5)); + std::list<int, other_allocator<int> > l2(l, other_allocator<int>(3)); + 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 +} diff --git a/test/std/containers/sequences/list/list.cons/default.pass.cpp b/test/std/containers/sequences/list/list.cons/default.pass.cpp new file mode 100644 index 000000000000..c05bd74ca79e --- /dev/null +++ b/test/std/containers/sequences/list/list.cons/default.pass.cpp @@ -0,0 +1,58 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// explicit list(const Alloc& = Alloc()); + +#include <list> +#include <cassert> +#include "DefaultOnly.h" +#include "min_allocator.h" + +int main() +{ + { + std::list<int> l; + assert(l.size() == 0); + assert(std::distance(l.begin(), l.end()) == 0); + } + { + std::list<DefaultOnly> l; + assert(l.size() == 0); + assert(std::distance(l.begin(), l.end()) == 0); + } + { + std::list<int> l((std::allocator<int>())); + 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); + } + { + std::list<int> l = {}; + assert(l.size() == 0); + assert(std::distance(l.begin(), l.end()) == 0); + } +#endif +} diff --git a/test/std/containers/sequences/list/list.cons/default_noexcept.pass.cpp b/test/std/containers/sequences/list/list.cons/default_noexcept.pass.cpp new file mode 100644 index 000000000000..2455fb39a79a --- /dev/null +++ b/test/std/containers/sequences/list/list.cons/default_noexcept.pass.cpp @@ -0,0 +1,50 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// list() +// noexcept(is_nothrow_default_constructible<allocator_type>::value); + +// This tests a conforming extension + +#include <list> +#include <cassert> + +#include "MoveOnly.h" +#include "test_allocator.h" + +template <class T> +struct some_alloc +{ + typedef T value_type; + some_alloc(const some_alloc&); +}; + +int main() +{ +#if __has_feature(cxx_noexcept) + { + typedef std::list<MoveOnly> C; + static_assert(std::is_nothrow_default_constructible<C>::value, ""); + } + { + typedef std::list<MoveOnly, test_allocator<MoveOnly>> C; + static_assert(std::is_nothrow_default_constructible<C>::value, ""); + } + { + typedef std::list<MoveOnly, other_allocator<MoveOnly>> C; + static_assert(!std::is_nothrow_default_constructible<C>::value, ""); + } + { + typedef std::list<MoveOnly, some_alloc<MoveOnly>> C; + static_assert(!std::is_nothrow_default_constructible<C>::value, ""); + } +#endif +} diff --git a/test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp b/test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp new file mode 100644 index 000000000000..9d9946b68966 --- /dev/null +++ b/test/std/containers/sequences/list/list.cons/default_stack_alloc.pass.cpp @@ -0,0 +1,48 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// explicit list(const Alloc& = Alloc()); + +#include <list> +#include <cassert> +#include "../../../stack_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + std::list<int> l; + assert(l.size() == 0); + assert(std::distance(l.begin(), l.end()) == 0); + } + { + std::list<int> l((std::allocator<int>())); + assert(l.size() == 0); + assert(std::distance(l.begin(), l.end()) == 0); + } + { + std::list<int, stack_allocator<int, 4> > l; + 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 +} diff --git a/test/std/containers/sequences/list/list.cons/dtor_noexcept.pass.cpp b/test/std/containers/sequences/list/list.cons/dtor_noexcept.pass.cpp new file mode 100644 index 000000000000..ca7ade6d19cb --- /dev/null +++ b/test/std/containers/sequences/list/list.cons/dtor_noexcept.pass.cpp @@ -0,0 +1,52 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// ~list() // implied noexcept; + +#include <list> +#include <cassert> + +#include "MoveOnly.h" +#include "test_allocator.h" + +#if __has_feature(cxx_noexcept) + +template <class T> +struct some_alloc +{ + typedef T value_type; + some_alloc(const some_alloc&); + ~some_alloc() noexcept(false); +}; + +#endif + +int main() +{ +#if __has_feature(cxx_noexcept) + { + typedef std::list<MoveOnly> C; + static_assert(std::is_nothrow_destructible<C>::value, ""); + } + { + typedef std::list<MoveOnly, test_allocator<MoveOnly>> C; + static_assert(std::is_nothrow_destructible<C>::value, ""); + } + { + typedef std::list<MoveOnly, other_allocator<MoveOnly>> C; + static_assert(std::is_nothrow_destructible<C>::value, ""); + } + { + typedef std::list<MoveOnly, some_alloc<MoveOnly>> C; + static_assert(!std::is_nothrow_destructible<C>::value, ""); + } +#endif +} diff --git a/test/std/containers/sequences/list/list.cons/initializer_list.pass.cpp b/test/std/containers/sequences/list/list.cons/initializer_list.pass.cpp new file mode 100644 index 000000000000..3307017989eb --- /dev/null +++ b/test/std/containers/sequences/list/list.cons/initializer_list.pass.cpp @@ -0,0 +1,43 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// list(initializer_list<value_type> il); + +#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(); + assert(*i++ == 3); + 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 +} diff --git a/test/std/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp b/test/std/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp new file mode 100644 index 000000000000..4a85e378c1ce --- /dev/null +++ b/test/std/containers/sequences/list/list.cons/initializer_list_alloc.pass.cpp @@ -0,0 +1,46 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// list(initializer_list<value_type> il, const Allocator& a = allocator_type()); + +#include <list> +#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); + std::list<int>::iterator i = d.begin(); + assert(*i++ == 3); + 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 +} diff --git a/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp b/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp new file mode 100644 index 000000000000..09eae8ab43c1 --- /dev/null +++ b/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp @@ -0,0 +1,77 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// template <class InputIterator> +// list(InputIterator first, InputIterator last, const Allocator& = Allocator()); + +#include <list> +#include <cassert> +#include "test_iterators.h" +#include "../../../stack_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + int a[] = {0, 1, 2, 3}; + std::list<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>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j) + assert(*i == j); + } + { + int a[] = {0, 1, 2, 3}; + std::list<int> l(input_iterator<const int*>(a), + input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])), + std::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>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j) + assert(*i == j); + } + { + int a[] = {0, 1, 2, 3}; + std::list<int, stack_allocator<int, sizeof(a)/sizeof(a[0])> > 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>::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 +} diff --git a/test/std/containers/sequences/list/list.cons/move.pass.cpp b/test/std/containers/sequences/list/list.cons/move.pass.cpp new file mode 100644 index 000000000000..54209a55f7e2 --- /dev/null +++ b/test/std/containers/sequences/list/list.cons/move.pass.cpp @@ -0,0 +1,74 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// list(list&& c); + +#include <list> +#include <cassert> +#include "MoveOnly.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + { + std::list<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5)); + std::list<MoveOnly, test_allocator<MoveOnly> > lo(test_allocator<MoveOnly>(5)); + for (int i = 1; i <= 3; ++i) + { + l.push_back(i); + lo.push_back(i); + } + std::list<MoveOnly, test_allocator<MoveOnly> > l2 = std::move(l); + assert(l2 == lo); + assert(l.empty()); + assert(l2.get_allocator() == lo.get_allocator()); + } + { + std::list<MoveOnly, other_allocator<MoveOnly> > l(other_allocator<MoveOnly>(5)); + std::list<MoveOnly, other_allocator<MoveOnly> > lo(other_allocator<MoveOnly>(5)); + for (int i = 1; i <= 3; ++i) + { + l.push_back(i); + lo.push_back(i); + } + std::list<MoveOnly, other_allocator<MoveOnly> > l2 = std::move(l); + assert(l2 == lo); + 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 +#if _LIBCPP_DEBUG >= 1 + { + std::list<int> l1 = {1, 2, 3}; + std::list<int>::iterator i = l1.begin(); + std::list<int> l2 = std::move(l1); + assert(*l2.erase(i) == 2); + assert(l2.size() == 2); + } +#endif +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES +} diff --git a/test/std/containers/sequences/list/list.cons/move_alloc.pass.cpp b/test/std/containers/sequences/list/list.cons/move_alloc.pass.cpp new file mode 100644 index 000000000000..8f82702b296f --- /dev/null +++ b/test/std/containers/sequences/list/list.cons/move_alloc.pass.cpp @@ -0,0 +1,78 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// list(list&& c, const allocator_type& a); + +#include <list> +#include <cassert> +#include "MoveOnly.h" +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + { + std::list<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5)); + std::list<MoveOnly, test_allocator<MoveOnly> > lo(test_allocator<MoveOnly>(5)); + for (int i = 1; i <= 3; ++i) + { + l.push_back(i); + lo.push_back(i); + } + std::list<MoveOnly, test_allocator<MoveOnly> > l2(std::move(l), test_allocator<MoveOnly>(6)); + assert(l2 == lo); + assert(!l.empty()); + assert(l2.get_allocator() == test_allocator<MoveOnly>(6)); + } + { + std::list<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5)); + std::list<MoveOnly, test_allocator<MoveOnly> > lo(test_allocator<MoveOnly>(5)); + for (int i = 1; i <= 3; ++i) + { + l.push_back(i); + lo.push_back(i); + } + std::list<MoveOnly, test_allocator<MoveOnly> > l2(std::move(l), test_allocator<MoveOnly>(5)); + assert(l2 == lo); + assert(l.empty()); + assert(l2.get_allocator() == test_allocator<MoveOnly>(5)); + } + { + std::list<MoveOnly, other_allocator<MoveOnly> > l(other_allocator<MoveOnly>(5)); + std::list<MoveOnly, other_allocator<MoveOnly> > lo(other_allocator<MoveOnly>(5)); + for (int i = 1; i <= 3; ++i) + { + l.push_back(i); + lo.push_back(i); + } + std::list<MoveOnly, other_allocator<MoveOnly> > l2(std::move(l), other_allocator<MoveOnly>(4)); + assert(l2 == lo); + 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 +} diff --git a/test/std/containers/sequences/list/list.cons/move_assign_noexcept.pass.cpp b/test/std/containers/sequences/list/list.cons/move_assign_noexcept.pass.cpp new file mode 100644 index 000000000000..280d93d486e6 --- /dev/null +++ b/test/std/containers/sequences/list/list.cons/move_assign_noexcept.pass.cpp @@ -0,0 +1,52 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// list& operator=(list&& c) +// noexcept( +// allocator_type::propagate_on_container_move_assignment::value && +// is_nothrow_move_assignable<allocator_type>::value); + +// This tests a conforming extension + +#include <list> +#include <cassert> + +#include "MoveOnly.h" +#include "test_allocator.h" + +template <class T> +struct some_alloc +{ + typedef T value_type; + some_alloc(const some_alloc&); +}; + +int main() +{ +#if __has_feature(cxx_noexcept) + { + typedef std::list<MoveOnly> C; + static_assert(std::is_nothrow_move_assignable<C>::value, ""); + } + { + typedef std::list<MoveOnly, test_allocator<MoveOnly>> C; + static_assert(!std::is_nothrow_move_assignable<C>::value, ""); + } + { + typedef std::list<MoveOnly, other_allocator<MoveOnly>> C; + static_assert(std::is_nothrow_move_assignable<C>::value, ""); + } + { + typedef std::list<MoveOnly, some_alloc<MoveOnly>> C; + static_assert(!std::is_nothrow_move_assignable<C>::value, ""); + } +#endif +} diff --git a/test/std/containers/sequences/list/list.cons/move_noexcept.pass.cpp b/test/std/containers/sequences/list/list.cons/move_noexcept.pass.cpp new file mode 100644 index 000000000000..e436a29f5d47 --- /dev/null +++ b/test/std/containers/sequences/list/list.cons/move_noexcept.pass.cpp @@ -0,0 +1,50 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// list(list&&) +// noexcept(is_nothrow_move_constructible<allocator_type>::value); + +// This tests a conforming extension + +#include <list> +#include <cassert> + +#include "MoveOnly.h" +#include "test_allocator.h" + +template <class T> +struct some_alloc +{ + typedef T value_type; + some_alloc(const some_alloc&); +}; + +int main() +{ +#if __has_feature(cxx_noexcept) + { + typedef std::list<MoveOnly> C; + static_assert(std::is_nothrow_move_constructible<C>::value, ""); + } + { + typedef std::list<MoveOnly, test_allocator<MoveOnly>> C; + static_assert(std::is_nothrow_move_constructible<C>::value, ""); + } + { + typedef std::list<MoveOnly, other_allocator<MoveOnly>> C; + static_assert(std::is_nothrow_move_constructible<C>::value, ""); + } + { + typedef std::list<MoveOnly, some_alloc<MoveOnly>> C; + static_assert(!std::is_nothrow_move_constructible<C>::value, ""); + } +#endif +} diff --git a/test/std/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp b/test/std/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp new file mode 100644 index 000000000000..7b7b8a327b88 --- /dev/null +++ b/test/std/containers/sequences/list/list.cons/op_equal_initializer_list.pass.cpp @@ -0,0 +1,44 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// list& operator=(initializer_list<value_type> il); + +#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); + std::list<int>::iterator i = d.begin(); + assert(*i++ == 3); + 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 +} diff --git a/test/std/containers/sequences/list/list.cons/size_type.pass.cpp b/test/std/containers/sequences/list/list.cons/size_type.pass.cpp new file mode 100644 index 000000000000..75b93a3dfb6b --- /dev/null +++ b/test/std/containers/sequences/list/list.cons/size_type.pass.cpp @@ -0,0 +1,103 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// explicit list(size_type n); + +#include <list> +#include <cassert> +#include "DefaultOnly.h" +#include "../../../stack_allocator.h" +#include "min_allocator.h" + +template <class T, class Allocator> +void +test3(unsigned n, Allocator const &alloc = Allocator()) +{ +#if _LIBCPP_STD_VER > 11 + typedef std::list<T, Allocator> C; + typedef typename C::const_iterator const_iterator; + { + C d(n, alloc); + assert(d.size() == n); + assert(std::distance(d.begin(), d.end()) == n); + assert(d.get_allocator() == alloc); + } +#endif +} + + +int main() +{ + { + std::list<int> l(3); + assert(l.size() == 3); + assert(std::distance(l.begin(), l.end()) == 3); + std::list<int>::const_iterator i = l.begin(); + assert(*i == 0); + ++i; + assert(*i == 0); + ++i; + assert(*i == 0); + } + { + std::list<int, stack_allocator<int, 3> > l(3); + assert(l.size() == 3); + assert(std::distance(l.begin(), l.end()) == 3); + std::list<int>::const_iterator i = l.begin(); + assert(*i == 0); + ++i; + assert(*i == 0); + ++i; + assert(*i == 0); + } +#if _LIBCPP_STD_VER > 11 + { + typedef std::list<int, min_allocator<int> > C; + C l(3, min_allocator<int> ()); + assert(l.size() == 3); + assert(std::distance(l.begin(), l.end()) == 3); + C::const_iterator i = l.begin(); + assert(*i == 0); + ++i; + assert(*i == 0); + ++i; + assert(*i == 0); + test3<int, min_allocator<int>> (3); + } +#endif +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + { + std::list<DefaultOnly> l(3); + assert(l.size() == 3); + 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 +} diff --git a/test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp b/test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp new file mode 100644 index 000000000000..12da86da0a41 --- /dev/null +++ b/test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp @@ -0,0 +1,79 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// list(size_type n, const T& value, const Allocator& = Allocator()); + +#include <list> +#include <cassert> +#include "DefaultOnly.h" +#include "../../../stack_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + std::list<int> l(3, 2); + assert(l.size() == 3); + assert(std::distance(l.begin(), l.end()) == 3); + std::list<int>::const_iterator i = l.begin(); + assert(*i == 2); + ++i; + assert(*i == 2); + ++i; + assert(*i == 2); + } + { + std::list<int> l(3, 2, std::allocator<int>()); + assert(l.size() == 3); + assert(std::distance(l.begin(), l.end()) == 3); + std::list<int>::const_iterator i = l.begin(); + assert(*i == 2); + ++i; + assert(*i == 2); + ++i; + assert(*i == 2); + } + { + std::list<int, stack_allocator<int, 3> > l(3, 2); + assert(l.size() == 3); + assert(std::distance(l.begin(), l.end()) == 3); + std::list<int>::const_iterator i = l.begin(); + assert(*i == 2); + ++i; + assert(*i == 2); + ++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 +} diff --git a/test/std/containers/sequences/list/list.modifiers/clear.pass.cpp b/test/std/containers/sequences/list/list.modifiers/clear.pass.cpp new file mode 100644 index 000000000000..38696b6eb503 --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/clear.pass.cpp @@ -0,0 +1,35 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// void clear(); + +#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 +} diff --git a/test/std/containers/sequences/list/list.modifiers/emplace.pass.cpp b/test/std/containers/sequences/list/list.modifiers/emplace.pass.cpp new file mode 100644 index 000000000000..6476d1d6c6ae --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/emplace.pass.cpp @@ -0,0 +1,88 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// template <class... Args> void emplace(const_iterator p, Args&&... args); + +#if _LIBCPP_DEBUG >= 1 +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) +#endif + +#include <list> +#include <cassert> + +#include "min_allocator.h" + +class A +{ + int i_; + double d_; + + A(const A&); + A& operator=(const A&); +public: + A(int i, double d) + : i_(i), d_(d) {} + + int geti() const {return i_;} + double getd() const {return d_;} +}; + +int main() +{ +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + { + std::list<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_DEBUG >= 1 + { + std::list<A> c1; + std::list<A> c2; + std::list<A>::iterator i = c1.emplace(c2.cbegin(), 2, 3.5); + 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_DEBUG >= 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 +} diff --git a/test/std/containers/sequences/list/list.modifiers/emplace_back.pass.cpp b/test/std/containers/sequences/list/list.modifiers/emplace_back.pass.cpp new file mode 100644 index 000000000000..5983efc59ad1 --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/emplace_back.pass.cpp @@ -0,0 +1,66 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// template <class... Args> void emplace_back(Args&&... args); + +#include <list> +#include <cassert> + +#include "min_allocator.h" + +class A +{ + int i_; + double d_; + + A(const A&); + A& operator=(const A&); +public: + A(int i, double d) + : i_(i), d_(d) {} + + int geti() const {return i_;} + double getd() const {return d_;} +}; + +int main() +{ +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + { + std::list<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); + } +#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 +} diff --git a/test/std/containers/sequences/list/list.modifiers/emplace_front.pass.cpp b/test/std/containers/sequences/list/list.modifiers/emplace_front.pass.cpp new file mode 100644 index 000000000000..e2e68e331381 --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/emplace_front.pass.cpp @@ -0,0 +1,66 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// template <class... Args> void emplace_front(Args&&... args); + +#include <list> +#include <cassert> + +#include "min_allocator.h" + +class A +{ + int i_; + double d_; + + A(const A&); + A& operator=(const A&); +public: + A(int i, double d) + : i_(i), d_(d) {} + + int geti() const {return i_;} + double getd() const {return d_;} +}; + +int main() +{ +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + { + std::list<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); + } +#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 +} diff --git a/test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp b/test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp new file mode 100644 index 000000000000..c1cc90043670 --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/erase_iter.pass.cpp @@ -0,0 +1,65 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// iterator erase(const_iterator position); + +#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(); + ++i; + std::list<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); + } +#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 +} diff --git a/test/std/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp b/test/std/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp new file mode 100644 index 000000000000..18c15eb02c85 --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/erase_iter_db1.pass.cpp @@ -0,0 +1,51 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// Call erase(const_iterator position) with end() + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <list> +#include <cassert> +#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 + +int main() +{ +} + +#endif diff --git a/test/std/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp b/test/std/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp new file mode 100644 index 000000000000..61ff8409c964 --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/erase_iter_db2.pass.cpp @@ -0,0 +1,53 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// Call erase(const_iterator position) with iterator from another container + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <list> +#include <cassert> +#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 + +int main() +{ +} + +#endif diff --git a/test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp b/test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp new file mode 100644 index 000000000000..bd3f66b4116a --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/erase_iter_iter.pass.cpp @@ -0,0 +1,84 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// iterator erase(const_iterator first, const_iterator last); + +#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>::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> l1(a1, a1+3); + std::list<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>(a1+1, a1+3)); + } + { + std::list<int> l1(a1, a1+3); + std::list<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>(a1+2, a1+3)); + } + { + std::list<int> l1(a1, a1+3); + std::list<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()); + } +#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 +} diff --git a/test/std/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp b/test/std/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp new file mode 100644 index 000000000000..71ad497e7d97 --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp @@ -0,0 +1,51 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// Call erase(const_iterator first, const_iterator last); with first iterator from another container + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <list> +#include <cassert> +#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 + +int main() +{ +} + +#endif diff --git a/test/std/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp b/test/std/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp new file mode 100644 index 000000000000..db76b4de4865 --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/erase_iter_iter_db2.pass.cpp @@ -0,0 +1,51 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// Call erase(const_iterator first, const_iterator last); with second iterator from another container + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <list> +#include <cassert> +#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 + +int main() +{ +} + +#endif diff --git a/test/std/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp b/test/std/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp new file mode 100644 index 000000000000..25c5c6147a01 --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/erase_iter_iter_db3.pass.cpp @@ -0,0 +1,51 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// Call erase(const_iterator first, const_iterator last); with both iterators from another container + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <list> +#include <cassert> +#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 + +int main() +{ +} + +#endif diff --git a/test/std/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp b/test/std/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp new file mode 100644 index 000000000000..35a4ceb4848a --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/erase_iter_iter_db4.pass.cpp @@ -0,0 +1,49 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// Call erase(const_iterator first, const_iterator last); with a bad range + +#if _LIBCPP_DEBUG >= 1 + +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) + +#include <list> +#include <cassert> +#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 + +int main() +{ +} + +#endif diff --git a/test/std/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp b/test/std/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp new file mode 100644 index 000000000000..a82a2696e82a --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/insert_iter_initializer_list.pass.cpp @@ -0,0 +1,67 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// iterator insert(const_iterator p, initializer_list<value_type> il); + +#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); + 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); + } +#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 +} diff --git a/test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp b/test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp new file mode 100644 index 000000000000..a7f1917ab856 --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/insert_iter_iter_iter.pass.cpp @@ -0,0 +1,185 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// template <InputIterator Iter> +// iterator insert(const_iterator position, Iter first, Iter last); + +// UNSUPPORTED: sanitizer-new-delete + +#if _LIBCPP_DEBUG >= 1 +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) +#endif + +#include <list> +#include <cstdlib> +#include <cassert> +#include "test_iterators.h" +#include "min_allocator.h" + +int throw_next = 0xFFFF; +int count = 0; + +void* operator new(std::size_t s) throw(std::bad_alloc) +{ + if (throw_next == 0) + throw std::bad_alloc(); + --throw_next; + ++count; + return std::malloc(s); +} + +void operator delete(void* p) throw() +{ + --count; + std::free(p); +} + +int main() +{ + { + int a1[] = {1, 2, 3}; + std::list<int> l1; + std::list<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); + } + throw_next = 0xFFFF; +#if _LIBCPP_DEBUG >= 1 + { + std::list<int> v(100); + std::list<int> v2(100); + int a[] = {1, 2, 3, 4, 5}; + const int N = sizeof(a)/sizeof(a[0]); + std::list<int>::iterator i = v.insert(next(v2.cbegin(), 10), input_iterator<const int*>(a), + input_iterator<const int*>(a+N)); + 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_DEBUG >= 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 +} diff --git a/test/std/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp b/test/std/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp new file mode 100644 index 000000000000..3d5dec299b95 --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/insert_iter_rvalue.pass.cpp @@ -0,0 +1,68 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// iterator insert(const_iterator position, value_type&& x); + +#if _LIBCPP_DEBUG >= 1 +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) +#endif + +#include <list> +#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); + 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_DEBUG >= 1 + { + std::list<int> v1(3); + std::list<int> v2(3); + v1.insert(v2.begin(), 4); + 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_DEBUG >= 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 +} diff --git a/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp b/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp new file mode 100644 index 000000000000..eeb74b83e509 --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/insert_iter_size_value.pass.cpp @@ -0,0 +1,106 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// iterator insert(const_iterator position, size_type n, const value_type& x); + +// UNSUPPORTED: sanitizer-new-delete + +#if _LIBCPP_DEBUG >= 1 +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) +#endif + +#include <list> +#include <cstdlib> +#include <cassert> + +#include "min_allocator.h" + +int throw_next = 0xFFFF; +int count = 0; + +void* operator new(std::size_t s) throw(std::bad_alloc) +{ + if (throw_next == 0) + throw std::bad_alloc(); + --throw_next; + ++count; + return std::malloc(s); +} + +void operator delete(void* p) throw() +{ + --count; + std::free(p); +} + +int main() +{ + { + int a1[] = {1, 2, 3}; + int a2[] = {1, 4, 4, 4, 4, 4, 2, 3}; + std::list<int> l1(a1, a1+3); + std::list<int>::iterator i = l1.insert(next(l1.cbegin()), 5, 4); + assert(i == next(l1.begin())); + assert(l1 == std::list<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>(a2, a2+8)); + } +#if _LIBCPP_DEBUG >= 1 + { + std::list<int> c1(100); + std::list<int> c2; + std::list<int>::iterator i = c1.insert(next(c2.cbegin(), 10), 5, 1); + 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_DEBUG >= 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 +} diff --git a/test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp b/test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp new file mode 100644 index 000000000000..406e93a376a1 --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/insert_iter_value.pass.cpp @@ -0,0 +1,112 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// iterator insert(const_iterator position, const value_type& x); + +// UNSUPPORTED: sanitizer-new-delete + +#if _LIBCPP_DEBUG >= 1 +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) +#endif + +#include <list> +#include <cstdlib> +#include <cassert> + +#include "min_allocator.h" + +int throw_next = 0xFFFF; +int count = 0; + +void* operator new(std::size_t s) throw(std::bad_alloc) +{ + if (throw_next == 0) + throw std::bad_alloc(); + --throw_next; + ++count; + return std::malloc(s); +} + +void operator delete(void* p) throw() +{ + --count; + std::free(p); +} + +int main() +{ + { + int a1[] = {1, 2, 3}; + int a2[] = {1, 4, 2, 3}; + std::list<int> l1(a1, a1+3); + std::list<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>(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>(a2, a2+4)); + } +#if _LIBCPP_DEBUG >= 1 + { + std::list<int> v1(3); + std::list<int> v2(3); + int i = 4; + v1.insert(v2.begin(), i); + 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_DEBUG >= 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 +} diff --git a/test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp b/test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp new file mode 100644 index 000000000000..3add8518809c --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/pop_back.pass.cpp @@ -0,0 +1,55 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// void pop_back(); + +#if _LIBCPP_DEBUG >= 1 +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) +#endif + +#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(); + assert(c == std::list<int>(a, a+2)); + c.pop_back(); + assert(c == std::list<int>(a, a+1)); + c.pop_back(); + assert(c.empty()); +#if _LIBCPP_DEBUG >= 1 + 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_DEBUG >= 1 + c.pop_back(); + assert(false); +#endif + } +#endif +} diff --git a/test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp b/test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp new file mode 100644 index 000000000000..aec17cc08f43 --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/pop_front.pass.cpp @@ -0,0 +1,43 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// void pop_front(); + +#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(); + assert(c == std::list<int>(a+1, a+3)); + c.pop_front(); + 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 +} diff --git a/test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp new file mode 100644 index 000000000000..2638c541fa1c --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/push_back.pass.cpp @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// void push_back(const value_type& x); + +#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 +} diff --git a/test/std/containers/sequences/list/list.modifiers/push_back_exception_safety.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_back_exception_safety.pass.cpp new file mode 100644 index 000000000000..9d3c05e26b1c --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/push_back_exception_safety.pass.cpp @@ -0,0 +1,73 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// void push_back(const value_type& x); + +#include <list> +#include <cassert> + +// Flag that makes the copy constructor for CMyClass throw an exception +static bool gCopyConstructorShouldThow = false; + + +class CMyClass { + public: CMyClass(); + public: CMyClass(const CMyClass& iOther); + public: ~CMyClass(); + + private: int fMagicValue; + + private: static int kStartedConstructionMagicValue; + private: static int kFinishedConstructionMagicValue; +}; + +// Value for fMagicValue when the constructor has started running, but not yet finished +int CMyClass::kStartedConstructionMagicValue = 0; +// Value for fMagicValue when the constructor has finished running +int CMyClass::kFinishedConstructionMagicValue = 12345; + +CMyClass::CMyClass() : + fMagicValue(kStartedConstructionMagicValue) +{ + // Signal that the constructor has finished running + fMagicValue = kFinishedConstructionMagicValue; +} + +CMyClass::CMyClass(const CMyClass& /*iOther*/) : + fMagicValue(kStartedConstructionMagicValue) +{ + // If requested, throw an exception _before_ setting fMagicValue to kFinishedConstructionMagicValue + if (gCopyConstructorShouldThow) { + throw std::exception(); + } + // Signal that the constructor has finished running + fMagicValue = kFinishedConstructionMagicValue; +} + +CMyClass::~CMyClass() { + // Only instances for which the constructor has finished running should be destructed + assert(fMagicValue == kFinishedConstructionMagicValue); +} + +int main() +{ + CMyClass instance; + std::list<CMyClass> vec; + + vec.push_back(instance); + + gCopyConstructorShouldThow = true; + try { + vec.push_back(instance); + } + catch (...) { + } +} diff --git a/test/std/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp new file mode 100644 index 000000000000..a2837f813bea --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/push_back_rvalue.pass.cpp @@ -0,0 +1,46 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// void push_back(value_type&& x); + +#include <list> +#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); + assert(l1.front() == MoveOnly(1)); + l1.push_back(MoveOnly(2)); + 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 +} diff --git a/test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp new file mode 100644 index 000000000000..b7f4febcd385 --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/push_front.pass.cpp @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// void push_front(const value_type& x); + +#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 +} diff --git a/test/std/containers/sequences/list/list.modifiers/push_front_exception_safety.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_front_exception_safety.pass.cpp new file mode 100644 index 000000000000..6609005262eb --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/push_front_exception_safety.pass.cpp @@ -0,0 +1,73 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// void push_front(const value_type& x); + +#include <list> +#include <cassert> + +// Flag that makes the copy constructor for CMyClass throw an exception +static bool gCopyConstructorShouldThow = false; + + +class CMyClass { + public: CMyClass(); + public: CMyClass(const CMyClass& iOther); + public: ~CMyClass(); + + private: int fMagicValue; + + private: static int kStartedConstructionMagicValue; + private: static int kFinishedConstructionMagicValue; +}; + +// Value for fMagicValue when the constructor has started running, but not yet finished +int CMyClass::kStartedConstructionMagicValue = 0; +// Value for fMagicValue when the constructor has finished running +int CMyClass::kFinishedConstructionMagicValue = 12345; + +CMyClass::CMyClass() : + fMagicValue(kStartedConstructionMagicValue) +{ + // Signal that the constructor has finished running + fMagicValue = kFinishedConstructionMagicValue; +} + +CMyClass::CMyClass(const CMyClass& /*iOther*/) : + fMagicValue(kStartedConstructionMagicValue) +{ + // If requested, throw an exception _before_ setting fMagicValue to kFinishedConstructionMagicValue + if (gCopyConstructorShouldThow) { + throw std::exception(); + } + // Signal that the constructor has finished running + fMagicValue = kFinishedConstructionMagicValue; +} + +CMyClass::~CMyClass() { + // Only instances for which the constructor has finished running should be destructed + assert(fMagicValue == kFinishedConstructionMagicValue); +} + +int main() +{ + CMyClass instance; + std::list<CMyClass> vec; + + vec.push_front(instance); + + gCopyConstructorShouldThow = true; + try { + vec.push_front(instance); + } + catch (...) { + } +} diff --git a/test/std/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp b/test/std/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp new file mode 100644 index 000000000000..4f41c3dd390b --- /dev/null +++ b/test/std/containers/sequences/list/list.modifiers/push_front_rvalue.pass.cpp @@ -0,0 +1,46 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// void push_front(value_type&& x); + +#include <list> +#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); + assert(l1.front() == MoveOnly(1)); + l1.push_front(MoveOnly(2)); + 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 +} diff --git a/test/std/containers/sequences/list/list.ops/merge.pass.cpp b/test/std/containers/sequences/list/list.ops/merge.pass.cpp new file mode 100644 index 000000000000..d226ed5dc642 --- /dev/null +++ b/test/std/containers/sequences/list/list.ops/merge.pass.cpp @@ -0,0 +1,41 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// void merge(list& x); + +#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}; + std::list<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0])); + 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 +} diff --git a/test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp b/test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp new file mode 100644 index 000000000000..ce861a5dcb88 --- /dev/null +++ b/test/std/containers/sequences/list/list.ops/merge_comp.pass.cpp @@ -0,0 +1,42 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// template <class Compare> void merge(list& x, Compare comp); + +#include <list> +#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}; + std::list<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0])); + 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 +} diff --git a/test/std/containers/sequences/list/list.ops/remove.pass.cpp b/test/std/containers/sequences/list/list.ops/remove.pass.cpp new file mode 100644 index 000000000000..f580c94ef486 --- /dev/null +++ b/test/std/containers/sequences/list/list.ops/remove.pass.cpp @@ -0,0 +1,69 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// void remove(const value_type& value); + +#include <list> +#include <cassert> + +#include "min_allocator.h" + +struct S { + S(int i) : i_(new int(i)) {} + S(const S &rhs) : i_(new int(*rhs.i_)) {} + S& operator = (const S &rhs) { *i_ = *rhs.i_; return *this; } + ~S () { delete i_; i_ = NULL; } + bool operator == (const S &rhs) const { return *i_ == *rhs.i_; } + int get () const { return *i_; } + int *i_; + }; + + +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)); + } + { // LWG issue #526 + int a1[] = {1, 2, 1, 3, 5, 8, 11}; + int a2[] = { 2, 3, 5, 8, 11}; + std::list<int> c(a1, a1+7); + c.remove(c.front()); + assert(c == std::list<int>(a2, a2+5)); + } + { + int a1[] = {1, 2, 1, 3, 5, 8, 11, 1}; + int a2[] = { 2, 3, 5, 8, 11 }; + std::list<S> c; + for(int *ip = a1; ip < a1+8; ++ip) + c.push_back(S(*ip)); + c.remove(c.front()); + std::list<S>::const_iterator it = c.begin(); + for(int *ip = a2; ip < a2+5; ++ip, ++it) { + assert ( it != c.end()); + assert ( *ip == it->get()); + } + assert ( it == c.end ()); + } +#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 +} diff --git a/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp b/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp new file mode 100644 index 000000000000..162919ed85de --- /dev/null +++ b/test/std/containers/sequences/list/list.ops/remove_if.pass.cpp @@ -0,0 +1,64 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// template <class Pred> void remove_if(Pred pred); + +#include <list> +#include <cassert> +#include <functional> + +#include "min_allocator.h" +#include "counting_predicates.hpp" + +bool even(int i) +{ + return i % 2 == 0; +} + +bool g(int i) +{ + return i < 3; +} + +typedef unary_counting_predicate<bool(*)(int), int> Predicate; + +int main() +{ + { + int a1[] = {1, 2, 3, 4}; + int a2[] = {3, 4}; + std::list<int> c(a1, a1+4); + Predicate cp(g); + c.remove_if(std::ref(cp)); + assert(c == std::list<int>(a2, a2+2)); + assert(cp.count() == 4); + } + { + int a1[] = {1, 2, 3, 4}; + int a2[] = {1, 3}; + std::list<int> c(a1, a1+4); + Predicate cp(even); + c.remove_if(std::ref(cp)); + assert(c == std::list<int>(a2, a2+2)); + assert(cp.count() == 4); + } +#if __cplusplus >= 201103L + { + int a1[] = {1, 2, 3, 4}; + int a2[] = {3, 4}; + std::list<int, min_allocator<int>> c(a1, a1+4); + Predicate cp(g); + c.remove_if(std::ref(cp)); + assert((c == std::list<int, min_allocator<int>>(a2, a2+2))); + assert(cp.count() == 4); + } +#endif +} diff --git a/test/std/containers/sequences/list/list.ops/reverse.pass.cpp b/test/std/containers/sequences/list/list.ops/reverse.pass.cpp new file mode 100644 index 000000000000..046453ae5386 --- /dev/null +++ b/test/std/containers/sequences/list/list.ops/reverse.pass.cpp @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// void reverse(); + +#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 +} diff --git a/test/std/containers/sequences/list/list.ops/sort.pass.cpp b/test/std/containers/sequences/list/list.ops/sort.pass.cpp new file mode 100644 index 000000000000..1c11227237a7 --- /dev/null +++ b/test/std/containers/sequences/list/list.ops/sort.pass.cpp @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// void sort(); + +#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 +} diff --git a/test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp b/test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp new file mode 100644 index 000000000000..28125ab83c00 --- /dev/null +++ b/test/std/containers/sequences/list/list.ops/sort_comp.pass.cpp @@ -0,0 +1,38 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// template <class Compare> sort(Compare comp); + +#include <list> +#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 +} diff --git a/test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp b/test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp new file mode 100644 index 000000000000..354871c20afa --- /dev/null +++ b/test/std/containers/sequences/list/list.ops/splice_pos_list.pass.cpp @@ -0,0 +1,803 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// void splice(const_iterator position, list& x); + +#if _LIBCPP_DEBUG >= 1 +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) +#endif + +#include <list> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + int a1[] = {1, 2, 3}; + int a2[] = {4, 5, 6}; + { + std::list<int> l1; + std::list<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> l1; + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 4); + } + { + std::list<int> l1; + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 4); + ++i; + assert(*i == 5); + } + { + std::list<int> l1; + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 4); + ++i; + assert(*i == 5); + ++i; + assert(*i == 6); + } + { + std::list<int> l1(a1, a1+1); + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 1); + } + { + std::list<int> l1(a1, a1+1); + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 1); + } + { + std::list<int> l1(a1, a1+1); + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 4); + ++i; + assert(*i == 1); + } + { + std::list<int> l1(a1, a1+1); + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 1); + ++i; + assert(*i == 4); + } + { + std::list<int> l1(a1, a1+1); + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 4); + ++i; + assert(*i == 5); + ++i; + assert(*i == 1); + } + { + std::list<int> l1(a1, a1+1); + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 1); + ++i; + assert(*i == 4); + ++i; + assert(*i == 5); + } + { + std::list<int> l1(a1, a1+1); + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 4); + ++i; + assert(*i == 5); + ++i; + assert(*i == 6); + ++i; + assert(*i == 1); + } + { + std::list<int> l1(a1, a1+1); + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 1); + ++i; + assert(*i == 4); + ++i; + assert(*i == 5); + ++i; + assert(*i == 6); + } + { + std::list<int> l1(a1, a1+2); + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 1); + ++i; + assert(*i == 2); + } + { + std::list<int> l1(a1, a1+2); + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 1); + ++i; + assert(*i == 2); + } + { + std::list<int> l1(a1, a1+2); + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 1); + ++i; + assert(*i == 2); + } + { + std::list<int> l1(a1, a1+2); + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 4); + ++i; + assert(*i == 1); + ++i; + assert(*i == 2); + } + { + std::list<int> l1(a1, a1+2); + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 1); + ++i; + assert(*i == 4); + ++i; + assert(*i == 2); + } + { + std::list<int> l1(a1, a1+2); + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 1); + ++i; + assert(*i == 2); + ++i; + assert(*i == 4); + } + { + std::list<int> l1(a1, a1+2); + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 4); + ++i; + assert(*i == 5); + ++i; + assert(*i == 1); + ++i; + assert(*i == 2); + } + { + std::list<int> l1(a1, a1+2); + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 1); + ++i; + assert(*i == 4); + ++i; + assert(*i == 5); + ++i; + assert(*i == 2); + } + { + std::list<int> l1(a1, a1+2); + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 1); + ++i; + assert(*i == 2); + ++i; + assert(*i == 4); + ++i; + assert(*i == 5); + } + { + std::list<int> l1(a1, a1+3); + std::list<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>::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> l1(a1, a1+3); + std::list<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>::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> l1(a1, a1+3); + std::list<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>::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> l1(a1, a1+3); + std::list<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>::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_DEBUG >= 1 + { + std::list<int> v1(3); + std::list<int> v2(3); + v1.splice(v2.begin(), v2); + 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_DEBUG >= 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 +} diff --git a/test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp b/test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp new file mode 100644 index 000000000000..5082c3f85175 --- /dev/null +++ b/test/std/containers/sequences/list/list.ops/splice_pos_list_iter.pass.cpp @@ -0,0 +1,357 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// void splice(const_iterator position, list<T,Allocator>& x, iterator i); + +#if _LIBCPP_DEBUG >= 1 +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) +#endif + +#include <list> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + int a1[] = {1, 2, 3}; + int a2[] = {4, 5, 6}; + { + std::list<int> l1; + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 4); + } + { + std::list<int> l1; + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 4); + i = l2.begin(); + assert(*i == 5); + } + { + std::list<int> l1; + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 5); + i = l2.begin(); + assert(*i == 4); + } + { + std::list<int> l1; + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 4); + i = l2.begin(); + assert(*i == 5); + ++i; + assert(*i == 6); + } + { + std::list<int> l1; + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 5); + i = l2.begin(); + assert(*i == 4); + ++i; + assert(*i == 6); + } + { + std::list<int> l1; + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 6); + i = l2.begin(); + assert(*i == 4); + ++i; + assert(*i == 5); + } + { + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 1); + } + { + std::list<int> l1(a1, a1+1); + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 4); + ++i; + assert(*i == 1); + } + { + std::list<int> l1(a1, a1+1); + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 1); + ++i; + assert(*i == 4); + } + { + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 1); + ++i; + assert(*i == 2); + } + { + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 2); + ++i; + assert(*i == 1); + } + { + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 1); + ++i; + assert(*i == 2); + } + { + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 1); + ++i; + assert(*i == 2); + } +#if _LIBCPP_DEBUG >= 1 + { + std::list<int> v1(3); + std::list<int> v2(3); + v1.splice(v1.begin(), v2, v1.begin()); + 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_DEBUG >= 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 +} diff --git a/test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp b/test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp new file mode 100644 index 000000000000..fcc4acceec57 --- /dev/null +++ b/test/std/containers/sequences/list/list.ops/splice_pos_list_iter_iter.pass.cpp @@ -0,0 +1,237 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// void splice(const_iterator position, list& x, iterator first, iterator last); + +#if _LIBCPP_DEBUG >= 1 +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) +#endif + +#include <list> +#include <cassert> + +#include "min_allocator.h" + +int main() +{ + int a1[] = {1, 2, 3}; + int a2[] = {4, 5, 6}; + { + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 1); + ++i; + assert(*i == 2); + ++i; + assert(*i == 3); + } + { + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 2); + ++i; + assert(*i == 1); + ++i; + assert(*i == 3); + } + { + std::list<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>::const_iterator i = l1.begin(); + assert(*i == 2); + ++i; + assert(*i == 3); + ++i; + assert(*i == 1); + } + { + std::list<int> l1(a1, a1+3); + std::list<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>::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> l1(a1, a1+3); + std::list<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>::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> l1(a1, a1+3); + std::list<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>::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_DEBUG >= 1 + { + std::list<int> v1(3); + std::list<int> v2(3); + v1.splice(v1.begin(), v2, v2.begin(), v1.end()); + 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_DEBUG >= 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 +} diff --git a/test/std/containers/sequences/list/list.ops/unique.pass.cpp b/test/std/containers/sequences/list/list.ops/unique.pass.cpp new file mode 100644 index 000000000000..48cad1ddd156 --- /dev/null +++ b/test/std/containers/sequences/list/list.ops/unique.pass.cpp @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// void unique(); + +#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 +} diff --git a/test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp b/test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp new file mode 100644 index 000000000000..f8935b81f6a7 --- /dev/null +++ b/test/std/containers/sequences/list/list.ops/unique_pred.pass.cpp @@ -0,0 +1,42 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// template <class BinaryPred> void unique(BinaryPred pred); + +#include <list> +#include <cassert> + +#include "min_allocator.h" + +bool g(int x, int y) +{ + return x == 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 +} diff --git a/test/std/containers/sequences/list/list.special/db_swap_1.pass.cpp b/test/std/containers/sequences/list/list.special/db_swap_1.pass.cpp new file mode 100644 index 000000000000..f7171795cd5f --- /dev/null +++ b/test/std/containers/sequences/list/list.special/db_swap_1.pass.cpp @@ -0,0 +1,59 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// template <class T, class Alloc> +// void swap(list<T,Alloc>& x, list<T,Alloc>& y); + +#if _LIBCPP_DEBUG >= 1 +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) +#endif + +#include <list> +#include <cassert> + +#include <__debug> +#include "min_allocator.h" + +int main() +{ +#if _LIBCPP_DEBUG >= 1 + { + int a1[] = {1, 3, 7, 9, 10}; + int a2[] = {0, 2, 4, 5, 6, 8, 11}; + std::list<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0])); + std::list<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0])); + std::list<int>::iterator i1 = c1.begin(); + std::list<int>::iterator i2 = c2.begin(); + swap(c1, c2); + c1.erase(i2); + c2.erase(i1); + std::list<int>::iterator j = i1; + 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 +} diff --git a/test/std/containers/sequences/list/list.special/swap.pass.cpp b/test/std/containers/sequences/list/list.special/swap.pass.cpp new file mode 100644 index 000000000000..bc5f4857edc7 --- /dev/null +++ b/test/std/containers/sequences/list/list.special/swap.pass.cpp @@ -0,0 +1,146 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// template <class T, class Alloc> +// void swap(list<T,Alloc>& x, list<T,Alloc>& y); + +#include <list> +#include <cassert> +#include "test_allocator.h" +#include "min_allocator.h" + +int main() +{ + { + int a1[] = {1, 3, 7, 9, 10}; + int a2[] = {0, 2, 4, 5, 6, 8, 11}; + std::list<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0])); + std::list<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0])); + swap(c1, c2); + assert(c1 == std::list<int>(a2, a2+sizeof(a2)/sizeof(a2[0]))); + assert(c2 == std::list<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> c1(a1, a1); + std::list<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0])); + swap(c1, c2); + assert(c1 == std::list<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> c1(a1, a1+sizeof(a1)/sizeof(a1[0])); + std::list<int> c2(a2, a2); + swap(c1, c2); + assert(c1.empty()); + assert(distance(c1.begin(), c1.end()) == 0); + assert(c2 == std::list<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> c1(a1, a1); + std::list<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 test_allocator<int> A; + std::list<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(1)); + std::list<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(2)); + swap(c1, c2); + assert((c1 == std::list<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0])))); + assert(c1.get_allocator() == A(1)); + assert((c2 == std::list<int, A>(a1, a1+sizeof(a1)/sizeof(a1[0])))); + assert(c2.get_allocator() == A(2)); + } +#endif + { + int a1[] = {1, 3, 7, 9, 10}; + int a2[] = {0, 2, 4, 5, 6, 8, 11}; + typedef other_allocator<int> A; + std::list<int, A> c1(a1, a1+sizeof(a1)/sizeof(a1[0]), A(1)); + std::list<int, A> c2(a2, a2+sizeof(a2)/sizeof(a2[0]), A(2)); + swap(c1, c2); + assert((c1 == std::list<int, A>(a2, a2+sizeof(a2)/sizeof(a2[0])))); + assert(c1.get_allocator() == A(2)); + 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 +} diff --git a/test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp b/test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp new file mode 100644 index 000000000000..9c83ad58fed4 --- /dev/null +++ b/test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp @@ -0,0 +1,90 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// void swap(list& c) +// noexcept(!allocator_type::propagate_on_container_swap::value || +// __is_nothrow_swappable<allocator_type>::value); +// +// In C++17, the standard says that swap shall have: +// noexcept(allocator_traits<Allocator>::is_always_equal::value); + +// This tests a conforming extension + +#include <list> +#include <cassert> + +#include "MoveOnly.h" +#include "test_allocator.h" + +template <class T> +struct some_alloc +{ + typedef T value_type; + + some_alloc() {} + some_alloc(const some_alloc&); + void deallocate(void*, unsigned) {} + + typedef std::true_type propagate_on_container_swap; +}; + +template <class T> +struct some_alloc2 +{ + typedef T value_type; + + some_alloc2() {} + some_alloc2(const some_alloc2&); + void deallocate(void*, unsigned) {} + + typedef std::false_type propagate_on_container_swap; + typedef std::true_type is_always_equal; +}; + +int main() +{ +#if __has_feature(cxx_noexcept) + { + typedef std::list<MoveOnly> C; + C c1, c2; + static_assert(noexcept(swap(c1, c2)), ""); + } + { + typedef std::list<MoveOnly, test_allocator<MoveOnly>> C; + C c1, c2; + static_assert(noexcept(swap(c1, c2)), ""); + } + { + typedef std::list<MoveOnly, other_allocator<MoveOnly>> C; + C c1, c2; + static_assert(noexcept(swap(c1, c2)), ""); + } + { + typedef std::list<MoveOnly, some_alloc<MoveOnly>> C; + C c1, c2; +#if TEST_STD_VER >= 14 + // In c++14, if POCS is set, swapping the allocator is required not to throw + static_assert( noexcept(swap(c1, c2)), ""); +#else + static_assert(!noexcept(swap(c1, c2)), ""); +#endif + } +#if TEST_STD_VER >= 14 + { + typedef std::list<MoveOnly, some_alloc2<MoveOnly>> C; + C c1, c2; + // if the allocators are always equal, then the swap can be noexcept + static_assert( noexcept(swap(c1, c2)), ""); + } +#endif + +#endif +} diff --git a/test/std/containers/sequences/list/types.pass.cpp b/test/std/containers/sequences/list/types.pass.cpp new file mode 100644 index 000000000000..77303601ae97 --- /dev/null +++ b/test/std/containers/sequences/list/types.pass.cpp @@ -0,0 +1,48 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +// template <class T, class Alloc = allocator<T> > +// class list +// { +// public: +// +// // types: +// typedef T value_type; +// typedef Alloc allocator_type; +// typedef typename allocator_type::reference reference; +// typedef typename allocator_type::const_reference const_reference; +// typedef typename allocator_type::pointer pointer; +// typedef typename allocator_type::const_pointer const_pointer; + +#include <list> +#include <type_traits> + +#include "min_allocator.h" + +struct A { std::list<A> v; }; // incomplete type support + +int main() +{ + static_assert((std::is_same<std::list<int>::value_type, int>::value), ""); + static_assert((std::is_same<std::list<int>::allocator_type, std::allocator<int> >::value), ""); + static_assert((std::is_same<std::list<int>::reference, std::allocator<int>::reference>::value), ""); + 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 +} diff --git a/test/std/containers/sequences/list/version.pass.cpp b/test/std/containers/sequences/list/version.pass.cpp new file mode 100644 index 000000000000..097c013f52cb --- /dev/null +++ b/test/std/containers/sequences/list/version.pass.cpp @@ -0,0 +1,20 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <list> + +#include <list> + +#ifndef _LIBCPP_VERSION +#error _LIBCPP_VERSION not defined +#endif + +int main() +{ +} |