int main() { { typedef std::deque<MoveOnly> C; static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { typedef std::deque<MoveOnly, test_allocator<MoveOnly>> C; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { typedef std::deque<MoveOnly, other_allocator<MoveOnly>> C; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C; #if TEST_STD_VER >= 14 // In c++14, if POCS is set, swapping the allocator is required not to throw static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); #else static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); #endif } #if TEST_STD_VER >= 14 { typedef std::deque<MoveOnly, some_alloc2<MoveOnly>> C; // if the allocators are always equal, then the swap can be noexcept static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } #endif }
int main() { { typedef std::unordered_multimap<MoveOnly, MoveOnly> C; LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); } { typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, std::equal_to<MoveOnly>, test_allocator<std::pair<const MoveOnly, MoveOnly>>> C; LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); } { typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, std::equal_to<MoveOnly>, other_allocator<std::pair<const MoveOnly, MoveOnly>>> C; LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); } { typedef std::unordered_multimap<MoveOnly, MoveOnly, some_hash<MoveOnly>> C; static_assert(!std::is_nothrow_move_constructible<C>::value, ""); } { typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, some_comp<MoveOnly>> C; static_assert(!std::is_nothrow_move_constructible<C>::value, ""); } }
int main() { { typedef std::stack<MoveOnly> C; LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); } }
int main() { { typedef std::unordered_set<MoveOnly> C; static_assert(std::is_nothrow_move_assignable<C>::value, ""); } { typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>, std::equal_to<MoveOnly>, test_allocator<MoveOnly>> C; static_assert(!std::is_nothrow_move_assignable<C>::value, ""); } { typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>, std::equal_to<MoveOnly>, other_allocator<MoveOnly>> C; LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable<C>::value, ""); } { typedef std::unordered_set<MoveOnly, some_hash<MoveOnly>> C; static_assert(!std::is_nothrow_move_assignable<C>::value, ""); } { typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>, some_comp<MoveOnly>> C; static_assert(!std::is_nothrow_move_assignable<C>::value, ""); } }
int main() { { typedef double T; typedef std::array<T, 10> C; static_assert((std::is_same<C::reference, T&>::value), ""); static_assert((std::is_same<C::const_reference, const T&>::value), ""); LIBCPP_STATIC_ASSERT((std::is_same<C::iterator, T*>::value), ""); LIBCPP_STATIC_ASSERT((std::is_same<C::const_iterator, const T*>::value), ""); test_iterators<C>(); static_assert((std::is_same<C::pointer, T*>::value), ""); static_assert((std::is_same<C::const_pointer, const T*>::value), ""); static_assert((std::is_same<C::size_type, std::size_t>::value), ""); static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), ""); static_assert((std::is_same<C::reverse_iterator, std::reverse_iterator<C::iterator> >::value), ""); static_assert((std::is_same<C::const_reverse_iterator, std::reverse_iterator<C::const_iterator> >::value), ""); static_assert((std::is_signed<typename C::difference_type>::value), ""); static_assert((std::is_unsigned<typename C::size_type>::value), ""); static_assert((std::is_same<typename C::difference_type, typename std::iterator_traits<typename C::iterator>::difference_type>::value), ""); static_assert((std::is_same<typename C::difference_type, typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), ""); } { typedef int* T; typedef std::array<T, 0> C; static_assert((std::is_same<C::reference, T&>::value), ""); static_assert((std::is_same<C::const_reference, const T&>::value), ""); LIBCPP_STATIC_ASSERT((std::is_same<C::iterator, T*>::value), ""); LIBCPP_STATIC_ASSERT((std::is_same<C::const_iterator, const T*>::value), ""); test_iterators<C>(); static_assert((std::is_same<C::pointer, T*>::value), ""); static_assert((std::is_same<C::const_pointer, const T*>::value), ""); static_assert((std::is_same<C::size_type, std::size_t>::value), ""); static_assert((std::is_same<C::difference_type, std::ptrdiff_t>::value), ""); static_assert((std::is_same<C::reverse_iterator, std::reverse_iterator<C::iterator> >::value), ""); static_assert((std::is_same<C::const_reverse_iterator, std::reverse_iterator<C::const_iterator> >::value), ""); static_assert((std::is_signed<typename C::difference_type>::value), ""); static_assert((std::is_unsigned<typename C::size_type>::value), ""); static_assert((std::is_same<typename C::difference_type, typename std::iterator_traits<typename C::iterator>::difference_type>::value), ""); static_assert((std::is_same<typename C::difference_type, typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), ""); } }
int main() { typedef std::pair<const MoveOnly, MoveOnly> V; { typedef std::multimap<MoveOnly, MoveOnly> C; static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<V>> C; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { typedef std::multimap<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<V>> C; LIBCPP_STATIC_ASSERT(noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { typedef std::multimap<MoveOnly, MoveOnly, some_comp<MoveOnly>> C; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } #if TEST_STD_VER >= 14 { // POCS allocator, throwable swap for comp typedef std::multimap<MoveOnly, MoveOnly, some_comp <MoveOnly>, some_alloc <V>> C; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { // always equal allocator, throwable swap for comp typedef std::multimap<MoveOnly, MoveOnly, some_comp <MoveOnly>, some_alloc2<V>> C; static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { // POCS allocator, nothrow swap for comp typedef std::multimap<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc <V>> C; static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { // always equal allocator, nothrow swap for comp typedef std::multimap<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc2<V>> C; static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } { // NOT always equal allocator, nothrow swap for comp typedef std::multimap<MoveOnly, MoveOnly, some_comp2<MoveOnly>, some_alloc3<V>> C; LIBCPP_STATIC_ASSERT( noexcept(swap(std::declval<C&>(), std::declval<C&>())), ""); } #endif }
int main() { { typedef std::set<MoveOnly> C; LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); } { typedef std::set<MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C; LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); } { typedef std::set<MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C; LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); } { typedef std::set<MoveOnly, some_comp<MoveOnly>> C; static_assert(!std::is_nothrow_move_constructible<C>::value, ""); } }
int main(int, char**) { using H = coro::coroutine_handle<>; using S = SuspendT; H h{}; S s{}; S const& cs = s; { LIBCPP_STATIC_ASSERT(noexcept(s.await_ready()), ""); static_assert(std::is_same<decltype(s.await_ready()), bool>::value, ""); assert(s.await_ready() == false); assert(cs.await_ready() == false); } { LIBCPP_STATIC_ASSERT(noexcept(s.await_suspend(h)), ""); static_assert(std::is_same<decltype(s.await_suspend(h)), void>::value, ""); s.await_suspend(h); cs.await_suspend(h); } { LIBCPP_STATIC_ASSERT(noexcept(s.await_resume()), ""); static_assert(std::is_same<decltype(s.await_resume()), void>::value, ""); s.await_resume(); cs.await_resume(); } { static_assert(std::is_nothrow_default_constructible<S>::value, ""); static_assert(std::is_nothrow_copy_constructible<S>::value, ""); static_assert(std::is_nothrow_move_constructible<S>::value, ""); static_assert(std::is_nothrow_copy_assignable<S>::value, ""); static_assert(std::is_nothrow_move_assignable<S>::value, ""); static_assert(std::is_trivially_copyable<S>::value, ""); static_assert(check_suspend_constexpr(), ""); } { // suppress unused warnings for the global constexpr test variable ((void)constexpr_sa); } return 0; }
int main() { { typedef std::vector<bool> C; LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); } { typedef std::vector<bool, test_allocator<bool>> C; LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); } { typedef std::vector<bool, other_allocator<bool>> C; LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible<C>::value, ""); } { typedef std::vector<bool, some_alloc<bool>> C; // In C++17, move constructors for allocators are not allowed to throw #if TEST_STD_VER > 14 LIBCPP_STATIC_ASSERT( std::is_nothrow_move_constructible<C>::value, ""); #else static_assert(!std::is_nothrow_move_constructible<C>::value, ""); #endif } }
int main(int, char**) { #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS LIBCPP_STATIC_ASSERT(static_cast<int>(std::launch::any) == (static_cast<int>(std::launch::async) | static_cast<int>(std::launch::deferred)), ""); #else LIBCPP_STATIC_ASSERT(std::launch::any == (std::launch::async | std::launch::deferred), ""); static_assert(std::launch(0) == (std::launch::async & std::launch::deferred), ""); LIBCPP_STATIC_ASSERT(std::launch::any == (std::launch::async ^ std::launch::deferred), ""); LIBCPP_STATIC_ASSERT(std::launch::deferred == ~std::launch::async, ""); std::launch x = std::launch::async; x &= std::launch::deferred; assert(x == std::launch(0)); x = std::launch::async; x |= std::launch::deferred; LIBCPP_ASSERT(x == std::launch::any); x ^= std::launch::deferred; assert(x == std::launch::async); #endif static_assert(static_cast<int>(std::launch::async) == 1, ""); static_assert(static_cast<int>(std::launch::deferred) == 2, ""); return 0; }
int main() { { typedef std::string C; static_assert(std::is_nothrow_destructible<C>::value, ""); } { typedef std::basic_string<char, std::char_traits<char>, test_allocator<char>> C; static_assert(std::is_nothrow_destructible<C>::value, ""); } { typedef std::basic_string<char, std::char_traits<char>, some_alloc<char>> C; LIBCPP_STATIC_ASSERT(!std::is_nothrow_destructible<C>::value, ""); } }
int main() { // Use a builtin type so we don't get ADL lookup. typedef double T[17][29]; { LIBCPP_STATIC_ASSERT(std::__is_swappable<T>::value, ""); #if TEST_STD_VER > 14 static_assert(std::is_swappable_v<T>, ""); #endif } { T t1 = {}; T t2 = {}; std::iter_swap(t1, t2); std::swap_ranges(t1, t1 + 17, t2); } }