int main() { #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES { typedef std::multiset<DefaultOnly> M; typedef M::iterator R; M m; assert(DefaultOnly::count == 0); R r = m.emplace_hint(m.cend()); assert(r == m.begin()); assert(m.size() == 1); assert(*m.begin() == DefaultOnly()); assert(DefaultOnly::count == 1); r = m.emplace_hint(m.cbegin()); assert(r == m.begin()); assert(m.size() == 2); assert(*m.begin() == DefaultOnly()); assert(DefaultOnly::count == 2); } assert(DefaultOnly::count == 0); { typedef std::multiset<Emplaceable> M; typedef M::iterator R; M m; R r = m.emplace_hint(m.cend()); assert(r == m.begin()); assert(m.size() == 1); assert(*m.begin() == Emplaceable()); r = m.emplace_hint(m.cend(), 2, 3.5); assert(r == next(m.begin())); assert(m.size() == 2); assert(*r == Emplaceable(2, 3.5)); r = m.emplace_hint(m.cbegin(), 2, 3.5); assert(r == next(m.begin())); assert(m.size() == 3); assert(*r == Emplaceable(2, 3.5)); } { typedef std::multiset<int> M; typedef M::iterator R; M m; R r = m.emplace_hint(m.cend(), M::value_type(2)); assert(r == m.begin()); assert(m.size() == 1); assert(*r == 2); } #if __cplusplus >= 201103L { typedef std::multiset<int, std::less<int>, min_allocator<int>> M; typedef M::iterator R; M m; R r = m.emplace_hint(m.cend(), M::value_type(2)); assert(r == m.begin()); assert(m.size() == 1); assert(*r == 2); } #endif #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES }
int main(int, char**) { { typedef std::set<DefaultOnly> M; typedef M::iterator R; M m; assert(DefaultOnly::count == 0); R r = m.emplace_hint(m.cend()); assert(r == m.begin()); assert(m.size() == 1); assert(*m.begin() == DefaultOnly()); assert(DefaultOnly::count == 1); r = m.emplace_hint(m.cbegin()); assert(r == m.begin()); assert(m.size() == 1); assert(*m.begin() == DefaultOnly()); assert(DefaultOnly::count == 1); } assert(DefaultOnly::count == 0); { typedef std::set<Emplaceable> M; typedef M::iterator R; M m; R r = m.emplace_hint(m.cend()); assert(r == m.begin()); assert(m.size() == 1); assert(*m.begin() == Emplaceable()); r = m.emplace_hint(m.cend(), 2, 3.5); assert(r == next(m.begin())); assert(m.size() == 2); assert(*r == Emplaceable(2, 3.5)); r = m.emplace_hint(m.cbegin(), 2, 3.5); assert(r == next(m.begin())); assert(m.size() == 2); assert(*r == Emplaceable(2, 3.5)); } { typedef std::set<int> M; typedef M::iterator R; M m; R r = m.emplace_hint(m.cend(), M::value_type(2)); assert(r == m.begin()); assert(m.size() == 1); assert(*r == 2); } { typedef std::set<int, std::less<int>, min_allocator<int>> M; typedef M::iterator R; M m; R r = m.emplace_hint(m.cend(), M::value_type(2)); assert(r == m.begin()); assert(m.size() == 1); assert(*r == 2); } return 0; }
int main() { { std::tuple<> t(std::allocator_arg, A1<int>()); } { std::tuple<int> t(std::allocator_arg, A1<int>()); assert(std::get<0>(t) == 0); } { std::tuple<DefaultOnly> t(std::allocator_arg, A1<int>()); assert(std::get<0>(t) == DefaultOnly()); } { assert(!alloc_first::allocator_constructed); std::tuple<alloc_first> t(std::allocator_arg, A1<int>(5)); assert(alloc_first::allocator_constructed); assert(std::get<0>(t) == alloc_first()); } { assert(!alloc_last::allocator_constructed); std::tuple<alloc_last> t(std::allocator_arg, A1<int>(5)); assert(alloc_last::allocator_constructed); assert(std::get<0>(t) == alloc_last()); } { alloc_first::allocator_constructed = false; std::tuple<DefaultOnly, alloc_first> t(std::allocator_arg, A1<int>(5)); assert(std::get<0>(t) == DefaultOnly()); assert(alloc_first::allocator_constructed); assert(std::get<1>(t) == alloc_first()); } { alloc_first::allocator_constructed = false; alloc_last::allocator_constructed = false; std::tuple<DefaultOnly, alloc_first, alloc_last> t(std::allocator_arg, A1<int>(5)); assert(std::get<0>(t) == DefaultOnly()); assert(alloc_first::allocator_constructed); assert(std::get<1>(t) == alloc_first()); assert(alloc_last::allocator_constructed); assert(std::get<2>(t) == alloc_last()); } { alloc_first::allocator_constructed = false; alloc_last::allocator_constructed = false; std::tuple<DefaultOnly, alloc_first, alloc_last> t(std::allocator_arg, A2<int>(5)); assert(std::get<0>(t) == DefaultOnly()); assert(!alloc_first::allocator_constructed); assert(std::get<1>(t) == alloc_first()); assert(!alloc_last::allocator_constructed); assert(std::get<2>(t) == alloc_last()); } }
int main() { #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES { typedef std::set<DefaultOnly> M; typedef std::pair<M::iterator, bool> R; M m; assert(DefaultOnly::count == 0); R r = m.emplace(); assert(r.second); assert(r.first == m.begin()); assert(m.size() == 1); assert(*m.begin() == DefaultOnly()); assert(DefaultOnly::count == 1); r = m.emplace(); assert(!r.second); assert(r.first == m.begin()); assert(m.size() == 1); assert(*m.begin() == DefaultOnly()); assert(DefaultOnly::count == 1); } assert(DefaultOnly::count == 0); { typedef std::set<Emplaceable> M; typedef std::pair<M::iterator, bool> R; M m; R r = m.emplace(); assert(r.second); assert(r.first == m.begin()); assert(m.size() == 1); assert(*m.begin() == Emplaceable()); r = m.emplace(2, 3.5); assert(r.second); assert(r.first == next(m.begin())); assert(m.size() == 2); assert(*r.first == Emplaceable(2, 3.5)); r = m.emplace(2, 3.5); assert(!r.second); assert(r.first == next(m.begin())); assert(m.size() == 2); assert(*r.first == Emplaceable(2, 3.5)); } { typedef std::set<int> M; typedef std::pair<M::iterator, bool> R; M m; R r = m.emplace(M::value_type(2)); assert(r.second); assert(r.first == m.begin()); assert(m.size() == 1); assert(*r.first == 2); } #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES }
int main() { { std::tuple<> t; } { std::tuple<int> t; assert(std::get<0>(t) == 0); } { std::tuple<int, char*> t; assert(std::get<0>(t) == 0); assert(std::get<1>(t) == nullptr); } { std::tuple<int, char*, std::string> t; assert(std::get<0>(t) == 0); assert(std::get<1>(t) == nullptr); assert(std::get<2>(t) == ""); } { std::tuple<int, char*, std::string, DefaultOnly> t; assert(std::get<0>(t) == 0); assert(std::get<1>(t) == nullptr); assert(std::get<2>(t) == ""); assert(std::get<3>(t) == DefaultOnly()); } }
int main() { { std::tuple<> t; } { std::tuple<int> t; assert(std::get<0>(t) == 0); } { std::tuple<int, char*> t; assert(std::get<0>(t) == 0); assert(std::get<1>(t) == nullptr); } { std::tuple<int, char*, std::string> t; assert(std::get<0>(t) == 0); assert(std::get<1>(t) == nullptr); assert(std::get<2>(t) == ""); } { std::tuple<int, char*, std::string, DefaultOnly> t; assert(std::get<0>(t) == 0); assert(std::get<1>(t) == nullptr); assert(std::get<2>(t) == ""); assert(std::get<3>(t) == DefaultOnly()); } #ifndef _LIBCPP_HAS_NO_CONSTEXPR { constexpr std::tuple<> t; } { constexpr std::tuple<int> t; assert(std::get<0>(t) == 0); } { constexpr std::tuple<int, char*> t; assert(std::get<0>(t) == 0); assert(std::get<1>(t) == nullptr); } #endif }
int main(int, char**) { { std::tuple<> t; (void)t; } { std::tuple<int> t; assert(std::get<0>(t) == 0); } { std::tuple<int, char*> t; assert(std::get<0>(t) == 0); assert(std::get<1>(t) == nullptr); } { std::tuple<int, char*, std::string> t; assert(std::get<0>(t) == 0); assert(std::get<1>(t) == nullptr); assert(std::get<2>(t) == ""); } { std::tuple<int, char*, std::string, DefaultOnly> t; assert(std::get<0>(t) == 0); assert(std::get<1>(t) == nullptr); assert(std::get<2>(t) == ""); assert(std::get<3>(t) == DefaultOnly()); } { // See bug #21157. static_assert(!std::is_default_constructible<std::tuple<NoDefault>>(), ""); static_assert(!std::is_default_constructible<std::tuple<DefaultOnly, NoDefault>>(), ""); static_assert(!std::is_default_constructible<std::tuple<NoDefault, DefaultOnly, NoDefault>>(), ""); } { static_assert(noexcept(std::tuple<NoExceptDefault>()), ""); static_assert(noexcept(std::tuple<NoExceptDefault, NoExceptDefault>()), ""); static_assert(!noexcept(std::tuple<ThrowingDefault, NoExceptDefault>()), ""); static_assert(!noexcept(std::tuple<NoExceptDefault, ThrowingDefault>()), ""); static_assert(!noexcept(std::tuple<ThrowingDefault, ThrowingDefault>()), ""); } { constexpr std::tuple<> t; (void)t; } { constexpr std::tuple<int> t; assert(std::get<0>(t) == 0); } { constexpr std::tuple<int, char*> t; assert(std::get<0>(t) == 0); assert(std::get<1>(t) == nullptr); } { // Check that the SFINAE on the default constructor is not evaluated when // it isn't needed. If the default constructor is evaluated then this test // should fail to compile. IllFormedDefault v(0); std::tuple<IllFormedDefault> t(v); } return 0; }
int main() { #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES { typedef std::multimap<int, DefaultOnly> M; typedef M::iterator R; M m; assert(DefaultOnly::count == 0); R r = m.emplace(); assert(r == m.begin()); assert(m.size() == 1); assert(m.begin()->first == 0); assert(m.begin()->second == DefaultOnly()); assert(DefaultOnly::count == 1); r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple()); assert(r == next(m.begin())); assert(m.size() == 2); assert(next(m.begin())->first == 1); assert(next(m.begin())->second == DefaultOnly()); assert(DefaultOnly::count == 2); r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple()); assert(r == next(m.begin(), 2)); assert(m.size() == 3); assert(next(m.begin(), 2)->first == 1); assert(next(m.begin(), 2)->second == DefaultOnly()); assert(DefaultOnly::count == 3); } assert(DefaultOnly::count == 0); { typedef std::multimap<int, Emplaceable> M; typedef M::iterator R; M m; R r = m.emplace(std::piecewise_construct, std::forward_as_tuple(2), std::forward_as_tuple()); assert(r == m.begin()); assert(m.size() == 1); assert(m.begin()->first == 2); assert(m.begin()->second == Emplaceable()); r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5)); assert(r == m.begin()); assert(m.size() == 2); assert(m.begin()->first == 1); assert(m.begin()->second == Emplaceable(2, 3.5)); r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(3, 3.5)); assert(r == next(m.begin())); assert(m.size() == 3); assert(r->first == 1); assert(r->second == Emplaceable(3, 3.5)); } { typedef std::multimap<int, double> M; typedef M::iterator R; M m; R r = m.emplace(M::value_type(2, 3.5)); assert(r == m.begin()); assert(m.size() == 1); assert(m.begin()->first == 2); assert(m.begin()->second == 3.5); } #if __cplusplus >= 201103L || defined(_LIBCPP_MSVC) { typedef std::multimap<int, DefaultOnly, std::less<int>, min_allocator<std::pair<const int, DefaultOnly>>> M; typedef M::iterator R; M m; assert(DefaultOnly::count == 0); R r = m.emplace(); assert(r == m.begin()); assert(m.size() == 1); assert(m.begin()->first == 0); assert(m.begin()->second == DefaultOnly()); assert(DefaultOnly::count == 1); r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple()); assert(r == next(m.begin())); assert(m.size() == 2); assert(next(m.begin())->first == 1); assert(next(m.begin())->second == DefaultOnly()); assert(DefaultOnly::count == 2); r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple()); assert(r == next(m.begin(), 2)); assert(m.size() == 3); assert(next(m.begin(), 2)->first == 1); assert(next(m.begin(), 2)->second == DefaultOnly()); assert(DefaultOnly::count == 3); } assert(DefaultOnly::count == 0); { typedef std::multimap<int, Emplaceable, std::less<int>, min_allocator<std::pair<const int, Emplaceable>>> M; typedef M::iterator R; M m; R r = m.emplace(std::piecewise_construct, std::forward_as_tuple(2), std::forward_as_tuple()); assert(r == m.begin()); assert(m.size() == 1); assert(m.begin()->first == 2); assert(m.begin()->second == Emplaceable()); r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5)); assert(r == m.begin()); assert(m.size() == 2); assert(m.begin()->first == 1); assert(m.begin()->second == Emplaceable(2, 3.5)); r = m.emplace(std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(3, 3.5)); assert(r == next(m.begin())); assert(m.size() == 3); assert(r->first == 1); assert(r->second == Emplaceable(3, 3.5)); } { typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M; typedef M::iterator R; M m; R r = m.emplace(M::value_type(2, 3.5)); assert(r == m.begin()); assert(m.size() == 1); assert(m.begin()->first == 2); assert(m.begin()->second == 3.5); } #endif #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES }
int main() { { typedef std::multimap<int, DefaultOnly> M; typedef M::iterator R; M m; assert(DefaultOnly::count == 0); R r = m.emplace_hint(m.cend()); assert(r == m.begin()); assert(m.size() == 1); assert(m.begin()->first == 0); assert(m.begin()->second == DefaultOnly()); assert(DefaultOnly::count == 1); r = m.emplace_hint(m.cend(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple()); assert(r == next(m.begin())); assert(m.size() == 2); assert(next(m.begin())->first == 1); assert(next(m.begin())->second == DefaultOnly()); assert(DefaultOnly::count == 2); r = m.emplace_hint(m.cend(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple()); assert(r == next(m.begin(), 2)); assert(m.size() == 3); assert(next(m.begin(), 2)->first == 1); assert(next(m.begin(), 2)->second == DefaultOnly()); assert(DefaultOnly::count == 3); } assert(DefaultOnly::count == 0); { typedef std::multimap<int, Emplaceable> M; typedef M::iterator R; M m; R r = m.emplace_hint(m.cend(), std::piecewise_construct, std::forward_as_tuple(2), std::forward_as_tuple()); assert(r == m.begin()); assert(m.size() == 1); assert(m.begin()->first == 2); assert(m.begin()->second == Emplaceable()); r = m.emplace_hint(m.cbegin(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5)); assert(r == m.begin()); assert(m.size() == 2); assert(m.begin()->first == 1); assert(m.begin()->second == Emplaceable(2, 3.5)); r = m.emplace_hint(m.cbegin(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(3, 3.5)); assert(r == m.begin()); assert(m.size() == 3); assert(r->first == 1); assert(r->second == Emplaceable(3, 3.5)); } { typedef std::multimap<int, double> M; typedef M::iterator R; M m; R r = m.emplace_hint(m.cend(), M::value_type(2, 3.5)); assert(r == m.begin()); assert(m.size() == 1); assert(m.begin()->first == 2); assert(m.begin()->second == 3.5); } { typedef std::multimap<int, DefaultOnly, std::less<int>, min_allocator<std::pair<const int, DefaultOnly>>> M; typedef M::iterator R; M m; assert(DefaultOnly::count == 0); R r = m.emplace_hint(m.cend()); assert(r == m.begin()); assert(m.size() == 1); assert(m.begin()->first == 0); assert(m.begin()->second == DefaultOnly()); assert(DefaultOnly::count == 1); r = m.emplace_hint(m.cend(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple()); assert(r == next(m.begin())); assert(m.size() == 2); assert(next(m.begin())->first == 1); assert(next(m.begin())->second == DefaultOnly()); assert(DefaultOnly::count == 2); r = m.emplace_hint(m.cend(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple()); assert(r == next(m.begin(), 2)); assert(m.size() == 3); assert(next(m.begin(), 2)->first == 1); assert(next(m.begin(), 2)->second == DefaultOnly()); assert(DefaultOnly::count == 3); } assert(DefaultOnly::count == 0); { typedef std::multimap<int, Emplaceable, std::less<int>, min_allocator<std::pair<const int, Emplaceable>>> M; typedef M::iterator R; M m; R r = m.emplace_hint(m.cend(), std::piecewise_construct, std::forward_as_tuple(2), std::forward_as_tuple()); assert(r == m.begin()); assert(m.size() == 1); assert(m.begin()->first == 2); assert(m.begin()->second == Emplaceable()); r = m.emplace_hint(m.cbegin(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(2, 3.5)); assert(r == m.begin()); assert(m.size() == 2); assert(m.begin()->first == 1); assert(m.begin()->second == Emplaceable(2, 3.5)); r = m.emplace_hint(m.cbegin(), std::piecewise_construct, std::forward_as_tuple(1), std::forward_as_tuple(3, 3.5)); assert(r == m.begin()); assert(m.size() == 3); assert(r->first == 1); assert(r->second == Emplaceable(3, 3.5)); } { typedef std::multimap<int, double, std::less<int>, min_allocator<std::pair<const int, double>>> M; typedef M::iterator R; M m; R r = m.emplace_hint(m.cend(), M::value_type(2, 3.5)); assert(r == m.begin()); assert(m.size() == 1); assert(m.begin()->first == 2); assert(m.begin()->second == 3.5); } }
int main() { { std::tuple<> t(std::allocator_arg, A1<int>()); } { std::tuple<int> t(std::allocator_arg, A1<int>()); assert(std::get<0>(t) == 0); } { std::tuple<DefaultOnly> t(std::allocator_arg, A1<int>()); assert(std::get<0>(t) == DefaultOnly()); } { assert(!alloc_first::allocator_constructed); std::tuple<alloc_first> t(std::allocator_arg, A1<int>(5)); assert(alloc_first::allocator_constructed); assert(std::get<0>(t) == alloc_first()); } { assert(!alloc_last::allocator_constructed); std::tuple<alloc_last> t(std::allocator_arg, A1<int>(5)); assert(alloc_last::allocator_constructed); assert(std::get<0>(t) == alloc_last()); } { alloc_first::allocator_constructed = false; std::tuple<DefaultOnly, alloc_first> t(std::allocator_arg, A1<int>(5)); assert(std::get<0>(t) == DefaultOnly()); assert(alloc_first::allocator_constructed); assert(std::get<1>(t) == alloc_first()); } { alloc_first::allocator_constructed = false; alloc_last::allocator_constructed = false; std::tuple<DefaultOnly, alloc_first, alloc_last> t(std::allocator_arg, A1<int>(5)); assert(std::get<0>(t) == DefaultOnly()); assert(alloc_first::allocator_constructed); assert(std::get<1>(t) == alloc_first()); assert(alloc_last::allocator_constructed); assert(std::get<2>(t) == alloc_last()); } { alloc_first::allocator_constructed = false; alloc_last::allocator_constructed = false; std::tuple<DefaultOnly, alloc_first, alloc_last> t(std::allocator_arg, A2<int>(5)); assert(std::get<0>(t) == DefaultOnly()); assert(!alloc_first::allocator_constructed); assert(std::get<1>(t) == alloc_first()); assert(!alloc_last::allocator_constructed); assert(std::get<2>(t) == alloc_last()); } { // Test that the uses-allocator default constructor does not evaluate // its SFINAE when it otherwise shouldn't be selected. Do this by // using 'NonDefaultConstructible' which will cause a compile error // if std::is_default_constructible is evaluated on it. using T = NonDefaultConstructible<>; T v(42); std::tuple<T, T> t(v, v); (void)t; std::tuple<T, T> t2(42, 42); (void)t2; } }
int main(int, char**) { { typedef std::set<DefaultOnly> M; typedef std::pair<M::iterator, bool> R; M m; assert(DefaultOnly::count == 0); R r = m.emplace(); assert(r.second); assert(r.first == m.begin()); assert(m.size() == 1); assert(*m.begin() == DefaultOnly()); assert(DefaultOnly::count == 1); r = m.emplace(); assert(!r.second); assert(r.first == m.begin()); assert(m.size() == 1); assert(*m.begin() == DefaultOnly()); assert(DefaultOnly::count == 1); } assert(DefaultOnly::count == 0); { typedef std::set<Emplaceable> M; typedef std::pair<M::iterator, bool> R; M m; R r = m.emplace(); assert(r.second); assert(r.first == m.begin()); assert(m.size() == 1); assert(*m.begin() == Emplaceable()); r = m.emplace(2, 3.5); assert(r.second); assert(r.first == next(m.begin())); assert(m.size() == 2); assert(*r.first == Emplaceable(2, 3.5)); r = m.emplace(2, 3.5); assert(!r.second); assert(r.first == next(m.begin())); assert(m.size() == 2); assert(*r.first == Emplaceable(2, 3.5)); } { typedef std::set<int> M; typedef std::pair<M::iterator, bool> R; M m; R r = m.emplace(M::value_type(2)); assert(r.second); assert(r.first == m.begin()); assert(m.size() == 1); assert(*r.first == 2); } { typedef std::set<int, std::less<int>, min_allocator<int>> M; typedef std::pair<M::iterator, bool> R; M m; R r = m.emplace(M::value_type(2)); assert(r.second); assert(r.first == m.begin()); assert(m.size() == 1); assert(*r.first == 2); } return 0; }