int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
std::vector<MoveOnly> v(100);
std::vector<MoveOnly>::iterator i = v.insert(v.cbegin() + 10, MoveOnly(3));
assert(v.size() == 101);
assert(i == v.begin() + 10);
int j;
for (j = 0; j < 10; ++j)
assert(v[j] == MoveOnly());
assert(v[j] == MoveOnly(3));
for (++j; j < 101; ++j)
assert(v[j] == MoveOnly());
}
{
std::vector<MoveOnly, stack_allocator<MoveOnly, 300> > v(100);
std::vector<MoveOnly, stack_allocator<MoveOnly, 300> >::iterator i = v.insert(v.cbegin() + 10, MoveOnly(3));
assert(v.size() == 101);
assert(i == v.begin() + 10);
int j;
for (j = 0; j < 10; ++j)
assert(v[j] == MoveOnly());
assert(v[j] == MoveOnly(3));
for (++j; j < 101; ++j)
assert(v[j] == MoveOnly());
}
#if _LIBCPP_DEBUG >= 1
{
std::vector<int> v1(3);
std::vector<int> v2(3);
v1.insert(v2.begin(), 4);
assert(false);
}
#endif
#if __cplusplus >= 201103L
{
std::vector<MoveOnly, min_allocator<MoveOnly>> v(100);
std::vector<MoveOnly, min_allocator<MoveOnly>>::iterator i = v.insert(v.cbegin() + 10, MoveOnly(3));
assert(v.size() == 101);
assert(i == v.begin() + 10);
int j;
for (j = 0; j < 10; ++j)
assert(v[j] == MoveOnly());
assert(v[j] == MoveOnly(3));
for (++j; j < 101; ++j)
assert(v[j] == MoveOnly());
}
#if _LIBCPP_DEBUG >= 1
{
std::vector<int, min_allocator<int>> v1(3);
std::vector<int, min_allocator<int>> v2(3);
v1.insert(v2.begin(), 4);
assert(false);
}
#endif
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}
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));
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}
void
test(C& c1, int x)
{
typedef typename C::iterator I;
std::size_t c1_osize = c1.size();
c1.push_front(MoveOnly(x));
assert(c1.size() == c1_osize + 1);
assert(static_cast<std::size_t>(distance(c1.begin(), c1.end())) == c1.size());
I i = c1.begin();
assert(*i == MoveOnly(x));
++i;
for (int j = 0; static_cast<std::size_t>(j) < c1_osize; ++j, ++i)
assert(*i == MoveOnly(j));
}
int main()
{
test_throwing_new_during_thread_creation();
{
std::thread t(f);
t.join();
assert(f_run == true);
}
{
assert(G::n_alive == 0);
assert(!G::op_run);
std::thread t((G()));
t.join();
assert(G::n_alive == 0);
assert(G::op_run);
}
G::op_run = false;
{
try
{
throw_one = 0;
assert(G::n_alive == 0);
assert(!G::op_run);
std::thread t((G()));
assert(false);
}
catch (...)
{
throw_one = 0xFFFF;
assert(G::n_alive == 0);
assert(!G::op_run);
}
}
#if TEST_STD_VER >= 11
{
assert(G::n_alive == 0);
assert(!G::op_run);
std::thread t(G(), 5, 5.5);
t.join();
assert(G::n_alive == 0);
assert(G::op_run);
}
{
std::thread t = std::thread(MoveOnly(), MoveOnly());
t.join();
}
#endif
}
void
test(std::deque<MoveOnly>& c1, int x)
{
typedef std::deque<MoveOnly> C;
typedef C::iterator I;
std::size_t c1_osize = c1.size();
c1.push_front(MoveOnly(x));
assert(c1.size() == c1_osize + 1);
assert(distance(c1.begin(), c1.end()) == c1.size());
I i = c1.begin();
assert(*i == MoveOnly(x));
++i;
for (int j = 0; j < c1_osize; ++j, ++i)
assert(*i == MoveOnly(j));
}
int main()
{
std::priority_queue<MoveOnly> qo(std::less<MoveOnly>(), make<std::vector<MoveOnly> >(5));
std::priority_queue<MoveOnly> q = std::move(qo);
assert(q.size() == 5);
assert(q.top() == MoveOnly(4));
}
TEST(WTF_Deque, MoveOnly)
{
Deque<MoveOnly> deque;
deque.append(MoveOnly(1));
deque.prepend(MoveOnly(0));
EXPECT_EQ(0U, deque.first().value());
EXPECT_EQ(1U, deque.last().value());
auto first = deque.takeFirst();
EXPECT_EQ(0U, first.value());
auto last = deque.takeLast();
EXPECT_EQ(1U, last.value());
}
int main(int, char**)
{
{
using E = MoveOnly;
using Tup = std::tuple<E, E, E>;
static_assert(test_convertible<Tup, E, E, E>(), "");
Tup t = {E(0), E(1)};
static_assert(test_convertible<Tup, E, E>(), "");
assert(std::get<0>(t) == 0);
assert(std::get<1>(t) == 1);
assert(std::get<2>(t) == MoveOnly());
Tup t2 = {E(0)};
static_assert(test_convertible<Tup, E>(), "");
assert(std::get<0>(t) == 0);
assert(std::get<1>(t) == E());
assert(std::get<2>(t) == E());
}
// Check that SFINAE is properly applied with the default reduced arity
// constructor extensions.
test_default_constructible_extension_sfinae();
test_example_from_docs();
return 0;
}
C
make(int n)
{
C c;
for (int i = 0; i < n; ++i)
c.push_back(MoveOnly(i));
return c;
}
int main()
{
do_insert_rv_test<std::map<int, MoveOnly>, std::pair<int, MoveOnly>>();
do_insert_rv_test<std::map<int, MoveOnly>, std::pair<const int, MoveOnly>>();
{
typedef std::map<int, MoveOnly, std::less<int>, min_allocator<std::pair<const int, MoveOnly>>> M;
typedef std::pair<int, MoveOnly> P;
typedef std::pair<const int, MoveOnly> CP;
do_insert_rv_test<M, P>();
do_insert_rv_test<M, CP>();
}
{
typedef std::map<int, MoveOnly> M;
typedef std::pair<M::iterator, bool> R;
M m;
R r = m.insert({2, MoveOnly(2)});
assert(r.second);
assert(r.first == m.begin());
assert(m.size() == 1);
assert(r.first->first == 2);
assert(r.first->second == 2);
r = m.insert({1, MoveOnly(1)});
assert(r.second);
assert(r.first == m.begin());
assert(m.size() == 2);
assert(r.first->first == 1);
assert(r.first->second == 1);
r = m.insert({3, MoveOnly(3)});
assert(r.second);
assert(r.first == prev(m.end()));
assert(m.size() == 3);
assert(r.first->first == 3);
assert(r.first->second == 3);
r = m.insert({3, MoveOnly(3)});
assert(!r.second);
assert(r.first == prev(m.end()));
assert(m.size() == 3);
assert(r.first->first == 3);
assert(r.first->second == 3);
}
}
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_DEBUG2 >= 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_DEBUG2 >= 1
{
std::list<int, min_allocator<int>> v1(3);
std::list<int, min_allocator<int>> v2(3);
v1.insert(v2.begin(), 4);
assert(false);
}
#endif
#endif
}
int main(int, char**)
{
do_insert_iter_rv_test<std::map<int, MoveOnly>, std::pair<int, MoveOnly>>();
do_insert_iter_rv_test<std::map<int, MoveOnly>, std::pair<const int, MoveOnly>>();
{
typedef std::map<int, MoveOnly, std::less<int>, min_allocator<std::pair<const int, MoveOnly>>> M;
typedef std::pair<int, MoveOnly> P;
typedef std::pair<const int, MoveOnly> CP;
do_insert_iter_rv_test<M, P>();
do_insert_iter_rv_test<M, CP>();
}
{
typedef std::map<int, MoveOnly> M;
typedef M::iterator R;
M m;
R r = m.insert(m.end(), {2, MoveOnly(2)});
assert(r == m.begin());
assert(m.size() == 1);
assert(r->first == 2);
assert(r->second == 2);
r = m.insert(m.end(), {1, MoveOnly(1)});
assert(r == m.begin());
assert(m.size() == 2);
assert(r->first == 1);
assert(r->second == 1);
r = m.insert(m.end(), {3, MoveOnly(3)});
assert(r == prev(m.end()));
assert(m.size() == 3);
assert(r->first == 3);
assert(r->second == 3);
r = m.insert(m.end(), {3, MoveOnly(3)});
assert(r == prev(m.end()));
assert(m.size() == 3);
assert(r->first == 3);
assert(r->second == 3);
}
return 0;
}
// compile-time test
void test_move_only_getters()
{
MoveOnly m1 = *makeMoveOnly();
MoveOnly m2 = makeMoveOnly().value();
MoveOnly m3 = makeMoveOnly().value_or(MoveOnly(1));
MoveOnly m4 = makeMoveOnly().value_or_eval(moveOnlyDefault);
boost::ignore_unused(m1);
boost::ignore_unused(m2);
boost::ignore_unused(m3);
boost::ignore_unused(m4);
}
void test(int size)
{
int rng[] = {0, 1, 2, 3, 1023, 1024, 1025, 2046, 2047, 2048, 2049};
const int N = sizeof(rng)/sizeof(rng[0]);
for (int j = 0; j < N; ++j)
{
C c = make<C>(size, rng[j]);
typename C::const_iterator it = c.begin();
for (int i = 0; i < size; ++i, ++it)
assert(*it == MoveOnly(i));
}
}
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
std::queue<MoveOnly> q;
q.push(MoveOnly(1));
assert(q.size() == 1);
assert(q.front() == MoveOnly(1));
assert(q.back() == MoveOnly(1));
q.push(MoveOnly(2));
assert(q.size() == 2);
assert(q.front() == MoveOnly(1));
assert(q.back() == MoveOnly(2));
q.push(MoveOnly(3));
assert(q.size() == 3);
assert(q.front() == MoveOnly(1));
assert(q.back() == MoveOnly(3));
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}
TEST(WTF_Deque, MoveAssignmentOperator)
{
Deque<MoveOnly, 4> deque1;
for (unsigned i = 0; i < 10; ++i)
deque1.append(MoveOnly(i));
EXPECT_EQ(10u, deque1.size());
Deque<MoveOnly, 4> deque2;
for (unsigned i = 0; i < 10; ++i)
deque2.append(MoveOnly(i * 2));
deque1 = WTF::move(deque2);
EXPECT_EQ(10u, deque2.size());
unsigned i = 0;
for (auto& element : deque1) {
EXPECT_EQ(i * 2, element.value());
++i;
}
}
int main()
{
{
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));
}
{
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));
}
}
int main()
{
{
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));
}
{
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));
}
}
void
test_move()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
std::deque<MoveOnly, stack_allocator<MoveOnly, 2000> > c;
typedef std::deque<MoveOnly>::const_iterator CI;
{
MoveOnly mo(0);
typedef MoveOnly* I;
c.insert(c.end(), std::move_iterator<I>(&mo), std::move_iterator<I>(&mo+1));
}
int j = 0;
for (CI i = c.begin(); i != c.end(); ++i, ++j)
assert(*i == MoveOnly(j));
{
MoveOnly mo(1);
typedef input_iterator<MoveOnly*> I;
c.insert(c.end(), std::move_iterator<I>(I(&mo)), std::move_iterator<I>(I(&mo+1)));
}
j = 0;
for (CI i = c.begin(); i != c.end(); ++i, ++j)
assert(*i == MoveOnly(j));
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}
TEST(WTF_HashSet, MoveOnly)
{
HashSet<MoveOnly> hashSet;
for (size_t i = 0; i < 100; ++i) {
MoveOnly moveOnly(i + 1);
hashSet.add(std::move(moveOnly));
}
for (size_t i = 0; i < 100; ++i)
EXPECT_TRUE(hashSet.contains(MoveOnly(i + 1)));
for (size_t i = 0; i < 100; ++i)
EXPECT_TRUE(hashSet.remove(MoveOnly(i + 1)));
EXPECT_TRUE(hashSet.isEmpty());
for (size_t i = 0; i < 100; ++i)
hashSet.add(std::move(MoveOnly(i + 1)));
for (size_t i = 0; i < 100; ++i)
EXPECT_TRUE(hashSet.take(MoveOnly(i + 1)) == MoveOnly(i + 1));
}
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
int* an = ab + sizeof(ab)/sizeof(ab[0]);
typedef test_allocator<MoveOnly> A;
std::deque<MoveOnly, A> c1(A(5));
for (int* p = ab; p < an; ++p)
c1.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c2(A(5));
for (int* p = ab; p < an; ++p)
c2.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c3(A(5));
c3 = std::move(c1);
assert(c2 == c3);
assert(c1.size() == 0);
assert(c3.get_allocator() == A(5));
}
{
int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
int* an = ab + sizeof(ab)/sizeof(ab[0]);
typedef test_allocator<MoveOnly> A;
std::deque<MoveOnly, A> c1(A(5));
for (int* p = ab; p < an; ++p)
c1.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c2(A(5));
for (int* p = ab; p < an; ++p)
c2.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c3(A(6));
c3 = std::move(c1);
assert(c2 == c3);
assert(c1.size() != 0);
assert(c3.get_allocator() == A(6));
}
{
int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
int* an = ab + sizeof(ab)/sizeof(ab[0]);
typedef other_allocator<MoveOnly> A;
std::deque<MoveOnly, A> c1(A(5));
for (int* p = ab; p < an; ++p)
c1.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c2(A(5));
for (int* p = ab; p < an; ++p)
c2.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c3(A(6));
c3 = std::move(c1);
assert(c2 == c3);
assert(c1.size() == 0);
assert(c3.get_allocator() == A(5));
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}
int main()
{
{
std::tuple<MoveOnly> t(std::allocator_arg, A1<int>(), MoveOnly(0));
assert(std::get<0>(t) == 0);
}
{
std::tuple<MoveOnly, MoveOnly> t(std::allocator_arg, A1<int>(),
MoveOnly(0), MoveOnly(1));
assert(std::get<0>(t) == 0);
assert(std::get<1>(t) == 1);
}
{
std::tuple<MoveOnly, MoveOnly, MoveOnly> t(std::allocator_arg, A1<int>(),
MoveOnly(0),
1, 2);
assert(std::get<0>(t) == 0);
assert(std::get<1>(t) == 1);
assert(std::get<2>(t) == 2);
}
{
alloc_first::allocator_constructed = false;
alloc_last::allocator_constructed = false;
std::tuple<int, alloc_first, alloc_last> t(std::allocator_arg,
A1<int>(5), 1, 2, 3);
assert(std::get<0>(t) == 1);
assert(alloc_first::allocator_constructed);
assert(std::get<1>(t) == alloc_first(2));
assert(alloc_last::allocator_constructed);
assert(std::get<2>(t) == alloc_last(3));
}
// extensions
{
std::tuple<MoveOnly, MoveOnly, MoveOnly> t(std::allocator_arg, A1<int>(),
0, 1);
assert(std::get<0>(t) == 0);
assert(std::get<1>(t) == 1);
assert(std::get<2>(t) == MoveOnly());
}
{
std::tuple<MoveOnly, MoveOnly, MoveOnly> t(std::allocator_arg, A1<int>(),
0);
assert(std::get<0>(t) == 0);
assert(std::get<1>(t) == MoveOnly());
assert(std::get<2>(t) == MoveOnly());
}
}
TEST(WTF_Deque, MoveConstructor)
{
Deque<MoveOnly, 4> deque;
for (unsigned i = 0; i < 10; ++i)
deque.append(MoveOnly(i));
EXPECT_EQ(10u, deque.size());
Deque<MoveOnly, 4> deque2 = WTF::move(deque);
EXPECT_EQ(10u, deque2.size());
unsigned i = 0;
for (auto& element : deque2) {
EXPECT_EQ(i, element.value());
++i;
}
}
std::deque<MoveOnly>
make(int size, int start = 0 )
{
const int b = 4096 / sizeof(int);
int init = 0;
if (start > 0)
{
init = (start+1) / b + ((start+1) % b != 0);
init *= b;
--init;
}
std::deque<MoveOnly> c(init);
for (int i = 0; i < init-start; ++i)
c.pop_back();
for (int i = 0; i < size; ++i)
c.push_back(MoveOnly(i));
for (int i = 0; i < start; ++i)
c.pop_front();
return c;
};
int main() {
{
using T = hana::tuple<>;
T t0;
T t = std::move(t0); (void)t;
}
{
using T = hana::tuple<MoveOnly>;
T t0(MoveOnly(0));
T t = std::move(t0); (void)t;
BOOST_HANA_RUNTIME_CHECK(hana::at_c<0>(t) == 0);
}
{
using T = hana::tuple<MoveOnly, MoveOnly>;
T t0(MoveOnly(0), MoveOnly(1));
T t = std::move(t0); (void)t;
BOOST_HANA_RUNTIME_CHECK(hana::at_c<0>(t) == 0);
BOOST_HANA_RUNTIME_CHECK(hana::at_c<1>(t) == 1);
}
{
using T = hana::tuple<MoveOnly, MoveOnly, MoveOnly>;
T t0(MoveOnly(0), MoveOnly(1), MoveOnly(2));
T t = std::move(t0); (void)t;
BOOST_HANA_RUNTIME_CHECK(hana::at_c<0>(t) == 0);
BOOST_HANA_RUNTIME_CHECK(hana::at_c<1>(t) == 1);
BOOST_HANA_RUNTIME_CHECK(hana::at_c<2>(t) == 2);
}
{
// Check for SFINAE-friendliness
static_assert(!std::is_constructible<
hana::tuple<MoveOnly>, MoveOnly const&
>{}, "");
static_assert(!std::is_constructible<
hana::tuple<MoveOnly>, MoveOnly&
>{}, "");
static_assert(std::is_constructible<
hana::tuple<MoveOnly>, MoveOnly
>{}, "");
static_assert(std::is_constructible<
hana::tuple<MoveOnly>, MoveOnly&&
>{}, "");
}
}
int main()
{
{
typedef std::tuple<> T;
T t0;
T t = std::move(t0);
((void)t); // Prevent unused warning
}
{
typedef std::tuple<MoveOnly> T;
T t0(MoveOnly(0));
T t = std::move(t0);
assert(std::get<0>(t) == 0);
}
{
typedef std::tuple<MoveOnly, MoveOnly> T;
T t0(MoveOnly(0), MoveOnly(1));
T t = std::move(t0);
assert(std::get<0>(t) == 0);
assert(std::get<1>(t) == 1);
}
{
typedef std::tuple<MoveOnly, MoveOnly, MoveOnly> T;
T t0(MoveOnly(0), MoveOnly(1), MoveOnly(2));
T t = std::move(t0);
assert(std::get<0>(t) == 0);
assert(std::get<1>(t) == 1);
assert(std::get<2>(t) == 2);
}
// A bug in tuple caused __tuple_leaf to use its explicit converting constructor
// as its move constructor. This tests that ConstructsWithTupleLeaf is not called
// (w/ __tuple_leaf)
{
typedef std::tuple<ConstructsWithTupleLeaf> d_t;
d_t d((ConstructsWithTupleLeaf()));
d_t d2(static_cast<d_t &&>(d));
}
}
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
int* an = ab + sizeof(ab)/sizeof(ab[0]);
typedef test_allocator<MoveOnly> A;
std::deque<MoveOnly, A> c1(A(1));
for (int* p = ab; p < an; ++p)
c1.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c2(A(1));
for (int* p = ab; p < an; ++p)
c2.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c3(std::move(c1), A(3));
assert(c2 == c3);
assert(c3.get_allocator() == A(3));
assert(c1.size() != 0);
}
{
int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
int* an = ab + sizeof(ab)/sizeof(ab[0]);
typedef test_allocator<MoveOnly> A;
std::deque<MoveOnly, A> c1(A(1));
for (int* p = ab; p < an; ++p)
c1.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c2(A(1));
for (int* p = ab; p < an; ++p)
c2.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c3(std::move(c1), A(1));
assert(c2 == c3);
assert(c3.get_allocator() == A(1));
assert(c1.size() == 0);
}
{
int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
int* an = ab + sizeof(ab)/sizeof(ab[0]);
typedef other_allocator<MoveOnly> A;
std::deque<MoveOnly, A> c1(A(1));
for (int* p = ab; p < an; ++p)
c1.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c2(A(1));
for (int* p = ab; p < an; ++p)
c2.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c3(std::move(c1), A(3));
assert(c2 == c3);
assert(c3.get_allocator() == A(3));
assert(c1.size() != 0);
}
#if __cplusplus >= 201103L || defined(_LIBCPP_MSVC)
{
int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
int* an = ab + sizeof(ab)/sizeof(ab[0]);
typedef min_allocator<MoveOnly> A;
std::deque<MoveOnly, A> c1(A{});
for (int* p = ab; p < an; ++p)
c1.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c2(A{});
for (int* p = ab; p < an; ++p)
c2.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c3(std::move(c1), A());
assert(c2 == c3);
assert(c3.get_allocator() == A());
assert(c1.size() == 0);
}
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}
int main() {
{
hana::tuple<MoveOnly> t(MoveOnly(0));
BOOST_HANA_RUNTIME_CHECK(hana::at_c<0>(t) == 0);
}
{
hana::tuple<MoveOnly, MoveOnly> t(MoveOnly(0), MoveOnly(1));
BOOST_HANA_RUNTIME_CHECK(hana::at_c<0>(t) == 0);
BOOST_HANA_RUNTIME_CHECK(hana::at_c<1>(t) == 1);
}
{
hana::tuple<MoveOnly, MoveOnly, MoveOnly> t(
MoveOnly(0), MoveOnly(1), MoveOnly(2)
);
BOOST_HANA_RUNTIME_CHECK(hana::at_c<0>(t) == 0);
BOOST_HANA_RUNTIME_CHECK(hana::at_c<1>(t) == 1);
BOOST_HANA_RUNTIME_CHECK(hana::at_c<2>(t) == 2);
}
{
constexpr hana::tuple<Empty> t0{Empty()}; (void)t0;
}
{
constexpr hana::tuple<A, A> t(3, 2);
static_assert(hana::at_c<0>(t).id_ == 3, "");
}
{
typedef hana::tuple<MoveOnly, NoDefault> Tuple;
static_assert(!std::is_constructible<
Tuple,
MoveOnly
>::value, "");
static_assert(std::is_constructible<
Tuple,
MoveOnly, NoDefault
>::value, "");
}
{
typedef hana::tuple<MoveOnly, MoveOnly, NoDefault> Tuple;
static_assert(!std::is_constructible<
Tuple,
MoveOnly, MoveOnly
>::value, "");
static_assert(std::is_constructible<
Tuple,
MoveOnly, MoveOnly, NoDefault
>::value, "");
}
{
typedef hana::tuple<MoveOnly, NoDefault> Tuple;
typedef hana::tuple<MoveOnly, Tuple, MoveOnly, MoveOnly> NestedTuple;
static_assert(!std::is_constructible<
NestedTuple,
MoveOnly, MoveOnly, MoveOnly, MoveOnly
>::value, "");
static_assert(std::is_constructible<
NestedTuple,
MoveOnly, Tuple, MoveOnly, MoveOnly
>::value, "");
}
{
typedef hana::tuple<MoveOnly, int> Tuple;
typedef hana::tuple<MoveOnly, Tuple, MoveOnly, MoveOnly> NestedTuple;
static_assert(!std::is_constructible<
NestedTuple,
MoveOnly, MoveOnly, MoveOnly, MoveOnly
>::value, "");
static_assert(std::is_constructible<
NestedTuple,
MoveOnly, Tuple, MoveOnly, MoveOnly
>::value, "");
}
}
int main()
{
{
std::tuple<MoveOnly> t(MoveOnly(0));
assert(std::get<0>(t) == 0);
}
{
std::tuple<MoveOnly, MoveOnly> t(MoveOnly(0), MoveOnly(1));
assert(std::get<0>(t) == 0);
assert(std::get<1>(t) == 1);
}
{
std::tuple<MoveOnly, MoveOnly, MoveOnly> t(MoveOnly(0),
MoveOnly(1),
MoveOnly(2));
assert(std::get<0>(t) == 0);
assert(std::get<1>(t) == 1);
assert(std::get<2>(t) == 2);
}
// extensions
{
std::tuple<MoveOnly, MoveOnly, MoveOnly> t(MoveOnly(0),
MoveOnly(1));
assert(std::get<0>(t) == 0);
assert(std::get<1>(t) == 1);
assert(std::get<2>(t) == MoveOnly());
}
{
std::tuple<MoveOnly, MoveOnly, MoveOnly> t(MoveOnly(0));
assert(std::get<0>(t) == 0);
assert(std::get<1>(t) == MoveOnly());
assert(std::get<2>(t) == MoveOnly());
}
#if _LIBCPP_STD_VER > 11
{
constexpr std::tuple<Empty> t0{Empty()};
}
{
constexpr std::tuple<A, A> t(3, 2);
static_assert(std::get<0>(t).id_ == 3, "");
}
#endif
// Check that SFINAE is properly applied with the default reduced arity
// constructor extensions.
test_default_constructible_extension_sfinae();
}
int main()
{
{
int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
int* an = ab + sizeof(ab)/sizeof(ab[0]);
typedef test_allocator<MoveOnly> A;
std::deque<MoveOnly, A> c1(A(5));
for (int* p = ab; p < an; ++p)
c1.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c2(A(5));
for (int* p = ab; p < an; ++p)
c2.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c3(A(5));
c3 = std::move(c1);
assert(c2 == c3);
assert(c1.size() == 0);
assert(c3.get_allocator() == A(5));
}
{
int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
int* an = ab + sizeof(ab)/sizeof(ab[0]);
typedef test_allocator<MoveOnly> A;
std::deque<MoveOnly, A> c1(A(5));
for (int* p = ab; p < an; ++p)
c1.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c2(A(5));
for (int* p = ab; p < an; ++p)
c2.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c3(A(6));
c3 = std::move(c1);
assert(c2 == c3);
assert(c1.size() != 0);
assert(c3.get_allocator() == A(6));
}
{
int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
int* an = ab + sizeof(ab)/sizeof(ab[0]);
typedef other_allocator<MoveOnly> A;
std::deque<MoveOnly, A> c1(A(5));
for (int* p = ab; p < an; ++p)
c1.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c2(A(5));
for (int* p = ab; p < an; ++p)
c2.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c3(A(6));
c3 = std::move(c1);
assert(c2 == c3);
assert(c1.size() == 0);
assert(c3.get_allocator() == A(5));
}
{
int ab[] = {3, 4, 2, 8, 0, 1, 44, 34, 45, 96, 80, 1, 13, 31, 45};
int* an = ab + sizeof(ab)/sizeof(ab[0]);
typedef min_allocator<MoveOnly> A;
std::deque<MoveOnly, A> c1(A{});
for (int* p = ab; p < an; ++p)
c1.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c2(A{});
for (int* p = ab; p < an; ++p)
c2.push_back(MoveOnly(*p));
std::deque<MoveOnly, A> c3(A{});
c3 = std::move(c1);
assert(c2 == c3);
assert(c1.size() == 0);
assert(c3.get_allocator() == A());
}
}
