193 lines · cpp
1//===----------------------------------------------------------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9// UNSUPPORTED: c++03, c++11, c++14, c++17, c++2010 11// <flat_set>12 13// flat_set(flat_set&&);14 15#include <algorithm>16#include <deque>17#include <flat_set>18#include <functional>19#include <utility>20#include <vector>21 22#include "../helpers.h"23#include "test_macros.h"24#include "../../../test_compare.h"25#include "test_allocator.h"26#include "min_allocator.h"27 28template <template <class...> class KeyContainer>29constexpr void test() {30 {31 using C = test_less<int>;32 using A = test_allocator<int>;33 using M = std::flat_set<int, C, KeyContainer<int, A>>;34 M mo = M({1, 2, 3}, C(5), A(7));35 M m = std::move(mo);36 assert((m == M{1, 2, 3}));37 assert(m.key_comp() == C(5));38 assert(std::move(m).extract().get_allocator() == A(7));39 40 assert(mo.empty());41 assert(mo.key_comp() == C(5));42 assert(std::move(mo).extract().get_allocator().get_id() == test_alloc_base::moved_value);43 }44 {45 using C = test_less<int>;46 using A = min_allocator<int>;47 using M = std::flat_set<int, C, KeyContainer<int, A>>;48 M mo = M({1, 2, 3}, C(5), A());49 M m = std::move(mo);50 assert((m == M{1, 2, 3}));51 assert(m.key_comp() == C(5));52 assert(std::move(m).extract().get_allocator() == A());53 54 assert(mo.empty());55 assert(mo.key_comp() == C(5));56 assert(std::move(mo).extract().get_allocator() == A());57 }58 if (!TEST_IS_CONSTANT_EVALUATED) {59 // A moved-from flat_set maintains its class invariant in the presence of moved-from comparators.60 using M = std::flat_set<int, std::function<bool(int, int)>, KeyContainer<int>>;61 M mo = M({1, 2, 3}, std::less<int>());62 M m = std::move(mo);63 assert(m.size() == 3);64 assert(std::is_sorted(m.begin(), m.end(), m.value_comp()));65 assert(m.key_comp()(1, 2) == true);66 67 assert(std::is_sorted(mo.begin(), mo.end(), mo.value_comp()));68 LIBCPP_ASSERT(m.key_comp()(1, 2) == true);69 LIBCPP_ASSERT(mo.empty());70 mo.insert({1, 2, 3}); // insert has no preconditions71 assert(m == mo);72 }73 {74 // moved-from object maintains invariant if the underlying container does not clear after move75 using M = std::flat_set<int, std::less<>, CopyOnlyVector<int>>;76 M m1 = M({1, 2, 3});77 M m2 = std::move(m1);78 assert(m2.size() == 3);79 check_invariant(m1);80 LIBCPP_ASSERT(m1.empty());81 LIBCPP_ASSERT(m1.size() == 0);82 }83}84 85template <class T>86struct ThrowingMoveAllocator {87 using value_type = T;88 explicit ThrowingMoveAllocator() = default;89 ThrowingMoveAllocator(const ThrowingMoveAllocator&) = default;90 constexpr ThrowingMoveAllocator(ThrowingMoveAllocator&&) noexcept(false) {}91 constexpr T* allocate(std::ptrdiff_t n) { return std::allocator<T>().allocate(n); }92 constexpr void deallocate(T* p, std::ptrdiff_t n) { return std::allocator<T>().deallocate(p, n); }93 friend bool operator==(ThrowingMoveAllocator, ThrowingMoveAllocator) = default;94};95 96struct ThrowingMoveComp {97 ThrowingMoveComp() = default;98 constexpr ThrowingMoveComp(const ThrowingMoveComp&) noexcept(true) {}99 constexpr ThrowingMoveComp(ThrowingMoveComp&&) noexcept(false) {}100 constexpr bool operator()(const auto&, const auto&) const { return false; }101};102 103template <template <class...> class KeyContainer>104constexpr void test_move_noexcept() {105 {106 using C = std::flat_set<int, std::less<int>, KeyContainer<int>>;107 LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible_v<C>);108 C c;109 C d = std::move(c);110 }111 {112 using C = std::flat_set<int, std::less<int>, KeyContainer<int, test_allocator<int>>>;113 LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible_v<C>);114 C c;115 C d = std::move(c);116 }117#if _LIBCPP_VERSION118 if (!TEST_IS_CONSTANT_EVALUATED) {119 // Container fails to be nothrow-move-constructible; this relies on libc++'s support for non-nothrow-copyable allocators120 using C = std::flat_set<int, std::less<int>, std::deque<int, ThrowingMoveAllocator<int>>>;121 static_assert(!std::is_nothrow_move_constructible_v<std::deque<int, ThrowingMoveAllocator<int>>>);122 static_assert(!std::is_nothrow_move_constructible_v<C>);123 C c;124 C d = std::move(c);125 }126#endif // _LIBCPP_VERSION127 {128 // Comparator fails to be nothrow-move-constructible129 using C = std::flat_set<int, ThrowingMoveComp, KeyContainer<int>>;130 static_assert(!std::is_nothrow_move_constructible_v<C>);131 C c;132 C d = std::move(c);133 }134}135 136constexpr bool test() {137 test<std::vector>();138 test_move_noexcept<std::vector>();139#ifndef __cpp_lib_constexpr_deque140 if (!TEST_IS_CONSTANT_EVALUATED)141#endif142 {143 test<std::deque>();144 test_move_noexcept<std::deque>();145 }146 return true;147}148 149#if !defined(TEST_HAS_NO_EXCEPTIONS)150static int countdown = 0;151 152struct EvilContainer : std::vector<int> {153 EvilContainer() = default;154 EvilContainer(EvilContainer&& rhs) {155 // Throw on move-construction.156 if (--countdown == 0) {157 rhs.insert(rhs.end(), 0);158 rhs.insert(rhs.end(), 0);159 throw 42;160 }161 }162};163 164void test_move_exception() {165 {166 using M = std::flat_set<int, std::less<int>, EvilContainer>;167 M mo = {1, 2, 3};168 countdown = 1;169 try {170 M m = std::move(mo);171 assert(false); // not reached172 } catch (int x) {173 assert(x == 42);174 }175 // The source flat_set maintains its class invariant.176 check_invariant(mo);177 LIBCPP_ASSERT(mo.empty());178 }179}180#endif // !defined(TEST_HAS_NO_EXCEPTIONS)181 182int main(int, char**) {183 test();184#if !defined(TEST_HAS_NO_EXCEPTIONS)185 test_move_exception();186#endif187#if TEST_STD_VER >= 26188 static_assert(test());189#endif190 191 return 0;192}193