diff --git a/libcxx/docs/ReleaseNotes/21.rst b/libcxx/docs/ReleaseNotes/21.rst index 5bb25af4a219..f67a5fced6fc 100644 --- a/libcxx/docs/ReleaseNotes/21.rst +++ b/libcxx/docs/ReleaseNotes/21.rst @@ -43,6 +43,7 @@ Implemented Papers - P1361R2: Integration of chrono with text formatting (`Github `__) - P2255R2: A type trait to detect reference binding to temporary (implemented the type traits only) (`Github `__) - P2562R1: ``constexpr`` Stable Sorting (`Github `__) +- P1222R4: A Standard ``flat_set`` is partially implemented and ``flat_set`` is provided (`Github `__) Improvements and New Features ----------------------------- diff --git a/libcxx/docs/Status/Cxx23Papers.csv b/libcxx/docs/Status/Cxx23Papers.csv index 2589954729a3..4e45debd419e 100644 --- a/libcxx/docs/Status/Cxx23Papers.csv +++ b/libcxx/docs/Status/Cxx23Papers.csv @@ -54,7 +54,7 @@ "`P0009R18 `__","mdspan: A Non-Owning Multidimensional Array Reference","2022-07 (Virtual)","|Complete|","18","" "`P0429R9 `__","A Standard ``flat_map``","2022-07 (Virtual)","|Complete|","20","" "`P1169R4 `__","``static operator()``","2022-07 (Virtual)","|Complete|","16","" -"`P1222R4 `__","A Standard ``flat_set``","2022-07 (Virtual)","","","" +"`P1222R4 `__","A Standard ``flat_set``","2022-07 (Virtual)","|In progress|","","" "`P1223R5 `__","``ranges::find_last()``, ``ranges::find_last_if()``, and ``ranges::find_last_if_not()``","2022-07 (Virtual)","|Complete|","19","" "`P1467R9 `__","Extended ``floating-point`` types and standard names","2022-07 (Virtual)","","","" "`P1642R11 `__","Freestanding ``[utilities]``, ``[ranges]``, and ``[iterators]``","2022-07 (Virtual)","","","" diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt index 443e58fffe0d..a021b9bb44d6 100644 --- a/libcxx/include/CMakeLists.txt +++ b/libcxx/include/CMakeLists.txt @@ -369,6 +369,8 @@ set(files __flat_map/sorted_equivalent.h __flat_map/sorted_unique.h __flat_map/utils.h + __flat_set/flat_set.h + __flat_set/ra_iterator.h __format/buffer.h __format/concepts.h __format/container_adaptor.h @@ -995,6 +997,7 @@ set(files fenv.h filesystem flat_map + flat_set float.h format forward_list diff --git a/libcxx/include/__flat_set/flat_set.h b/libcxx/include/__flat_set/flat_set.h new file mode 100644 index 000000000000..cc45db7565bd --- /dev/null +++ b/libcxx/include/__flat_set/flat_set.h @@ -0,0 +1,846 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___FLAT_SET_FLAT_SET_H +#define _LIBCPP___FLAT_SET_FLAT_SET_H + +#include <__algorithm/lexicographical_compare_three_way.h> +#include <__algorithm/min.h> +#include <__algorithm/ranges_adjacent_find.h> +#include <__algorithm/ranges_equal.h> +#include <__algorithm/ranges_inplace_merge.h> +#include <__algorithm/ranges_lower_bound.h> +#include <__algorithm/ranges_partition_point.h> +#include <__algorithm/ranges_sort.h> +#include <__algorithm/ranges_unique.h> +#include <__algorithm/ranges_upper_bound.h> +#include <__algorithm/remove_if.h> +#include <__assert> +#include <__compare/synth_three_way.h> +#include <__concepts/swappable.h> +#include <__config> +#include <__cstddef/ptrdiff_t.h> +#include <__flat_map/sorted_unique.h> +#include <__flat_set/ra_iterator.h> +#include <__functional/invoke.h> +#include <__functional/is_transparent.h> +#include <__functional/operations.h> +#include <__fwd/vector.h> +#include <__iterator/concepts.h> +#include <__iterator/distance.h> +#include <__iterator/iterator_traits.h> +#include <__iterator/next.h> +#include <__iterator/prev.h> +#include <__iterator/ranges_iterator_traits.h> +#include <__iterator/reverse_iterator.h> +#include <__memory/allocator_traits.h> +#include <__memory/uses_allocator.h> +#include <__memory/uses_allocator_construction.h> +#include <__ranges/access.h> +#include <__ranges/concepts.h> +#include <__ranges/container_compatible_range.h> +#include <__ranges/drop_view.h> +#include <__ranges/from_range.h> +#include <__ranges/ref_view.h> +#include <__ranges/size.h> +#include <__ranges/subrange.h> +#include <__type_traits/conjunction.h> +#include <__type_traits/container_traits.h> +#include <__type_traits/invoke.h> +#include <__type_traits/is_allocator.h> +#include <__type_traits/is_const.h> +#include <__type_traits/is_nothrow_constructible.h> +#include <__type_traits/is_same.h> +#include <__type_traits/remove_reference.h> +#include <__utility/as_const.h> +#include <__utility/exception_guard.h> +#include <__utility/move.h> +#include <__utility/pair.h> +#include <__utility/scope_guard.h> +#include <__vector/vector.h> +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +#if _LIBCPP_STD_VER >= 23 + +_LIBCPP_BEGIN_NAMESPACE_STD + +template , class _KeyContainer = vector<_Key>> +class flat_set { + template + friend class flat_set; + + static_assert(is_same_v<_Key, typename _KeyContainer::value_type>); + static_assert(!is_same_v<_KeyContainer, std::vector>, "vector is not a sequence container"); + + using __key_iterator _LIBCPP_NODEBUG = typename _KeyContainer::const_iterator; + +public: + // types + using key_type = _Key; + using value_type = _Key; + using key_compare = __type_identity_t<_Compare>; + using value_compare = _Compare; + using reference = value_type&; + using const_reference = const value_type&; + using size_type = typename _KeyContainer::size_type; + using difference_type = typename _KeyContainer::difference_type; + using iterator = __ra_iterator; + using const_iterator = iterator; + using reverse_iterator = std::reverse_iterator; + using const_reverse_iterator = std::reverse_iterator; + using container_type = _KeyContainer; + +public: + // [flat.set.cons], construct/copy/destroy + _LIBCPP_HIDE_FROM_ABI + flat_set() noexcept(is_nothrow_default_constructible_v<_KeyContainer> && is_nothrow_default_constructible_v<_Compare>) + : __keys_(), __compare_() {} + + _LIBCPP_HIDE_FROM_ABI flat_set(const flat_set&) = default; + + _LIBCPP_HIDE_FROM_ABI flat_set(flat_set&& __other) noexcept( + is_nothrow_move_constructible_v<_KeyContainer> && is_nothrow_move_constructible_v<_Compare>) +# if _LIBCPP_HAS_EXCEPTIONS + try +# endif // _LIBCPP_HAS_EXCEPTIONS + : __keys_(std::move(__other.__keys_)), __compare_(std::move(__other.__compare_)) { + __other.clear(); +# if _LIBCPP_HAS_EXCEPTIONS + } catch (...) { + __other.clear(); + // gcc does not like the `throw` keyword in a conditionally noexcept function + if constexpr (!(is_nothrow_move_constructible_v<_KeyContainer> && is_nothrow_move_constructible_v<_Compare>)) { + throw; + } +# endif // _LIBCPP_HAS_EXCEPTIONS + } + + _LIBCPP_HIDE_FROM_ABI explicit flat_set(const key_compare& __comp) : __keys_(), __compare_(__comp) {} + + _LIBCPP_HIDE_FROM_ABI explicit flat_set(container_type __keys, const key_compare& __comp = key_compare()) + : __keys_(std::move(__keys)), __compare_(__comp) { + __sort_and_unique(); + } + + _LIBCPP_HIDE_FROM_ABI flat_set(sorted_unique_t, container_type __keys, const key_compare& __comp = key_compare()) + : __keys_(std::move(__keys)), __compare_(__comp) { + _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT( + __is_sorted_and_unique(__keys_), "Either the key container is not sorted or it contains duplicates"); + } + + template + requires __has_input_iterator_category<_InputIterator>::value + _LIBCPP_HIDE_FROM_ABI + flat_set(_InputIterator __first, _InputIterator __last, const key_compare& __comp = key_compare()) + : __keys_(), __compare_(__comp) { + insert(__first, __last); + } + + template + requires __has_input_iterator_category<_InputIterator>::value + _LIBCPP_HIDE_FROM_ABI + flat_set(sorted_unique_t, _InputIterator __first, _InputIterator __last, const key_compare& __comp = key_compare()) + : __keys_(__first, __last), __compare_(__comp) { + _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT( + __is_sorted_and_unique(__keys_), "Either the key container is not sorted or it contains duplicates"); + } + + template <_ContainerCompatibleRange _Range> + _LIBCPP_HIDE_FROM_ABI flat_set(from_range_t, _Range&& __rg) + : flat_set(from_range, std::forward<_Range>(__rg), key_compare()) {} + + template <_ContainerCompatibleRange _Range> + _LIBCPP_HIDE_FROM_ABI flat_set(from_range_t, _Range&& __rg, const key_compare& __comp) : flat_set(__comp) { + insert_range(std::forward<_Range>(__rg)); + } + + _LIBCPP_HIDE_FROM_ABI flat_set(initializer_list __il, const key_compare& __comp = key_compare()) + : flat_set(__il.begin(), __il.end(), __comp) {} + + _LIBCPP_HIDE_FROM_ABI + flat_set(sorted_unique_t, initializer_list __il, const key_compare& __comp = key_compare()) + : flat_set(sorted_unique, __il.begin(), __il.end(), __comp) {} + + template + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI explicit flat_set(const _Allocator& __alloc) + : __keys_(std::make_obj_using_allocator(__alloc)), __compare_() {} + + template + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI flat_set(const key_compare& __comp, const _Allocator& __alloc) + : __keys_(std::make_obj_using_allocator(__alloc)), __compare_(__comp) {} + + template + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI flat_set(const container_type& __keys, const _Allocator& __alloc) + : __keys_(std::make_obj_using_allocator(__alloc, __keys)), __compare_() { + __sort_and_unique(); + } + + template + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI flat_set(const container_type& __keys, const key_compare& __comp, const _Allocator& __alloc) + : __keys_(std::make_obj_using_allocator(__alloc, __keys)), __compare_(__comp) { + __sort_and_unique(); + } + + template + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI flat_set(sorted_unique_t, const container_type& __keys, const _Allocator& __alloc) + : __keys_(std::make_obj_using_allocator(__alloc, __keys)), __compare_() { + _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT( + __is_sorted_and_unique(__keys_), "Either the key container is not sorted or it contains duplicates"); + } + + template + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI + flat_set(sorted_unique_t, const container_type& __keys, const key_compare& __comp, const _Allocator& __alloc) + : __keys_(std::make_obj_using_allocator(__alloc, __keys)), __compare_(__comp) { + _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT( + __is_sorted_and_unique(__keys_), "Either the key container is not sorted or it contains duplicates"); + } + + template + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI flat_set(const flat_set& __other, const _Allocator& __alloc) + : __keys_(std::make_obj_using_allocator(__alloc, __other.__keys_)), + __compare_(__other.__compare_) {} + + template + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI flat_set(flat_set&& __other, const _Allocator& __alloc) +# if _LIBCPP_HAS_EXCEPTIONS + try +# endif // _LIBCPP_HAS_EXCEPTIONS + : __keys_(std::make_obj_using_allocator(__alloc, std::move(__other.__keys_))), + __compare_(std::move(__other.__compare_)) { + __other.clear(); +# if _LIBCPP_HAS_EXCEPTIONS + } catch (...) { + __other.clear(); + throw; +# endif // _LIBCPP_HAS_EXCEPTIONS + } + + template + requires(__has_input_iterator_category<_InputIterator>::value && uses_allocator::value) + _LIBCPP_HIDE_FROM_ABI flat_set(_InputIterator __first, _InputIterator __last, const _Allocator& __alloc) + : __keys_(std::make_obj_using_allocator(__alloc)), __compare_() { + insert(__first, __last); + } + + template + requires(__has_input_iterator_category<_InputIterator>::value && uses_allocator::value) + _LIBCPP_HIDE_FROM_ABI + flat_set(_InputIterator __first, _InputIterator __last, const key_compare& __comp, const _Allocator& __alloc) + : __keys_(std::make_obj_using_allocator(__alloc)), __compare_(__comp) { + insert(__first, __last); + } + + template + requires(__has_input_iterator_category<_InputIterator>::value && uses_allocator::value) + _LIBCPP_HIDE_FROM_ABI + flat_set(sorted_unique_t, _InputIterator __first, _InputIterator __last, const _Allocator& __alloc) + : __keys_(std::make_obj_using_allocator(__alloc, __first, __last)), __compare_() { + _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT( + __is_sorted_and_unique(__keys_), "Either the key container is not sorted or it contains duplicates"); + } + + template + requires(__has_input_iterator_category<_InputIterator>::value && uses_allocator::value) + _LIBCPP_HIDE_FROM_ABI + flat_set(sorted_unique_t, + _InputIterator __first, + _InputIterator __last, + const key_compare& __comp, + const _Allocator& __alloc) + : __keys_(std::make_obj_using_allocator(__alloc, __first, __last)), __compare_(__comp) { + _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT( + __is_sorted_and_unique(__keys_), "Either the key container is not sorted or it contains duplicates"); + } + + template <_ContainerCompatibleRange _Range, class _Allocator> + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI flat_set(from_range_t, _Range&& __rg, const _Allocator& __alloc) + : __keys_(std::make_obj_using_allocator(__alloc)), __compare_() { + insert_range(std::forward<_Range>(__rg)); + } + + template <_ContainerCompatibleRange _Range, class _Allocator> + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI flat_set(from_range_t, _Range&& __rg, const key_compare& __comp, const _Allocator& __alloc) + : __keys_(std::make_obj_using_allocator(__alloc)), __compare_(__comp) { + insert_range(std::forward<_Range>(__rg)); + } + + template + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI flat_set(initializer_list __il, const _Allocator& __alloc) + : flat_set(__il.begin(), __il.end(), __alloc) {} + + template + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI + flat_set(initializer_list __il, const key_compare& __comp, const _Allocator& __alloc) + : flat_set(__il.begin(), __il.end(), __comp, __alloc) {} + + template + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI flat_set(sorted_unique_t, initializer_list __il, const _Allocator& __alloc) + : flat_set(sorted_unique, __il.begin(), __il.end(), __alloc) {} + + template + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI + flat_set(sorted_unique_t, initializer_list __il, const key_compare& __comp, const _Allocator& __alloc) + : flat_set(sorted_unique, __il.begin(), __il.end(), __comp, __alloc) {} + + _LIBCPP_HIDE_FROM_ABI flat_set& operator=(initializer_list __il) { + clear(); + insert(__il); + return *this; + } + + _LIBCPP_HIDE_FROM_ABI flat_set& operator=(const flat_set&) = default; + + _LIBCPP_HIDE_FROM_ABI flat_set& operator=(flat_set&& __other) noexcept( + is_nothrow_move_assignable_v<_KeyContainer> && is_nothrow_move_assignable_v<_Compare>) { + // No matter what happens, we always want to clear the other container before returning + // since we moved from it + auto __clear_other_guard = std::__make_scope_guard([&]() noexcept { __other.clear() /* noexcept */; }); + { + // If an exception is thrown, we have no choice but to clear *this to preserve invariants + auto __on_exception = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; }); + __keys_ = std::move(__other.__keys_); + __compare_ = std::move(__other.__compare_); + __on_exception.__complete(); + } + return *this; + } + + // iterators + _LIBCPP_HIDE_FROM_ABI iterator begin() noexcept { return iterator(std::as_const(__keys_).begin()); } + _LIBCPP_HIDE_FROM_ABI const_iterator begin() const noexcept { return const_iterator(__keys_.begin()); } + _LIBCPP_HIDE_FROM_ABI iterator end() noexcept { return iterator(std::as_const(__keys_).end()); } + _LIBCPP_HIDE_FROM_ABI const_iterator end() const noexcept { return const_iterator(__keys_.end()); } + + _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } + _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); } + _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() noexcept { return reverse_iterator(begin()); } + _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); } + + _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const noexcept { return begin(); } + _LIBCPP_HIDE_FROM_ABI const_iterator cend() const noexcept { return end(); } + _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); } + _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); } + + // [flat.set.capacity], capacity + [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool empty() const noexcept { return __keys_.empty(); } + + _LIBCPP_HIDE_FROM_ABI size_type size() const noexcept { return __keys_.size(); } + + _LIBCPP_HIDE_FROM_ABI size_type max_size() const noexcept { return __keys_.max_size(); } + + // [flat.set.modifiers], modifiers + template + _LIBCPP_HIDE_FROM_ABI pair emplace(_Args&&... __args) { + if constexpr (sizeof...(__args) == 1 && (is_same_v, _Key> && ...)) { + return __emplace(std::forward<_Args>(__args)...); + } else { + return __emplace(_Key(std::forward<_Args>(__args)...)); + } + } + + template + _LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator __hint, _Args&&... __args) { + if constexpr (sizeof...(__args) == 1 && (is_same_v, _Key> && ...)) { + return __emplace_hint(std::move(__hint), std::forward<_Args>(__args)...); + } else { + return __emplace_hint(std::move(__hint), _Key(std::forward<_Args>(__args)...)); + } + } + + _LIBCPP_HIDE_FROM_ABI pair insert(const value_type& __x) { return emplace(__x); } + + _LIBCPP_HIDE_FROM_ABI pair insert(value_type&& __x) { return emplace(std::move(__x)); } + + template + requires(__is_transparent_v<_Compare> && is_constructible_v) + _LIBCPP_HIDE_FROM_ABI pair insert(_Kp&& __x) { + return emplace(std::forward<_Kp>(__x)); + } + _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __hint, const value_type& __x) { + return emplace_hint(__hint, __x); + } + + _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __hint, value_type&& __x) { + return emplace_hint(__hint, std::move(__x)); + } + + template + requires(__is_transparent_v<_Compare> && is_constructible_v) + _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __hint, _Kp&& __x) { + return emplace_hint(__hint, std::forward<_Kp>(__x)); + } + + template + requires __has_input_iterator_category<_InputIterator>::value + _LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last) { + if constexpr (sized_sentinel_for<_InputIterator, _InputIterator>) { + __reserve(__last - __first); + } + __append_sort_merge_unique(std::move(__first), std::move(__last)); + } + + template + requires __has_input_iterator_category<_InputIterator>::value + _LIBCPP_HIDE_FROM_ABI void insert(sorted_unique_t, _InputIterator __first, _InputIterator __last) { + if constexpr (sized_sentinel_for<_InputIterator, _InputIterator>) { + __reserve(__last - __first); + } + + __append_sort_merge_unique(std::move(__first), std::move(__last)); + } + + template <_ContainerCompatibleRange _Range> + _LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) { + if constexpr (ranges::sized_range<_Range>) { + __reserve(ranges::size(__range)); + } + + __append_sort_merge_unique(std::forward<_Range>(__range)); + } + + _LIBCPP_HIDE_FROM_ABI void insert(initializer_list __il) { insert(__il.begin(), __il.end()); } + + _LIBCPP_HIDE_FROM_ABI void insert(sorted_unique_t, initializer_list __il) { + insert(sorted_unique, __il.begin(), __il.end()); + } + + _LIBCPP_HIDE_FROM_ABI container_type extract() && { + auto __guard = std::__make_scope_guard([&]() noexcept { clear() /* noexcept */; }); + auto __ret = std::move(__keys_); + return __ret; + } + + _LIBCPP_HIDE_FROM_ABI void replace(container_type&& __keys) { + _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT( + __is_sorted_and_unique(__keys), "Either the key container is not sorted or it contains duplicates"); + auto __guard = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; }); + __keys_ = std::move(__keys); + __guard.__complete(); + } + + _LIBCPP_HIDE_FROM_ABI iterator erase(iterator __position) { + auto __on_failure = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; }); + auto __key_iter = __keys_.erase(__position.__base()); + __on_failure.__complete(); + return iterator(__key_iter); + } + + // The following overload is the same as the iterator overload + // iterator erase(const_iterator __position); + + _LIBCPP_HIDE_FROM_ABI size_type erase(const key_type& __x) { + auto __iter = find(__x); + if (__iter != end()) { + erase(__iter); + return 1; + } + return 0; + } + + template + requires(__is_transparent_v<_Compare> && !is_convertible_v<_Kp &&, iterator> && + !is_convertible_v<_Kp &&, const_iterator>) + _LIBCPP_HIDE_FROM_ABI size_type erase(_Kp&& __x) { + auto [__first, __last] = equal_range(__x); + auto __res = __last - __first; + erase(__first, __last); + return __res; + } + + _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __first, const_iterator __last) { + auto __on_failure = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; }); + auto __key_it = __keys_.erase(__first.__base(), __last.__base()); + __on_failure.__complete(); + return iterator(std::move(__key_it)); + } + + _LIBCPP_HIDE_FROM_ABI void swap(flat_set& __y) noexcept { + // warning: The spec has unconditional noexcept, which means that + // if any of the following functions throw an exception, + // std::terminate will be called. + // This is discussed in P2767, which hasn't been voted on yet. + ranges::swap(__compare_, __y.__compare_); + ranges::swap(__keys_, __y.__keys_); + } + + _LIBCPP_HIDE_FROM_ABI void clear() noexcept { __keys_.clear(); } + + // observers + _LIBCPP_HIDE_FROM_ABI key_compare key_comp() const { return __compare_; } + _LIBCPP_HIDE_FROM_ABI value_compare value_comp() const { return __compare_; } + + // set operations + _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __x) { return __find_impl(*this, __x); } + + _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __x) const { return __find_impl(*this, __x); } + + template + requires __is_transparent_v<_Compare> + _LIBCPP_HIDE_FROM_ABI iterator find(const _Kp& __x) { + return __find_impl(*this, __x); + } + + template + requires __is_transparent_v<_Compare> + _LIBCPP_HIDE_FROM_ABI const_iterator find(const _Kp& __x) const { + return __find_impl(*this, __x); + } + + _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __x) const { return contains(__x) ? 1 : 0; } + + template + requires __is_transparent_v<_Compare> + _LIBCPP_HIDE_FROM_ABI size_type count(const _Kp& __x) const { + return contains(__x) ? 1 : 0; + } + + _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __x) const { return find(__x) != end(); } + + template + requires __is_transparent_v<_Compare> + _LIBCPP_HIDE_FROM_ABI bool contains(const _Kp& __x) const { + return find(__x) != end(); + } + + _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const key_type& __x) { + return iterator(ranges::lower_bound(std::as_const(__keys_), __x, __compare_)); + } + + _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const key_type& __x) const { + return const_iterator(ranges::lower_bound(__keys_, __x, __compare_)); + } + + template + requires __is_transparent_v<_Compare> + _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _Kp& __x) { + return iterator(ranges::lower_bound(std::as_const(__keys_), __x, __compare_)); + } + + template + requires __is_transparent_v<_Compare> + _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _Kp& __x) const { + return const_iterator(ranges::lower_bound(__keys_, __x, __compare_)); + } + + _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __x) { + return iterator(ranges::upper_bound(std::as_const(__keys_), __x, __compare_)); + } + + _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const key_type& __x) const { + return const_iterator(ranges::upper_bound(__keys_, __x, __compare_)); + } + + template + requires __is_transparent_v<_Compare> + _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _Kp& __x) { + return iterator(ranges::upper_bound(std::as_const(__keys_), __x, __compare_)); + } + + template + requires __is_transparent_v<_Compare> + _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _Kp& __x) const { + return const_iterator(ranges::upper_bound(__keys_, __x, __compare_)); + } + + _LIBCPP_HIDE_FROM_ABI pair equal_range(const key_type& __x) { + return __equal_range_impl(*this, __x); + } + + _LIBCPP_HIDE_FROM_ABI pair equal_range(const key_type& __x) const { + return __equal_range_impl(*this, __x); + } + + template + requires __is_transparent_v<_Compare> + _LIBCPP_HIDE_FROM_ABI pair equal_range(const _Kp& __x) { + return __equal_range_impl(*this, __x); + } + template + requires __is_transparent_v<_Compare> + _LIBCPP_HIDE_FROM_ABI pair equal_range(const _Kp& __x) const { + return __equal_range_impl(*this, __x); + } + + friend _LIBCPP_HIDE_FROM_ABI bool operator==(const flat_set& __x, const flat_set& __y) { + return ranges::equal(__x, __y); + } + + friend _LIBCPP_HIDE_FROM_ABI auto operator<=>(const flat_set& __x, const flat_set& __y) { + return std::lexicographical_compare_three_way( + __x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way); + } + + friend _LIBCPP_HIDE_FROM_ABI void swap(flat_set& __x, flat_set& __y) noexcept { __x.swap(__y); } + +private: + _LIBCPP_HIDE_FROM_ABI bool __is_sorted_and_unique(auto&& __key_container) const { + auto __greater_or_equal_to = [this](const auto& __x, const auto& __y) { return !__compare_(__x, __y); }; + return ranges::adjacent_find(__key_container, __greater_or_equal_to) == ranges::end(__key_container); + } + + // This function is only used in constructors. So there is not exception handling in this function. + // If the function exits via an exception, there will be no flat_set object constructed, thus, there + // is no invariant state to preserve + _LIBCPP_HIDE_FROM_ABI void __sort_and_unique() { + ranges::sort(__keys_, __compare_); + auto __dup_start = ranges::unique(__keys_, __key_equiv(__compare_)).begin(); + __keys_.erase(__dup_start, __keys_.end()); + } + + template + _LIBCPP_HIDE_FROM_ABI void __append(_InputIterator __first, _InputIterator __last) { + __keys_.insert(__keys_.end(), std::move(__first), std::move(__last)); + } + + template + _LIBCPP_HIDE_FROM_ABI void __append(_Range&& __rng) { + if constexpr (requires { __keys_.insert_range(__keys_.end(), std::forward<_Range>(__rng)); }) { + // C++23 Sequence Container should have insert_range member function + // Note that not all Sequence Containers provide append_range. + __keys_.insert_range(__keys_.end(), std::forward<_Range>(__rng)); + } else if constexpr (ranges::common_range<_Range>) { + __keys_.insert(__keys_.end(), ranges::begin(__rng), ranges::end(__rng)); + } else { + for (auto&& __x : __rng) { + __keys_.insert(__keys_.end(), std::forward(__x)); + } + } + } + + template + _LIBCPP_HIDE_FROM_ABI void __append_sort_merge_unique(_Args&&... __args) { + auto __on_failure = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; }); + size_type __old_size = size(); + __append(std::forward<_Args>(__args)...); + if (size() != __old_size) { + if constexpr (!_WasSorted) { + ranges::sort(__keys_.begin() + __old_size, __keys_.end(), __compare_); + } else { + _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(__is_sorted_and_unique(__keys_ | ranges::views::drop(__old_size)), + "Either the key container is not sorted or it contains duplicates"); + } + ranges::inplace_merge(__keys_.begin(), __keys_.begin() + __old_size, __keys_.end(), __compare_); + + auto __dup_start = ranges::unique(__keys_, __key_equiv(__compare_)).begin(); + __keys_.erase(__dup_start, __keys_.end()); + } + __on_failure.__complete(); + } + + template + _LIBCPP_HIDE_FROM_ABI static auto __find_impl(_Self&& __self, const _Kp& __key) { + auto __it = __self.lower_bound(__key); + auto __last = __self.end(); + if (__it == __last || __self.__compare_(__key, *__it)) { + return __last; + } + return __it; + } + + template + _LIBCPP_HIDE_FROM_ABI static auto __equal_range_impl(_Self&& __self, const _Kp& __key) { + using __iter = _If>, const_iterator, iterator>; + auto __it = ranges::lower_bound(__self.__keys_, __key, __self.__compare_); + auto __last = __self.__keys_.end(); + if (__it == __last || __self.__compare_(__key, *__it)) { + return std::make_pair(__iter(__it), __iter(__it)); + } + return std::make_pair(__iter(__it), __iter(std::next(__it))); + } + + template + _LIBCPP_HIDE_FROM_ABI iterator __emplace_exact_pos(const_iterator __it, _KeyArg&& __key) { + auto __on_failure = std::__make_exception_guard([&]() noexcept { + if constexpr (!__container_traits<_KeyContainer>::__emplacement_has_strong_exception_safety_guarantee) { + clear() /* noexcept */; + } + }); + auto __key_it = __keys_.emplace(__it.__base(), std::forward<_KeyArg>(__key)); + __on_failure.__complete(); + return iterator(std::move(__key_it)); + } + + template + _LIBCPP_HIDE_FROM_ABI pair __emplace(_Kp&& __key) { + auto __it = lower_bound(__key); + if (__it == end() || __compare_(__key, *__it)) { + return pair(__emplace_exact_pos(__it, std::forward<_Kp>(__key)), true); + } else { + return pair(std::move(__it), false); + } + } + + template + _LIBCPP_HIDE_FROM_ABI bool __is_hint_correct(const_iterator __hint, _Kp&& __key) { + if (__hint != cbegin() && !__compare_(*std::prev(__hint), __key)) { + return false; + } + if (__hint != cend() && __compare_(*__hint, __key)) { + return false; + } + return true; + } + + template + _LIBCPP_HIDE_FROM_ABI iterator __emplace_hint(const_iterator __hint, _Kp&& __key) { + if (__is_hint_correct(__hint, __key)) { + if (__hint == cend() || __compare_(__key, *__hint)) { + return __emplace_exact_pos(__hint, std::forward<_Kp>(__key)); + } else { + // we already have an equal key + return __hint; + } + } else { + return __emplace(std::forward<_Kp>(__key)).first; + } + } + + _LIBCPP_HIDE_FROM_ABI void __reserve(size_t __size) { + if constexpr (requires { __keys_.reserve(__size); }) { + __keys_.reserve(__size); + } + } + + template + friend typename flat_set<_Key2, _Compare2, _KeyContainer2>::size_type + erase_if(flat_set<_Key2, _Compare2, _KeyContainer2>&, _Predicate); + + _KeyContainer __keys_; + _LIBCPP_NO_UNIQUE_ADDRESS key_compare __compare_; + + struct __key_equiv { + _LIBCPP_HIDE_FROM_ABI __key_equiv(key_compare __c) : __comp_(__c) {} + _LIBCPP_HIDE_FROM_ABI bool operator()(const_reference __x, const_reference __y) const { + return !__comp_(__x, __y) && !__comp_(__y, __x); + } + key_compare __comp_; + }; +}; + +template > + requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value && + is_invocable_v) +flat_set(_KeyContainer, _Compare = _Compare()) -> flat_set; + +template + requires(uses_allocator_v<_KeyContainer, _Allocator> && !__is_allocator<_KeyContainer>::value) +flat_set(_KeyContainer, _Allocator) + -> flat_set, _KeyContainer>; + +template + requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value && + uses_allocator_v<_KeyContainer, _Allocator> && + is_invocable_v) +flat_set(_KeyContainer, _Compare, _Allocator) -> flat_set; + +template > + requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value && + is_invocable_v) +flat_set(sorted_unique_t, _KeyContainer, _Compare = _Compare()) + -> flat_set; + +template + requires(uses_allocator_v<_KeyContainer, _Allocator> && !__is_allocator<_KeyContainer>::value) +flat_set(sorted_unique_t, _KeyContainer, _Allocator) + -> flat_set, _KeyContainer>; + +template + requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value && + uses_allocator_v<_KeyContainer, _Allocator> && + is_invocable_v) +flat_set(sorted_unique_t, _KeyContainer, _Compare, _Allocator) + -> flat_set; + +template >> + requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator<_Compare>::value) +flat_set(_InputIterator, _InputIterator, _Compare = _Compare()) + -> flat_set<__iter_value_type<_InputIterator>, _Compare>; + +template >> + requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator<_Compare>::value) +flat_set(sorted_unique_t, _InputIterator, _InputIterator, _Compare = _Compare()) + -> flat_set<__iter_value_type<_InputIterator>, _Compare>; + +template >, + class _Allocator = allocator>, + class = __enable_if_t::value && __is_allocator<_Allocator>::value>> +flat_set(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator()) -> flat_set< + ranges::range_value_t<_Range>, + _Compare, + vector, __allocator_traits_rebind_t<_Allocator, ranges::range_value_t<_Range>>>>; + +template ::value>> +flat_set(from_range_t, _Range&&, _Allocator) -> flat_set< + ranges::range_value_t<_Range>, + less>, + vector, __allocator_traits_rebind_t<_Allocator, ranges::range_value_t<_Range>>>>; + +template > + requires(!__is_allocator<_Compare>::value) +flat_set(initializer_list<_Key>, _Compare = _Compare()) -> flat_set<_Key, _Compare>; + +template > + requires(!__is_allocator<_Compare>::value) +flat_set(sorted_unique_t, initializer_list<_Key>, _Compare = _Compare()) -> flat_set<_Key, _Compare>; + +template +struct uses_allocator, _Allocator> + : bool_constant> {}; + +template +_LIBCPP_HIDE_FROM_ABI typename flat_set<_Key, _Compare, _KeyContainer>::size_type +erase_if(flat_set<_Key, _Compare, _KeyContainer>& __flat_set, _Predicate __pred) { + auto __guard = std::__make_exception_guard([&] { __flat_set.clear(); }); + auto __it = std::remove_if(__flat_set.__keys_.begin(), __flat_set.__keys_.end(), [&](const auto& __e) -> bool { + return static_cast(__pred(__e)); + }); + auto __res = __flat_set.__keys_.end() - __it; + __flat_set.__keys_.erase(__it, __flat_set.__keys_.end()); + __guard.__complete(); + return __res; +} + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP_STD_VER >= 23 + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___FLAT_SET_FLAT_SET_H diff --git a/libcxx/include/__flat_set/ra_iterator.h b/libcxx/include/__flat_set/ra_iterator.h new file mode 100644 index 000000000000..6fac62895a0c --- /dev/null +++ b/libcxx/include/__flat_set/ra_iterator.h @@ -0,0 +1,157 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___FLAT_SET_RA_ITERATOR_H +#define _LIBCPP___FLAT_SET_RA_ITERATOR_H + +#include "__type_traits/is_same.h" +#include <__compare/three_way_comparable.h> +#include <__config> +#include <__iterator/incrementable_traits.h> +#include <__iterator/iterator_traits.h> +#include <__type_traits/is_constructible.h> +#include <__utility/move.h> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +#if _LIBCPP_STD_VER >= 23 + +_LIBCPP_BEGIN_NAMESPACE_STD + +/** + * __ra_iterator is a random access iterator that wraps an underlying iterator. + * It also stores the underlying container type in its type so that algorithms + * can optimize based on the underlying container type, and to avoid inadvertently + * mixing iterators coming from different containers.. + */ +template +struct __ra_iterator { +private: + _Iterator __iter_; + + friend _Container; + + // note: checking the concept random_access_iterator does not work for incomplete types + static_assert(_IsSame::iterator_category, random_access_iterator_tag>::value, + "Underlying iterator must be a random access iterator"); + +public: + using iterator_concept = random_access_iterator_tag; // deliberately lower contiguous_iterator + using iterator_category = random_access_iterator_tag; + using value_type = iter_value_t<_Iterator>; + using difference_type = iter_difference_t<_Iterator>; + + _LIBCPP_HIDE_FROM_ABI __ra_iterator() + requires is_default_constructible_v<_Iterator> + = default; + + _LIBCPP_HIDE_FROM_ABI explicit constexpr __ra_iterator(_Iterator __iter) : __iter_(std::move(__iter)) {} + + _LIBCPP_HIDE_FROM_ABI constexpr _Iterator __base() const noexcept(noexcept(_Iterator(__iter_))) { return __iter_; } + + _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator*() const { return *__iter_; } + _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator->() const + requires requires { __iter_.operator->(); } + { + return __iter_.operator->(); + } + + _LIBCPP_HIDE_FROM_ABI constexpr __ra_iterator& operator++() { + ++__iter_; + return *this; + } + + _LIBCPP_HIDE_FROM_ABI constexpr __ra_iterator operator++(int) { + __ra_iterator __tmp(*this); + ++*this; + return __tmp; + } + + _LIBCPP_HIDE_FROM_ABI constexpr __ra_iterator& operator--() { + --__iter_; + return *this; + } + + _LIBCPP_HIDE_FROM_ABI constexpr __ra_iterator operator--(int) { + __ra_iterator __tmp(*this); + --*this; + return __tmp; + } + + _LIBCPP_HIDE_FROM_ABI constexpr __ra_iterator& operator+=(difference_type __x) { + __iter_ += __x; + return *this; + } + + _LIBCPP_HIDE_FROM_ABI constexpr __ra_iterator& operator-=(difference_type __x) { + __iter_ -= __x; + return *this; + } + + _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator[](difference_type __n) const { return *(*this + __n); } + + _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __ra_iterator& __x, const __ra_iterator& __y) { + return __x.__iter_ == __y.__iter_; + } + + _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<(const __ra_iterator& __x, const __ra_iterator& __y) { + return __x.__iter_ < __y.__iter_; + } + + _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>(const __ra_iterator& __x, const __ra_iterator& __y) { + return __y < __x; + } + + _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<=(const __ra_iterator& __x, const __ra_iterator& __y) { + return !(__y < __x); + } + + _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>=(const __ra_iterator& __x, const __ra_iterator& __y) { + return !(__x < __y); + } + + _LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(const __ra_iterator& __x, const __ra_iterator& __y) + requires three_way_comparable<_Iterator> + { + return __x.__iter_ <=> __y.__iter_; + } + + _LIBCPP_HIDE_FROM_ABI friend constexpr __ra_iterator operator+(const __ra_iterator& __i, difference_type __n) { + auto __tmp = __i; + __tmp += __n; + return __tmp; + } + + _LIBCPP_HIDE_FROM_ABI friend constexpr __ra_iterator operator+(difference_type __n, const __ra_iterator& __i) { + return __i + __n; + } + + _LIBCPP_HIDE_FROM_ABI friend constexpr __ra_iterator operator-(const __ra_iterator& __i, difference_type __n) { + auto __tmp = __i; + __tmp -= __n; + return __tmp; + } + + _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const __ra_iterator& __x, const __ra_iterator& __y) { + return __x.__iter_ - __y.__iter_; + } +}; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP_STD_VER >= 23 + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___FLAT_SET_RA_ITERATOR_H diff --git a/libcxx/include/flat_set b/libcxx/include/flat_set new file mode 100644 index 000000000000..d03645fafafd --- /dev/null +++ b/libcxx/include/flat_set @@ -0,0 +1,59 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_FLAT_SET +#define _LIBCPP_FLAT_SET + +/* + Header synopsis + +#include // see [compare.syn] +#include // see [initializer.list.syn] + +namespace std { + // [flat.set], class template flat_set + template, class KeyContainer = vector> + class flat_set; + + struct sorted_unique_t { explicit sorted_unique_t() = default; }; + inline constexpr sorted_unique_t sorted_unique{}; + + template + struct uses_allocator, Allocator>; + + // [flat.set.erasure], erasure for flat_set + template + typename flat_set::size_type + erase_if(flat_set& c, Predicate pred); +} +*/ + +#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS) +# include <__cxx03/__config> +#else +# include <__config> + +# if _LIBCPP_STD_VER >= 23 +# include <__flat_map/sorted_unique.h> +# include <__flat_set/flat_set.h> +# endif + +// for feature-test macros +# include + +// standard required includes +# include +# include + +# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +# endif +#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS) + +#endif // _LIBCPP_FLAT_SET diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap index 82c51ba73e41..1809fe5c7f0f 100644 --- a/libcxx/include/module.modulemap +++ b/libcxx/include/module.modulemap @@ -1296,6 +1296,19 @@ module std [system] { export * } + module flat_set { + module flat_set { + header "__flat_set/flat_set.h" + export std.vector.vector + export std.vector.fwd + } + module ra_iterator { header "__flat_set/ra_iterator.h" } + + header "flat_set" + export std.flat_map.sorted_unique + export * + } + module format { module buffer { header "__format/buffer.h" diff --git a/libcxx/modules/std.compat.cppm.in b/libcxx/modules/std.compat.cppm.in index 5cea1b75bfc1..95931447ccdc 100644 --- a/libcxx/modules/std.compat.cppm.in +++ b/libcxx/modules/std.compat.cppm.in @@ -53,9 +53,6 @@ module; # if __has_include() # error "please update the header information for in headers_not_available in utils/libcxx/header_information.py" # endif // __has_include() -# if __has_include() -# error "please update the header information for in headers_not_available in utils/libcxx/header_information.py" -# endif // __has_include() # if __has_include() # error "please update the header information for in headers_not_available in utils/libcxx/header_information.py" # endif // __has_include() diff --git a/libcxx/modules/std.cppm.in b/libcxx/modules/std.cppm.in index b9d00df70658..5c523691bff4 100644 --- a/libcxx/modules/std.cppm.in +++ b/libcxx/modules/std.cppm.in @@ -65,6 +65,7 @@ module; #include #include #include +#include #include #include #if _LIBCPP_HAS_LOCALIZATION @@ -162,9 +163,6 @@ module; # if __has_include() # error "please update the header information for in headers_not_available in utils/libcxx/header_information.py" # endif // __has_include() -# if __has_include() -# error "please update the header information for in headers_not_available in utils/libcxx/header_information.py" -# endif // __has_include() # if __has_include() # error "please update the header information for in headers_not_available in utils/libcxx/header_information.py" # endif // __has_include() diff --git a/libcxx/modules/std/flat_set.inc b/libcxx/modules/std/flat_set.inc index a86cc1eae02a..3f2c6e09a0eb 100644 --- a/libcxx/modules/std/flat_set.inc +++ b/libcxx/modules/std/flat_set.inc @@ -8,7 +8,7 @@ //===----------------------------------------------------------------------===// export namespace std { -#if 0 +#if _LIBCPP_STD_VER >= 23 // [flat.set], class template flat_­set using std::flat_set; @@ -19,7 +19,9 @@ export namespace std { // [flat.set.erasure], erasure for flat_­set using std::erase_if; +#endif // _LIBCPP_STD_VER >= 23 +#if 0 // [flat.multiset], class template flat_­multiset using std::flat_multiset; diff --git a/libcxx/test/libcxx/containers/container.adaptors/flat.set/assert.sorted_unique.pass.cpp b/libcxx/test/libcxx/containers/container.adaptors/flat.set/assert.sorted_unique.pass.cpp new file mode 100644 index 000000000000..62903af7f4e4 --- /dev/null +++ b/libcxx/test/libcxx/containers/container.adaptors/flat.set/assert.sorted_unique.pass.cpp @@ -0,0 +1,226 @@ +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: has-unix-headers +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 +// UNSUPPORTED: libcpp-hardening-mode=none +// REQUIRES: libcpp-hardening-mode=debug +// XFAIL: libcpp-hardening-mode=debug && availability-verbose_abort-missing + +// + +// flat_set(container_type , const key_compare& __comp = key_compare()) +// flat_set(const container_type& , const _Allocator& ) +// flat_set(const container_type& , const key_compare&, const _Allocator& ) +// void replace(container_type&& ) +// + +#include +#include +#include +#include +#include +#include + +#include "check_assertion.h" + +int main(int, char**) { + using M = std::flat_set; + + TEST_LIBCPP_ASSERT_FAILURE(([] { M m(std::sorted_unique, {2, 2, 3}); }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE(([] { M m(std::sorted_unique, {4, 2, 3}); }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE(([] { M m(std::sorted_unique, {2, 2, 3}, std::less{}); }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE(([] { M m(std::sorted_unique, {4, 2, 3}, std::less{}); }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + const std::vector keys{2, 2, 3}; + const std::allocator alloc{}; + M m(std::sorted_unique, keys, alloc); + }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + const std::vector keys{4, 2, 3}; + const std::allocator alloc{}; + M m(std::sorted_unique, keys, alloc); + }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + const std::vector keys{2, 2, 3}; + const std::allocator alloc{}; + const std::less comp{}; + M m(std::sorted_unique, keys, comp, alloc); + }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + const std::vector keys{4, 2, 3}; + const std::allocator alloc{}; + const std::less comp{}; + M m(std::sorted_unique, keys, comp, alloc); + }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + const std::vector v{2, 2, 3}; + const std::less comp{}; + M m(std::sorted_unique, v.begin(), v.end(), comp); + }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + const std::vector v{4, 2, 3}; + const std::less comp{}; + M m(std::sorted_unique, v.begin(), v.end(), comp); + }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + const std::vector v{2, 2, 3}; + const std::less comp{}; + const std::allocator alloc{}; + M m(std::sorted_unique, v.begin(), v.end(), comp, alloc); + }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + const std::vector v{4, 2, 3}; + const std::less comp{}; + const std::allocator alloc{}; + M m(std::sorted_unique, v.begin(), v.end(), comp, alloc); + }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + const std::vector v{2, 2, 3}; + const std::allocator alloc{}; + M m(std::sorted_unique, v.begin(), v.end(), alloc); + }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + const std::vector v{4, 2, 3}; + const std::allocator alloc{}; + M m(std::sorted_unique, v.begin(), v.end(), alloc); + }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + std::initializer_list v{2, 2, 3}; + const std::less comp{}; + M m(std::sorted_unique, v, comp); + }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + std::initializer_list v{4, 2, 3}; + const std::less comp{}; + M m(std::sorted_unique, v, comp); + }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + std::initializer_list v{2, 2, 3}; + const std::less comp{}; + const std::allocator alloc{}; + M m(std::sorted_unique, v, comp, alloc); + }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + std::initializer_list v{4, 2, 3}; + const std::less comp{}; + const std::allocator alloc{}; + M m(std::sorted_unique, v, comp, alloc); + }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + std::initializer_list v{2, 2, 3}; + const std::allocator alloc{}; + M m(std::sorted_unique, v, alloc); + }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + std::initializer_list v{4, 2, 3}; + const std::allocator alloc{}; + M m(std::sorted_unique, v, alloc); + }()), + "Either the key container is not sorted or it contains duplicates"); + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + const std::vector v{2, 2, 3}; + M m; + m.insert(std::sorted_unique, v.begin(), v.end()); + }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + const std::vector v{4, 2, 3}; + M m; + m.insert(std::sorted_unique, v.begin(), v.end()); + }()), + "Either the key container is not sorted or it contains duplicates"); + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + std::initializer_list v{2, 2, 3}; + M m; + m.insert(std::sorted_unique, v); + }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + std::initializer_list v{4, 2, 3}; + M m; + m.insert(std::sorted_unique, v); + }()), + "Either the key container is not sorted or it contains duplicates"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + std::vector keys{1, 1, 3}; + M m; + m.replace(std::move(keys)); + }()), + "Either the key container is not sorted or it contains duplicates"); + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + std::vector keys{2, 1, 3}; + M m; + m.replace(std::move(keys)); + }()), + "Either the key container is not sorted or it contains duplicates"); + + return 0; +} diff --git a/libcxx/test/libcxx/containers/container.adaptors/flat.set/iterator.compile.pass.cpp b/libcxx/test/libcxx/containers/container.adaptors/flat.set/iterator.compile.pass.cpp new file mode 100644 index 000000000000..f2b3f1a52978 --- /dev/null +++ b/libcxx/test/libcxx/containers/container.adaptors/flat.set/iterator.compile.pass.cpp @@ -0,0 +1,42 @@ +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// test that iterators from different types of flat_set are not compatible + +#include +#include +#include +#include + +using Iter1 = std::flat_set::iterator; +using Iter2 = std::flat_set::iterator; +using Iter3 = std::flat_set>::iterator; +using Iter4 = std::flat_set, std::deque>::iterator; + +static_assert(std::is_convertible_v); +static_assert(!std::is_convertible_v); +static_assert(!std::is_convertible_v); +static_assert(!std::is_convertible_v); + +static_assert(!std::is_convertible_v); +static_assert(std::is_convertible_v); +static_assert(!std::is_convertible_v); +static_assert(!std::is_convertible_v); + +static_assert(!std::is_convertible_v); +static_assert(!std::is_convertible_v); +static_assert(std::is_convertible_v); +static_assert(!std::is_convertible_v); + +static_assert(!std::is_convertible_v); +static_assert(!std::is_convertible_v); +static_assert(!std::is_convertible_v); +static_assert(std::is_convertible_v); diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/empty.verify.cpp b/libcxx/test/libcxx/diagnostics/flat_map.nodiscard.verify.cpp similarity index 100% rename from libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/empty.verify.cpp rename to libcxx/test/libcxx/diagnostics/flat_map.nodiscard.verify.cpp diff --git a/libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.capacity/empty.verify.cpp b/libcxx/test/libcxx/diagnostics/flat_multimap.nodiscard.verify.cpp similarity index 100% rename from libcxx/test/std/containers/container.adaptors/flat.multimap/flat.multimap.capacity/empty.verify.cpp rename to libcxx/test/libcxx/diagnostics/flat_multimap.nodiscard.verify.cpp diff --git a/libcxx/test/libcxx/diagnostics/flat_set.nodiscard.verify.cpp b/libcxx/test/libcxx/diagnostics/flat_set.nodiscard.verify.cpp new file mode 100644 index 000000000000..161fe533eaba --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/flat_set.nodiscard.verify.cpp @@ -0,0 +1,20 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// [[nodiscard]] bool empty() const noexcept; + +#include + +void f() { + std::flat_set c; + c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}} +} diff --git a/libcxx/test/libcxx/transitive_includes/cxx03.csv b/libcxx/test/libcxx/transitive_includes/cxx03.csv index ec5db90597d9..c0031543e47b 100644 --- a/libcxx/test/libcxx/transitive_includes/cxx03.csv +++ b/libcxx/test/libcxx/transitive_includes/cxx03.csv @@ -683,6 +683,14 @@ flat_map initializer_list flat_map limits flat_map type_traits flat_map version +flat_set cmath +flat_set compare +flat_set cstddef +flat_set cstdint +flat_set initializer_list +flat_set limits +flat_set type_traits +flat_set version format algorithm format array format atomic diff --git a/libcxx/test/libcxx/transitive_includes/cxx11.csv b/libcxx/test/libcxx/transitive_includes/cxx11.csv index ec5db90597d9..c0031543e47b 100644 --- a/libcxx/test/libcxx/transitive_includes/cxx11.csv +++ b/libcxx/test/libcxx/transitive_includes/cxx11.csv @@ -683,6 +683,14 @@ flat_map initializer_list flat_map limits flat_map type_traits flat_map version +flat_set cmath +flat_set compare +flat_set cstddef +flat_set cstdint +flat_set initializer_list +flat_set limits +flat_set type_traits +flat_set version format algorithm format array format atomic diff --git a/libcxx/test/libcxx/transitive_includes/cxx14.csv b/libcxx/test/libcxx/transitive_includes/cxx14.csv index 95024df0590b..c2eb5b44e8d7 100644 --- a/libcxx/test/libcxx/transitive_includes/cxx14.csv +++ b/libcxx/test/libcxx/transitive_includes/cxx14.csv @@ -701,6 +701,14 @@ flat_map initializer_list flat_map limits flat_map type_traits flat_map version +flat_set cmath +flat_set compare +flat_set cstddef +flat_set cstdint +flat_set initializer_list +flat_set limits +flat_set type_traits +flat_set version format algorithm format array format atomic diff --git a/libcxx/test/libcxx/transitive_includes/cxx17.csv b/libcxx/test/libcxx/transitive_includes/cxx17.csv index a3518f7f62ec..332cb62f35b5 100644 --- a/libcxx/test/libcxx/transitive_includes/cxx17.csv +++ b/libcxx/test/libcxx/transitive_includes/cxx17.csv @@ -709,6 +709,14 @@ flat_map initializer_list flat_map limits flat_map type_traits flat_map version +flat_set cmath +flat_set compare +flat_set cstddef +flat_set cstdint +flat_set initializer_list +flat_set limits +flat_set type_traits +flat_set version format algorithm format array format atomic diff --git a/libcxx/test/libcxx/transitive_includes/cxx20.csv b/libcxx/test/libcxx/transitive_includes/cxx20.csv index 6de951392794..55c79acff5a8 100644 --- a/libcxx/test/libcxx/transitive_includes/cxx20.csv +++ b/libcxx/test/libcxx/transitive_includes/cxx20.csv @@ -705,6 +705,14 @@ flat_map initializer_list flat_map limits flat_map type_traits flat_map version +flat_set cmath +flat_set compare +flat_set cstddef +flat_set cstdint +flat_set initializer_list +flat_set limits +flat_set type_traits +flat_set version format algorithm format array format atomic diff --git a/libcxx/test/libcxx/transitive_includes/cxx23.csv b/libcxx/test/libcxx/transitive_includes/cxx23.csv index 17972b845374..cb23c7a98de1 100644 --- a/libcxx/test/libcxx/transitive_includes/cxx23.csv +++ b/libcxx/test/libcxx/transitive_includes/cxx23.csv @@ -345,6 +345,19 @@ flat_map optional flat_map stdexcept flat_map tuple flat_map version +flat_set cctype +flat_set climits +flat_set compare +flat_set cstdint +flat_set cstring +flat_set cwchar +flat_set cwctype +flat_set initializer_list +flat_set limits +flat_set optional +flat_set stdexcept +flat_set tuple +flat_set version format array format cctype format cerrno @@ -556,7 +569,6 @@ istream ios istream iosfwd istream limits istream locale - istream ratio istream stdexcept istream streambuf diff --git a/libcxx/test/libcxx/transitive_includes/cxx26.csv b/libcxx/test/libcxx/transitive_includes/cxx26.csv index 00ab78e61a45..c79badd3fa78 100644 --- a/libcxx/test/libcxx/transitive_includes/cxx26.csv +++ b/libcxx/test/libcxx/transitive_includes/cxx26.csv @@ -345,6 +345,19 @@ flat_map optional flat_map stdexcept flat_map tuple flat_map version +flat_set cctype +flat_set climits +flat_set compare +flat_set cstdint +flat_set cstring +flat_set cwchar +flat_set cwctype +flat_set initializer_list +flat_set limits +flat_set optional +flat_set stdexcept +flat_set tuple +flat_set version format array format cctype format cerrno diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.capacity/empty.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.capacity/empty.pass.cpp new file mode 100644 index 000000000000..223b92fc3e8e --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.capacity/empty.pass.cpp @@ -0,0 +1,52 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// [[nodiscard]] bool empty() const noexcept; + +#include +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "test_macros.h" +#include "min_allocator.h" + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set, KeyContainer>; + M m; + ASSERT_SAME_TYPE(decltype(m.empty()), bool); + ASSERT_NOEXCEPT(m.empty()); + assert(m.empty()); + assert(std::as_const(m).empty()); + m = {1}; + assert(!m.empty()); + m.clear(); + assert(m.empty()); +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.capacity/max_size.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.capacity/max_size.pass.cpp new file mode 100644 index 000000000000..dde1f7092e5b --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.capacity/max_size.pass.cpp @@ -0,0 +1,68 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// size_type max_size() const noexcept; + +#include +#include +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "test_allocator.h" +#include "test_macros.h" + +void test() { + { + using A1 = limited_allocator; + using C = std::flat_set, std::vector>; + ASSERT_SAME_TYPE(C::difference_type, std::ptrdiff_t); + ASSERT_SAME_TYPE(C::size_type, std::size_t); + const C c; + ASSERT_NOEXCEPT(c.max_size()); + ASSERT_SAME_TYPE(decltype(c.max_size()), C::size_type); + assert(c.max_size() <= 10); + LIBCPP_ASSERT(c.max_size() == 10); + } + { + using A = limited_allocator; + using C = std::flat_set, std::vector>; + ASSERT_SAME_TYPE(C::difference_type, std::ptrdiff_t); + ASSERT_SAME_TYPE(C::size_type, std::size_t); + const C::size_type max_dist = static_cast(std::numeric_limits::max()); + const C c; + ASSERT_NOEXCEPT(c.max_size()); + ASSERT_SAME_TYPE(decltype(c.max_size()), C::size_type); + assert(c.max_size() <= max_dist); + LIBCPP_ASSERT(c.max_size() == max_dist); + } + { + typedef std::flat_set C; + ASSERT_SAME_TYPE(C::difference_type, std::ptrdiff_t); + ASSERT_SAME_TYPE(C::size_type, std::size_t); + const C::size_type max_dist = static_cast(std::numeric_limits::max()); + const C c; + ASSERT_NOEXCEPT(c.max_size()); + ASSERT_SAME_TYPE(decltype(c.max_size()), C::size_type); + assert(c.max_size() <= max_dist); + assert(c.max_size() <= alloc_max_size(std::allocator())); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.capacity/size.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.capacity/size.pass.cpp new file mode 100644 index 000000000000..9f5ffdd06635 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.capacity/size.pass.cpp @@ -0,0 +1,70 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// size_type size() const noexcept; + +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "test_macros.h" +#include "min_allocator.h" + +template +void test_one() { + using M = std::flat_set, KeyContainer>; + using S = typename M::size_type; + { + const M m = {1, 1, 4, 5, 5}; + ASSERT_SAME_TYPE(decltype(m.size()), S); + ASSERT_NOEXCEPT(m.size()); + assert(m.size() == 3); + } + { + const M m = {1}; + ASSERT_SAME_TYPE(decltype(m.size()), S); + ASSERT_NOEXCEPT(m.size()); + assert(m.size() == 1); + } + { + const M m; + ASSERT_SAME_TYPE(decltype(m.size()), S); + ASSERT_NOEXCEPT(m.size()); + assert(m.size() == 0); + } + { + M m; + S s = 1000000; + for (auto i = 0u; i < s; ++i) { + m.emplace(i); + } + ASSERT_SAME_TYPE(decltype(m.size()), S); + ASSERT_NOEXCEPT(m.size()); + assert(m.size() == s); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/alloc.pass.cpp new file mode 100644 index 000000000000..d14e883dd5e9 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/alloc.pass.cpp @@ -0,0 +1,64 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// template +// explicit flat_set(const Allocator& a); + +#include +#include +#include +#include + +#include "test_macros.h" +#include "test_allocator.h" +#include "../../../test_compare.h" + +void test() { + { + // The constructors in this subclause shall not participate in overload + // resolution unless uses_allocator_v is true. + + using C = test_less; + using A1 = test_allocator; + using A2 = other_allocator; + using V1 = std::vector; + using V2 = std::vector; + using M1 = std::flat_set; + using M2 = std::flat_set; + static_assert(std::is_constructible_v); + static_assert(std::is_constructible_v); + static_assert(!std::is_constructible_v); + static_assert(!std::is_constructible_v); + } + { + // explicit + using M = std::flat_set, std::vector>>; + + static_assert(std::is_constructible_v>); + static_assert(!std::is_convertible_v, M>); + } + { + using A = test_allocator; + using M = std::flat_set, std::vector>>; + M m(A(0, 5)); + assert(m.empty()); + assert(m.begin() == m.end()); + auto v = std::move(m).extract(); + assert(v.get_allocator().get_id() == 5); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/assign_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/assign_initializer_list.pass.cpp new file mode 100644 index 000000000000..ad49b6214903 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/assign_initializer_list.pass.cpp @@ -0,0 +1,61 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// flat_set& operator=(initializer_list il); + +#include +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "test_macros.h" +#include "min_allocator.h" + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set, KeyContainer>; + { + M m = {8, 10}; + assert(m.size() == 2); + std::same_as decltype(auto) r = m = {3, 1, 2, 2, 3, 4, 3, 5, 6, 5}; + assert(&r == &m); + int expected[] = {1, 2, 3, 4, 5, 6}; + assert(std::ranges::equal(m, expected)); + } + { + M m = {10, 8}; + assert(m.size() == 2); + std::same_as decltype(auto) r = m = {3}; + assert(&r == &m); + int expected[] = {3}; + assert(std::ranges::equal(m, expected)); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>(); + test_one>>(); + test_one>>(); +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/compare.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/compare.pass.cpp new file mode 100644 index 000000000000..110757a1bb9a --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/compare.pass.cpp @@ -0,0 +1,87 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// explicit flat_set(const key_compare& comp); +// template +// flat_set(const key_compare& comp, const Alloc& a); + +#include +#include +#include +#include +#include + +#include "test_macros.h" +#include "../../../test_compare.h" +#include "test_allocator.h" + +void test() { + { + // The constructors in this subclause shall not participate in overload + // resolution unless uses_allocator_v is true. + + using C = test_less; + using A1 = test_allocator; + using A2 = other_allocator; + using V1 = std::vector; + using V2 = std::vector; + using M1 = std::flat_set; + using M2 = std::flat_set; + static_assert(std::is_constructible_v); + static_assert(std::is_constructible_v); + static_assert(!std::is_constructible_v); + static_assert(!std::is_constructible_v); + } + { + using C = test_less; + auto m = std::flat_set(C(3)); + assert(m.empty()); + assert(m.begin() == m.end()); + assert(m.key_comp() == C(3)); + } + { + // The one-argument ctor is explicit. + using C = test_less; + static_assert(std::is_constructible_v, C>); + static_assert(!std::is_convertible_v>); + + static_assert(std::is_constructible_v, std::less>); + static_assert(!std::is_convertible_v, std::flat_set>); + } + { + using C = test_less; + using A1 = test_allocator; + auto m = std::flat_set>(C(4), A1(5)); + assert(m.empty()); + assert(m.begin() == m.end()); + assert(m.key_comp() == C(4)); + auto keys = std::move(m).extract(); + assert(keys.get_allocator() == A1(5)); + } + { + // explicit(false) + using C = test_less; + using A1 = test_allocator; + std::flat_set> m = {C(4), A1(5)}; + assert(m.empty()); + assert(m.begin() == m.end()); + assert(m.key_comp() == C(4)); + auto keys = std::move(m).extract(); + assert(keys.get_allocator() == A1(5)); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/containers.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/containers.pass.cpp new file mode 100644 index 000000000000..6b1246885bf5 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/containers.pass.cpp @@ -0,0 +1,157 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// explicit flat_set(container_type key_cont, const key_compare& comp = key_compare()); +// template +// flat_set(const container_type& key_cont, const Allocator& a); +// template +// flat_set(const container_type& key_cont, const key_compare& comp, const Alloc& a); + +#include +#include +#include +#include +#include +#include + +#include "min_allocator.h" +#include "MoveOnly.h" +#include "test_allocator.h" +#include "test_iterators.h" +#include "test_macros.h" +#include "../../../test_compare.h" + +template +void conversion_test(T); + +template +concept ImplicitlyConstructible = requires(Args&&... args) { conversion_test({std::forward(args)...}); }; + +void test() { + { + // The constructors in this subclause shall not participate in overload + // resolution unless uses_allocator_v is true. + + using C = test_less; + using A1 = test_allocator; + using A2 = other_allocator; + using V1 = std::vector; + using V2 = std::vector; + using M1 = std::flat_set; + using M2 = std::flat_set; + static_assert(std::is_constructible_v); + static_assert(std::is_constructible_v); + static_assert(!std::is_constructible_v); + static_assert(!std::is_constructible_v); + + static_assert(std::is_constructible_v); + static_assert(std::is_constructible_v); + static_assert(!std::is_constructible_v); + static_assert(!std::is_constructible_v); + } + { + // flat_set(container_type) + using M = std::flat_set; + std::vector ks = {1, 1, 1, 2, 2, 3, 2, 3, 3}; + auto m = M(ks); + assert(std::ranges::equal(m, std::vector{1, 2, 3})); + + // explicit + static_assert(std::is_constructible_v&>); + static_assert(!ImplicitlyConstructible&>); + } + { + // flat_set(container_type) + // move-only + MoveOnly expected[] = {3, 2, 1}; + using Ks = std::deque>; + using M = std::flat_set, Ks>; + Ks ks; + ks.push_back(1); + ks.push_back(3); + ks.push_back(2); + auto m = M(std::move(ks)); + assert(ks.empty()); // it was moved-from + assert(std::ranges::equal(m, expected)); + } + { + // flat_set(container_type) + // container's allocator is used + using A = test_allocator; + using M = std::flat_set, std::deque>; + auto ks = std::deque({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(5)); + auto m = M(std::move(ks)); + assert(ks.empty()); // it was moved-from + assert((m == M{1, 2, 3})); + auto keys = std::move(m).extract(); + assert(keys.get_allocator() == A(5)); + } + { + // flat_set(container_type , key_compare) + using C = test_less; + using M = std::flat_set; + std::vector ks = {1, 1, 1, 2, 2, 3, 2, 3, 3}; + auto m = M(ks, C(4)); + assert(std::ranges::equal(m, std::vector{1, 2, 3})); + assert(m.key_comp() == C(4)); + + // explicit + static_assert(std::is_constructible_v&, const C&>); + static_assert(!ImplicitlyConstructible&, const C&>); + } + { + // flat_set(container_type , const Allocator&) + using A = test_allocator; + using M = std::flat_set, std::deque>; + auto ks = std::deque({1, 1, 1, 2, 2, 3, 2, 3, 3}, A(5)); + auto m = M(ks, A(4)); // replaces the allocators + assert(!ks.empty()); // it was an lvalue above + assert((m == M{1, 2, 3})); + auto keys = M(m).extract(); + assert(keys.get_allocator() == A(4)); + + // explicit(false) + static_assert(ImplicitlyConstructible&, const A&>); + M m2 = {ks, A(4)}; // implicit ctor + assert(!ks.empty()); // it was an lvalue above + assert(m2 == m); + auto keys2 = std::move(m).extract(); + assert(keys2.get_allocator() == A(4)); + } + { + // flat_set(container_type , key_compare, const Allocator&) + using C = test_less; + using A = test_allocator; + using M = std::flat_set>; + std::vector ks = {1, 1, 1, 2, 2, 3, 2, 3, 3}; + auto m = M(ks, C(4), A(5)); + assert(std::ranges::equal(m, std::vector{1, 2, 3})); + assert(m.key_comp() == C(4)); + auto m_copy = m; + auto keys = std::move(m_copy).extract(); + assert(keys.get_allocator() == A(5)); + + // explicit(false) + static_assert(ImplicitlyConstructible&, const A&>); + M m2 = {ks, C(4), A(5)}; + assert(m2 == m); + assert(m2.key_comp() == C(4)); + keys = std::move(m2).extract(); + assert(keys.get_allocator() == A(5)); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/copy.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/copy.pass.cpp new file mode 100644 index 000000000000..1ba550d98f01 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/copy.pass.cpp @@ -0,0 +1,68 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// flat_set(const flat_set& m); + +#include +#include +#include +#include + +#include "test_macros.h" +#include "../../../test_compare.h" +#include "test_allocator.h" + +void test() { + { + using C = test_less; + std::vector> ks({1, 3, 5}, test_allocator(6)); + using M = std::flat_set; + auto mo = M(ks, C(5)); + auto m = mo; + + assert(m.key_comp() == C(5)); + assert(std::ranges::equal(m, ks)); + auto keys = std::move(m).extract(); + assert(keys.get_allocator() == test_allocator(6)); + + // mo is unchanged + assert(mo.key_comp() == C(5)); + assert(std::ranges::equal(mo, ks)); + auto keys2 = std::move(mo).extract(); + assert(keys2.get_allocator() == test_allocator(6)); + } + { + using C = test_less; + using Ks = std::vector>; + auto ks = Ks({1, 3, 5}, other_allocator(6)); + using M = std::flat_set; + auto mo = M(Ks(ks, other_allocator(6)), C(5)); + auto m = mo; + + assert(m.key_comp() == C(5)); + assert(std::ranges::equal(m, ks)); + auto keys = std::move(m).extract(); + assert(keys.get_allocator() == other_allocator(-2)); + + // mo is unchanged + assert(mo.key_comp() == C(5)); + assert(std::ranges::equal(mo, ks)); + auto keys2 = std::move(mo).extract(); + assert(keys2.get_allocator() == other_allocator(6)); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/copy_alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/copy_alloc.pass.cpp new file mode 100644 index 000000000000..5011bd200306 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/copy_alloc.pass.cpp @@ -0,0 +1,67 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// flat_set(const flat_set&, const allocator_type&); + +#include +#include +#include +#include +#include +#include + +#include "test_macros.h" +#include "../../../test_compare.h" +#include "test_allocator.h" + +void test() { + { + // The constructors in this subclause shall not participate in overload + // resolution unless uses_allocator_v is true. + + using C = test_less; + using A1 = test_allocator; + using A2 = other_allocator; + using V1 = std::vector; + using V2 = std::vector; + using M1 = std::flat_set; + using M2 = std::flat_set; + static_assert(std::is_constructible_v); + static_assert(std::is_constructible_v); + static_assert(!std::is_constructible_v); + static_assert(!std::is_constructible_v); + } + { + using C = test_less; + std::vector> ks({1, 3, 5}, test_allocator(6)); + using M = std::flat_set; + auto mo = M(ks, C(5)); + auto m = M(mo, test_allocator(3)); + + assert(m.key_comp() == C(5)); + assert(std::ranges::equal(m, ks)); + auto keys = std::move(m).extract(); + assert(keys.get_allocator() == test_allocator(3)); + + // mo is unchanged + assert(mo.key_comp() == C(5)); + assert(std::ranges::equal(mo, ks)); + auto keys2 = std::move(mo).extract(); + assert(keys2.get_allocator() == test_allocator(6)); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/copy_assign.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/copy_assign.pass.cpp new file mode 100644 index 000000000000..695363e3aeab --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/copy_assign.pass.cpp @@ -0,0 +1,100 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// flat_set& operator=(const flat_set& m); + +#include +#include +#include +#include + +#include "operator_hijacker.h" +#include "test_macros.h" +#include "../../../test_compare.h" +#include "test_allocator.h" + +void test() { + { + // test_allocator is not propagated + using C = test_less; + std::vector> ks({1, 3, 5}, test_allocator(6)); + using M = std::flat_set; + auto mo = M(ks, C(5)); + auto m = M({{3, 4, 5}}, C(3), test_allocator(2)); + m = mo; + + assert(m.key_comp() == C(5)); + assert(std::ranges::equal(m, ks)); + auto keys = std::move(m).extract(); + assert(keys.get_allocator() == test_allocator(2)); + + // mo is unchanged + assert(mo.key_comp() == C(5)); + assert(std::ranges::equal(mo, ks)); + auto keys2 = std::move(mo).extract(); + assert(keys2.get_allocator() == test_allocator(6)); + } + { + // other_allocator is propagated + using C = test_less; + using Ks = std::vector>; + auto ks = Ks({1, 3, 5}, other_allocator(6)); + using M = std::flat_set; + auto mo = M(Ks(ks, other_allocator(6)), C(5)); + auto m = M({3, 4, 5}, C(3), other_allocator(2)); + m = mo; + + assert(m.key_comp() == C(5)); + assert(std::ranges::equal(m, ks)); + auto keys = std::move(m).extract(); + assert(keys.get_allocator() == other_allocator(6)); + + // mo is unchanged + assert(mo.key_comp() == C(5)); + assert(std::ranges::equal(mo, ks)); + auto keys2 = std::move(mo).extract(); + assert(keys2.get_allocator() == other_allocator(6)); + } + { + // comparator is copied and invariant is preserved + using M = std::flat_set>; + M mo = M({1, 2}, std::less()); + M m = M({1, 2}, std::greater()); + assert(m.key_comp()(2, 1) == true); + assert(m != mo); + m = mo; + assert(m.key_comp()(2, 1) == false); + assert(m == mo); + } + { + // self-assignment + using M = std::flat_set; + M m = {{1, 2}}; + m = static_cast(m); + assert((m == M{{1, 2}})); + } + { + // Validate whether the container can be copy-assigned (move-assigned, swapped) + // with an ADL-hijacking operator& + std::flat_set so; + std::flat_set s; + s = so; + s = std::move(so); + swap(s, so); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/deduct.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/deduct.compile.pass.cpp new file mode 100644 index 000000000000..1161fe6e61c7 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/deduct.compile.pass.cpp @@ -0,0 +1,43 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// Test CTAD on cases where deduction should fail. + +#include +#include +#include +#include +#include + +struct NotAnAllocator { + friend bool operator<(NotAnAllocator, NotAnAllocator) { return false; } +}; + +template +concept CanDeductFlatSet = requires { std::flat_set(std::declval()...); }; + +static_assert(CanDeductFlatSet>); + +// cannot deduce Key and T from nothing +static_assert(!CanDeductFlatSet<>); + +// cannot deduce Key and T from just (Compare) +static_assert(!CanDeductFlatSet>); + +// cannot deduce Key and T from just (Compare, Allocator) +static_assert(!CanDeductFlatSet, std::allocator>); + +// cannot deduce Key and T from just (Allocator) +static_assert(!CanDeductFlatSet>); + +// cannot convert from some arbitrary unrelated type +static_assert(!CanDeductFlatSet); diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/deduct.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/deduct.pass.cpp new file mode 100644 index 000000000000..9d1d2e1f20c8 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/deduct.pass.cpp @@ -0,0 +1,386 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "deduction_guides_sfinae_checks.h" +#include "test_allocator.h" + +void test() { + { + // deduction guide generated from + // flat_set(const flat_set&) + std::flat_set source = {1, 2}; + std::flat_set s(source); + ASSERT_SAME_TYPE(decltype(s), decltype(source)); + assert(s == source); + } + { + // deduction guide generated from + // flat_set(const flat_set&) + std::flat_set> source = {1, 2}; + std::flat_set s{source}; // braces instead of parens + ASSERT_SAME_TYPE(decltype(s), decltype(source)); + assert(s == source); + } + { + // deduction guide generated from + // flat_set(const flat_set&, const Allocator&) + std::flat_set> source = {1, 2}; + std::flat_set s(source, std::allocator()); + ASSERT_SAME_TYPE(decltype(s), decltype(source)); + assert(s == source); + } + + { + // various overloads that takes a container + std::deque> ks({1, 2, 1, INT_MAX, 3}, test_allocator(0, 42)); + std::deque> sorted_ks({1, 2, 3, INT_MAX}, test_allocator(0, 42)); + int expected[] = {1, 2, 3, INT_MAX}; + { + // template> + // flat_set(KeyContainer, Compare = Compare()) + // -> flat_set; + std::flat_set s(ks); + + ASSERT_SAME_TYPE(decltype(s), std::flat_set, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 42); + } + { + // template> + // flat_set(sorted_unique_t, KeyContainer, Compare = Compare()) + // -> flat_set; + std::flat_set s(std::sorted_unique, sorted_ks); + + ASSERT_SAME_TYPE(decltype(s), std::flat_set, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 42); + } + { + // template + // flat_set(KeyContainer, Allocator) + // -> flat_set, KeyContainer>; + std::flat_set s(ks, test_allocator(0, 44)); + + ASSERT_SAME_TYPE(decltype(s), std::flat_set, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 44); + } + { + // template + // flat_set(sorted_unique_t, KeyContainer, Allocator) + // -> flat_set, KeyContainer>; + std::flat_set s(std::sorted_unique, sorted_ks, test_allocator(0, 44)); + + ASSERT_SAME_TYPE(decltype(s), std::flat_set, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 44); + } + } + { + // various overloads that takes a container and a comparator + std::deque> ks({1, 2, 1, INT_MAX, 3}, test_allocator(0, 42)); + std::deque> sorted_ks({INT_MAX, 3, 2, 1}, test_allocator(0, 42)); + int expected[] = {INT_MAX, 3, 2, 1}; + { + // template> + // flat_set(KeyContainer, Compare = Compare()) + // -> flat_set; + std::flat_set s(ks, std::greater()); + + ASSERT_SAME_TYPE(decltype(s), std::flat_set, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 42); + } + { + // template> + // flat_set(sorted_unique_t, KeyContainer, Compare = Compare()) + // -> flat_set; + std::flat_set s(std::sorted_unique, sorted_ks, std::greater()); + + ASSERT_SAME_TYPE(decltype(s), std::flat_set, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 42); + } + { + // template + // flat_set(KeyContainer, Compare, Allocator) + // -> flat_set; + std::flat_set s(ks, std::greater(), test_allocator(0, 44)); + + ASSERT_SAME_TYPE(decltype(s), std::flat_set, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 44); + } + { + // template + // flat_set(sorted_unique_t, KeyContainer, Compare, Allocator) + // -> flat_set; + std::flat_set s(std::sorted_unique, sorted_ks, std::greater(), test_allocator(0, 44)); + + ASSERT_SAME_TYPE(decltype(s), std::flat_set, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 44); + } + } + { + // overloads that take pair of iterators + int arr[] = {1, 2, 1, INT_MAX, 3}; + int sorted_arr[] = {1, 2, 3, INT_MAX}; + const int arrc[] = {1, 2, 1, INT_MAX, 3}; + const int sorted_arrc[] = {1, 2, 3, INT_MAX}; + { + // template>> + // flat_set(InputIterator, InputIterator, Compare = Compare()) + // -> flat_set, Compare>; + std::flat_set m(std::begin(arr), std::end(arr)); + + ASSERT_SAME_TYPE(decltype(m), std::flat_set); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // const + std::flat_set m(std::begin(arrc), std::end(arrc)); + + ASSERT_SAME_TYPE(decltype(m), std::flat_set); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // template>> + // flat_set(sorted_unique_t, InputIterator, InputIterator, Compare = Compare()) + // -> flat_set, Compare>; + std::flat_set m(std::sorted_unique, std::begin(sorted_arr), std::end(sorted_arr)); + + ASSERT_SAME_TYPE(decltype(m), std::flat_set); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // const + std::flat_set m(std::sorted_unique, std::begin(sorted_arrc), std::end(sorted_arrc)); + + ASSERT_SAME_TYPE(decltype(m), std::flat_set); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // from flat_set::iterator + std::flat_set mo; + std::flat_set m(mo.begin(), mo.end()); + ASSERT_SAME_TYPE(decltype(m), decltype(mo)); + } + { + // from flat_set::const_iterator + std::flat_set mo; + std::flat_set m(mo.cbegin(), mo.cend()); + ASSERT_SAME_TYPE(decltype(m), decltype(mo)); + } + { + // This does not deduce to flat_set(InputIterator, InputIterator) + // But deduces to flat_set(initializer_list) + std::flat_set s = {arr, arr + 3}; + ASSERT_SAME_TYPE(decltype(s), std::flat_set); + assert(s.size() == 2); + } + { + // This deduces to flat_set(sorted_unique_t, InputIterator, InputIterator) + std::flat_set s{std::sorted_unique, sorted_arr, sorted_arr + 3}; + static_assert(std::is_same_v>); + assert(s.size() == 3); + } + } + { + // overloads that take pair of iterators and comparator + int arr[] = {1, 2, 1, INT_MAX, 3}; + int sorted_arr[] = {INT_MAX, 3, 2, 1}; + const int arrc[] = {1, 2, 1, INT_MAX, 3}; + const int sorted_arrc[] = {INT_MAX, 3, 2, 1}; + using C = std::greater; + { + // template>> + // flat_set(InputIterator, InputIterator, Compare = Compare()) + // -> flat_set, Compare>; + std::flat_set m(std::begin(arr), std::end(arr), C()); + + ASSERT_SAME_TYPE(decltype(m), std::flat_set); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // const + std::flat_set m(std::begin(arrc), std::end(arrc), C()); + + ASSERT_SAME_TYPE(decltype(m), std::flat_set); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // template>> + // flat_set(sorted_unique_t, InputIterator, InputIterator, Compare = Compare()) + // -> flat_set, Compare>; + std::flat_set m(std::sorted_unique, std::begin(sorted_arr), std::end(sorted_arr), C()); + + ASSERT_SAME_TYPE(decltype(m), std::flat_set); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // const + std::flat_set m(std::sorted_unique, std::begin(sorted_arrc), std::end(sorted_arrc), C()); + + ASSERT_SAME_TYPE(decltype(m), std::flat_set); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // from flat_set::iterator + std::flat_set mo; + std::flat_set m(mo.begin(), mo.end(), C()); + ASSERT_SAME_TYPE(decltype(m), std::flat_set); + } + { + // from flat_set::const_iterator + std::flat_set mo; + std::flat_set m(mo.cbegin(), mo.cend(), C()); + ASSERT_SAME_TYPE(decltype(m), std::flat_set); + } + } + { + // overloads that take an initializer_list + const int sorted_arr[] = {1, 2, 3, INT_MAX}; + { + // template> + // flat_set(initializer_list, Compare = Compare()) + // -> flat_set; + std::flat_set m{1, 2, 1, INT_MAX, 3}; + + ASSERT_SAME_TYPE(decltype(m), std::flat_set); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // template> + // flat_set(sorted_unique_t, initializer_list, Compare = Compare()) + // -> flat_set; + std::flat_set m(std::sorted_unique, {1, 2, 3, INT_MAX}); + + ASSERT_SAME_TYPE(decltype(m), std::flat_set); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // one argument/element of an int -> should be treated as an initializer_list + std::flat_set s = {1}; + ASSERT_SAME_TYPE(decltype(s), std::flat_set); + assert(s.size() == 1); + } + { + // two of the flat_sets -> should be treated as an initializer_list> + using M = std::flat_set; + M m; + std::flat_set s{m, m}; // flat_set(initializer_list) + ASSERT_SAME_TYPE(decltype(s), std::flat_set); + assert(s.size() == 1); + } + } + { + // overloads that take an initializer_list and a comparator + const int sorted_arr[] = {INT_MAX, 3, 2, 1}; + using C = std::greater; + { + // template> + // flat_set(initializer_list, Compare = Compare()) + // -> flat_set; + std::flat_set m({1, 2, 1, INT_MAX, 3}, C()); + + ASSERT_SAME_TYPE(decltype(m), std::flat_set); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // template> + // flat_set(sorted_unique_t, initializer_list, Compare = Compare()) + // -> flat_set; + std::flat_set m(std::sorted_unique, {INT_MAX, 3, 2, 1}, C()); + + ASSERT_SAME_TYPE(decltype(m), std::flat_set); + assert(std::ranges::equal(m, sorted_arr)); + } + } + { + // from_range without comparator + std::list r = {1, 2, 1, INT_MAX, 3}; + const int expected[] = {1, 2, 3, INT_MAX}; + { + // template>, + // class Allocator = allocator>> + // flat_set(from_range_t, R&&, Compare = Compare(), Allocator = Allocator()) + // -> flat_set, Compare, + // vector, + // alloc-rebind>>>; + std::flat_set s(std::from_range, r); + ASSERT_SAME_TYPE(decltype(s), std::flat_set>); + assert(std::ranges::equal(s, expected)); + } + { + // template + // flat_set(from_range_t, R&&, Allocator) + // -> flat_set, less>, + // vector, + // alloc-rebind>>>; + std::flat_set s(std::from_range, r, test_allocator(0, 42)); + ASSERT_SAME_TYPE(decltype(s), std::flat_set, std::vector>>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 42); + } + } + { + // from_range with comparator + std::list r = {1, 2, 1, INT_MAX, 3}; + const int expected[] = {INT_MAX, 3, 2, 1}; + { + // template>, + // class Allocator = allocator>> + // flat_set(from_range_t, R&&, Compare = Compare(), Allocator = Allocator()) + // -> flat_set, Compare, + // vector, + // alloc-rebind>>>; + std::flat_set s(std::from_range, r, std::greater()); + ASSERT_SAME_TYPE(decltype(s), std::flat_set>); + assert(std::ranges::equal(s, expected)); + } + { + // template + // flat_set(from_range_t, R&&, Allocator) + // -> flat_set, less>, + // vector, + // alloc-rebind>>>; + std::flat_set s(std::from_range, r, std::greater(), test_allocator(0, 42)); + ASSERT_SAME_TYPE(decltype(s), std::flat_set, std::vector>>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 42); + } + } + + AssociativeContainerDeductionGuidesSfinaeAway>(); +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/deduct_pmr.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/deduct_pmr.pass.cpp new file mode 100644 index 000000000000..bbb76205677b --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/deduct_pmr.pass.cpp @@ -0,0 +1,104 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 +// UNSUPPORTED: availability-pmr-missing + +// + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "test_allocator.h" + +using P = std::pair; +using PC = std::pair; + +int main(int, char**) { + { + std::deque> ks({1, 2, 1, INT_MAX, 3}, test_allocator(0, 42)); + std::deque> sorted_ks({1, 2, 3, INT_MAX}, test_allocator(0, 42)); + const int expected[] = {1, 2, 3, INT_MAX}; + { + // template + // flat_set(KeyContainer, Allocator) + // -> flat_set, KeyContainer>; + std::pmr::monotonic_buffer_resource mr; + std::pmr::monotonic_buffer_resource mr2; + std::pmr::deque pks(ks.begin(), ks.end(), &mr); + std::flat_set s(std::move(pks), &mr2); + + ASSERT_SAME_TYPE(decltype(s), std::flat_set, std::pmr::deque>); + assert(std::ranges::equal(s, expected)); + auto keys = std::move(s).extract(); + assert(keys.get_allocator().resource() == &mr2); + } + { + // template + // flat_set(sorted_unique_t, KeyContainer, Allocator) + // -> flat_set, KeyContainer>; + std::pmr::monotonic_buffer_resource mr; + std::pmr::monotonic_buffer_resource mr2; + std::pmr::deque pks(sorted_ks.begin(), sorted_ks.end(), &mr); + std::flat_set s(std::sorted_unique, std::move(pks), &mr2); + + ASSERT_SAME_TYPE(decltype(s), std::flat_set, std::pmr::deque>); + assert(std::ranges::equal(s, expected)); + auto keys = std::move(s).extract(); + assert(keys.get_allocator().resource() == &mr2); + } + } + { + std::deque> ks({1, 2, 1, INT_MAX, 3}, test_allocator(0, 42)); + std::deque> sorted_ks({INT_MAX, 3, 2, 1}, test_allocator(0, 42)); + const int expected[] = {INT_MAX, 3, 2, 1}; + { + // template + // flat_set(KeyContainer, Compare, Allocator) + // -> flat_set; + std::pmr::monotonic_buffer_resource mr; + std::pmr::monotonic_buffer_resource mr2; + std::pmr::deque pks(ks.begin(), ks.end(), &mr); + std::flat_set s(std::move(pks), std::greater(), &mr2); + + ASSERT_SAME_TYPE(decltype(s), std::flat_set, std::pmr::deque>); + assert(std::ranges::equal(s, expected)); + auto keys = std::move(s).extract(); + assert(keys.get_allocator().resource() == &mr2); + } + { + // template + // flat_set(sorted_unique_t, KeyContainer, Compare, Allocator) + // -> flat_set; + std::pmr::monotonic_buffer_resource mr; + std::pmr::monotonic_buffer_resource mr2; + std::pmr::deque pks(sorted_ks.begin(), sorted_ks.end(), &mr); + std::flat_set s(std::sorted_unique, std::move(pks), std::greater(), &mr2); + + ASSERT_SAME_TYPE(decltype(s), std::flat_set, std::pmr::deque>); + assert(std::ranges::equal(s, expected)); + auto keys = std::move(s).extract(); + assert(keys.get_allocator().resource() == &mr2); + } + } + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/default.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/default.pass.cpp new file mode 100644 index 000000000000..5cbd557eb856 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/default.pass.cpp @@ -0,0 +1,96 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// flat_set(); + +#include +#include +#include +#include +#include +#include + +#include "min_allocator.h" +#include "MoveOnly.h" +#include "test_allocator.h" +#include "test_macros.h" + +struct DefaultCtableComp { + explicit DefaultCtableComp() { default_constructed_ = true; } + bool operator()(int, int) const { return false; } + bool default_constructed_ = false; +}; + +struct ThrowingCtorComp { + ThrowingCtorComp() noexcept(false) {} + bool operator()(const auto&, const auto&) const { return false; } +}; + +void test() { + { + std::flat_set m; + assert(m.empty()); + } + { + // explicit(false) + std::flat_set m = {}; + assert(m.empty()); + } + { + std::flat_set>> m; + assert(m.empty()); + assert(m.begin() == m.end()); + assert(m.key_comp().default_constructed_); + } + { + using A1 = explicit_allocator; + { + std::flat_set> m; + assert(m.empty()); + assert(m.key_comp().default_constructed_); + } + { + A1 a1; + std::flat_set> m(a1); + assert(m.empty()); + assert(m.key_comp().default_constructed_); + } + } +#if defined(_LIBCPP_VERSION) + { + using C = std::flat_set; + static_assert(std::is_nothrow_default_constructible_v); + C c; + } + { + using C = std::flat_set, std::vector>>; + static_assert(std::is_nothrow_default_constructible_v); + C c; + } +#endif // _LIBCPP_VERSION + { + using C = std::flat_set, std::vector>>; + static_assert(!std::is_nothrow_default_constructible_v); + C c; + } + { + using C = std::flat_set; + static_assert(!std::is_nothrow_default_constructible_v); + C c; + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/dtor_noexcept.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/dtor_noexcept.pass.cpp new file mode 100644 index 000000000000..fa1e2478af45 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/dtor_noexcept.pass.cpp @@ -0,0 +1,61 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// ~flat_set(); + +#include +#include +#include +#include +#include + +#include "test_macros.h" +#include "MoveOnly.h" +#include "test_allocator.h" + +struct ThrowingDtorComp { + bool operator()(const auto&, const auto&) const; + ~ThrowingDtorComp() noexcept(false) {} +}; + +void test() { + { + using C = std::flat_set; + static_assert(std::is_nothrow_destructible_v); + C c; + } + { + using V = std::vector>; + using C = std::flat_set, V>; + static_assert(std::is_nothrow_destructible_v); + C c; + } + { + using V = std::deque>; + using C = std::flat_set, V>; + static_assert(std::is_nothrow_destructible_v); + C c; + } +#if defined(_LIBCPP_VERSION) + { + using C = std::flat_set; + static_assert(!std::is_nothrow_destructible_v); + C c; + } +#endif // _LIBCPP_VERSION +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/initializer_list.pass.cpp new file mode 100644 index 000000000000..9aed5c88ee72 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/initializer_list.pass.cpp @@ -0,0 +1,155 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// flat_set(initializer_list il, const key_compare& comp = key_compare()); +// template +// flat_set(initializer_list il, const Alloc& a); +// template +// flat_set(initializer_list il, const key_compare& comp, const Alloc& a); + +#include +#include +#include +#include +#include +#include + +#include "test_macros.h" +#include "min_allocator.h" +#include "test_allocator.h" + +#include "../../../test_compare.h" + +struct DefaultCtableComp { + explicit DefaultCtableComp() { default_constructed_ = true; } + bool operator()(int, int) const { return false; } + bool default_constructed_ = false; +}; + +void test() { + { + // The constructors in this subclause shall not participate in overload + // resolution unless uses_allocator_v is true. + + using C = test_less; + using A1 = test_allocator; + using A2 = other_allocator; + using V1 = std::vector; + using V2 = std::vector; + using M1 = std::flat_set; + using M2 = std::flat_set; + using IL = std::initializer_list; + static_assert(std::is_constructible_v); + static_assert(std::is_constructible_v); + static_assert(!std::is_constructible_v); + static_assert(!std::is_constructible_v); + + static_assert(std::is_constructible_v); + static_assert(std::is_constructible_v); + static_assert(!std::is_constructible_v); + static_assert(!std::is_constructible_v); + } + + { + // initializer_list needs to match exactly + using M = std::flat_set; + using C = typename M::key_compare; + static_assert(std::is_constructible_v>); + static_assert(std::is_constructible_v, C>); + static_assert(std::is_constructible_v, C, std::allocator>); + static_assert(std::is_constructible_v, std::allocator>); + static_assert(!std::is_constructible_v>); + static_assert(!std::is_constructible_v, C>); + static_assert(!std::is_constructible_v, C, std::allocator>); + static_assert(!std::is_constructible_v, std::allocator>); + static_assert(!std::is_constructible_v>); + static_assert(!std::is_constructible_v, C>); + static_assert(!std::is_constructible_v, C, std::allocator>); + static_assert(!std::is_constructible_v, std::allocator>); + } + + int expected[] = {1, 2, 3, 5}; + { + // flat_set(initializer_list); + using M = std::flat_set; + std::initializer_list il = {5, 2, 2, 3, 1, 3}; + M m(il); + assert(std::equal(m.begin(), m.end(), expected, expected + 4)); + } + { + // flat_set(initializer_list); + // explicit(false) + using M = std::flat_set; + M m = {5, 2, 2, 3, 1, 3}; + assert(std::equal(m.begin(), m.end(), expected, expected + 4)); + } + { + // flat_set(initializer_list); + using M = std::flat_set, std::deque>>; + M m = {5, 2, 2, 3, 1, 3}; + assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4)); + } + { + using A = explicit_allocator; + { + // flat_set(initializer_list); + // different comparator + using M = std::flat_set>; + M m = {1, 2, 3}; + assert(m.size() == 1); + LIBCPP_ASSERT(*m.begin() == 1); + assert(m.key_comp().default_constructed_); + } + { + // flat_set(initializer_list, const Allocator&); + using M = std::flat_set, std::deque>; + A a; + M m({5, 2, 2, 3, 1, 3}, a); + assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4)); + } + } + { + // flat_set(initializer_list, const key_compare&); + using C = test_less; + using M = std::flat_set; + auto m = M({5, 2, 2, 3, 1, 3}, C(10)); + assert(std::equal(m.begin(), m.end(), expected, expected + 4)); + assert(m.key_comp() == C(10)); + + // explicit(false) + M m2 = {{5, 2, 2, 1, 3, 3}, C(10)}; + assert(m2 == m); + assert(m2.key_comp() == C(10)); + } + { + // flat_set(initializer_list, const key_compare&); + // Sorting uses the comparator that was passed in + using M = std::flat_set, std::deque>>; + auto m = M({5, 2, 2, 1, 3, 1}, std::greater()); + assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4)); + assert(m.key_comp()(2, 1) == true); + } + { + // flat_set(initializer_list il, const key_compare& comp, const Alloc& a); + using A = explicit_allocator; + using M = std::flat_set, std::deque>; + A a; + M m({5, 2, 2, 3, 1, 3}, {}, a); + assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4)); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/iter_iter.pass.cpp new file mode 100644 index 000000000000..2d0b07c9155f --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/iter_iter.pass.cpp @@ -0,0 +1,140 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// template +// flat_set(InputIterator first, InputIterator last, const key_compare& comp = key_compare()); +// template +// flat_set(InputIterator first, InputIterator last, const Allocator& a); +// template +// flat_set(InputIterator first, InputIterator last, const key_compare& comp, const Allocator& a); + +#include +#include +#include +#include +#include + +#include "min_allocator.h" +#include "test_allocator.h" +#include "test_iterators.h" +#include "test_macros.h" +#include "../../../test_compare.h" + +void test() { + { + // The constructors in this subclause shall not participate in overload + // resolution unless uses_allocator_v is true. + + using C = test_less; + using A1 = test_allocator; + using A2 = other_allocator; + using V1 = std::vector; + using V2 = std::vector; + using M1 = std::flat_set; + using M2 = std::flat_set; + using Iter1 = typename M1::iterator; + using Iter2 = typename M2::iterator; + static_assert(std::is_constructible_v); + static_assert(std::is_constructible_v); + static_assert(!std::is_constructible_v); + static_assert(!std::is_constructible_v); + + static_assert(std::is_constructible_v); + static_assert(std::is_constructible_v); + static_assert(!std::is_constructible_v); + static_assert(!std::is_constructible_v); + } + + int ar[] = {1, 1, 1, 2, 2, 3, 2, 3, 3}; + int expected[] = {1, 2, 3}; + { + // flat_set(InputIterator , InputIterator) + // cpp17_input_iterator + using M = std::flat_set; + auto m = M(cpp17_input_iterator(ar), cpp17_input_iterator(ar + 9)); + assert(std::ranges::equal(m, expected)); + + // explicit(false) + M m2 = {cpp17_input_iterator(ar), cpp17_input_iterator(ar + 9)}; + assert(m2 == m); + } + { + // flat_set(InputIterator , InputIterator) + // greater + using M = std::flat_set, std::deque>>; + auto m = M(cpp17_input_iterator(ar), cpp17_input_iterator(ar + 9)); + assert(std::ranges::equal(m, std::deque>{3, 2, 1})); + } + { + // flat_set(InputIterator , InputIterator) + // Test when the operands are of array type (also contiguous iterator type) + using M = std::flat_set, std::vector>>; + auto m = M(ar, ar); + assert(m.empty()); + } + { + // flat_set(InputIterator , InputIterator, const key_compare&) + using C = test_less; + using M = std::flat_set>; + auto m = M(ar, ar + 9, C(3)); + assert(std::ranges::equal(m, expected)); + assert(m.key_comp() == C(3)); + + // explicit(false) + M m2 = {ar, ar + 9, C(3)}; + assert(m2 == m); + assert(m2.key_comp() == C(3)); + } + { + // flat_set(InputIterator , InputIterator, const Allocator&) + using A1 = test_allocator; + using M = std::flat_set, std::vector>; + auto m = M(ar, ar + 9, A1(5)); + assert(std::ranges::equal(m, expected)); + assert(std::move(m).extract().get_allocator() == A1(5)); + } + { + // flat_set(InputIterator , InputIterator, const Allocator&) + // explicit(false) + using A1 = test_allocator; + using M = std::flat_set, std::vector>; + M m = {ar, ar + 9, A1(5)}; // implicit ctor + assert(std::ranges::equal(m, expected)); + assert(std::move(m).extract().get_allocator() == A1(5)); + } + { + // flat_set(InputIterator , InputIterator, const key_compare&, const Allocator&) + using C = test_less; + using A1 = test_allocator; + using M = std::flat_set>; + auto m = M(ar, ar + 9, C(3), A1(5)); + assert(std::ranges::equal(m, expected)); + assert(m.key_comp() == C(3)); + assert(std::move(m).extract().get_allocator() == A1(5)); + } + { + // flat_set(InputIterator , InputIterator, const key_compare&, const Allocator&) + // explicit(false) + using A1 = test_allocator; + using M = std::flat_set, std::deque>; + M m = {ar, ar + 9, {}, A1(5)}; // implicit ctor + assert(std::ranges::equal(m, expected)); + LIBCPP_ASSERT(std::ranges::equal(m, expected)); + assert(std::move(m).extract().get_allocator() == A1(5)); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move.pass.cpp new file mode 100644 index 000000000000..e26f8c8f25ce --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move.pass.cpp @@ -0,0 +1,188 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// flat_set(flat_set&&); + +#include +#include +#include +#include +#include +#include + +#include "../helpers.h" +#include "test_macros.h" +#include "../../../test_compare.h" +#include "test_allocator.h" +#include "min_allocator.h" + +void test() { + { + using C = test_less; + using A = test_allocator; + using M = std::flat_set>; + M mo = M({1, 2, 3}, C(5), A(7)); + M m = std::move(mo); + assert((m == M{1, 2, 3})); + assert(m.key_comp() == C(5)); + assert(std::move(m).extract().get_allocator() == A(7)); + + assert(mo.empty()); + assert(mo.key_comp() == C(5)); + assert(std::move(mo).extract().get_allocator().get_id() == test_alloc_base::moved_value); + } + { + using C = test_less; + using A = min_allocator; + using M = std::flat_set>; + M mo = M({1, 2, 3}, C(5), A()); + M m = std::move(mo); + assert((m == M{1, 2, 3})); + assert(m.key_comp() == C(5)); + assert(std::move(m).extract().get_allocator() == A()); + + assert(mo.empty()); + assert(mo.key_comp() == C(5)); + assert(std::move(mo).extract().get_allocator() == A()); + } + { + // A moved-from flat_set maintains its class invariant in the presence of moved-from comparators. + using M = std::flat_set>; + M mo = M({1, 2, 3}, std::less()); + M m = std::move(mo); + assert(m.size() == 3); + assert(std::is_sorted(m.begin(), m.end(), m.value_comp())); + assert(m.key_comp()(1, 2) == true); + + assert(std::is_sorted(mo.begin(), mo.end(), mo.value_comp())); + LIBCPP_ASSERT(m.key_comp()(1, 2) == true); + LIBCPP_ASSERT(mo.empty()); + mo.insert({1, 2, 3}); // insert has no preconditions + assert(m == mo); + } + { + // moved-from object maintains invariant if the underlying container does not clear after move + using M = std::flat_set, CopyOnlyVector>; + M m1 = M({1, 2, 3}); + M m2 = std::move(m1); + assert(m2.size() == 3); + check_invariant(m1); + LIBCPP_ASSERT(m1.empty()); + LIBCPP_ASSERT(m1.size() == 0); + } +} + +template +struct ThrowingMoveAllocator { + using value_type = T; + explicit ThrowingMoveAllocator() = default; + ThrowingMoveAllocator(const ThrowingMoveAllocator&) = default; + ThrowingMoveAllocator(ThrowingMoveAllocator&&) noexcept(false) {} + T* allocate(std::ptrdiff_t n) { return std::allocator().allocate(n); } + void deallocate(T* p, std::ptrdiff_t n) { return std::allocator().deallocate(p, n); } + friend bool operator==(ThrowingMoveAllocator, ThrowingMoveAllocator) = default; +}; + +struct ThrowingMoveComp { + ThrowingMoveComp() = default; + ThrowingMoveComp(const ThrowingMoveComp&) noexcept(true) {} + ThrowingMoveComp(ThrowingMoveComp&&) noexcept(false) {} + bool operator()(const auto&, const auto&) const { return false; } +}; + +struct MoveSensitiveComp { + MoveSensitiveComp() noexcept(false) = default; + MoveSensitiveComp(const MoveSensitiveComp&) noexcept = default; + MoveSensitiveComp(MoveSensitiveComp&& rhs) { rhs.is_moved_from_ = true; } + MoveSensitiveComp& operator=(const MoveSensitiveComp&) noexcept(false) = default; + MoveSensitiveComp& operator=(MoveSensitiveComp&& rhs) { + rhs.is_moved_from_ = true; + return *this; + } + bool operator()(const auto&, const auto&) const { return false; } + bool is_moved_from_ = false; +}; + +void test_move_noexcept() { + { + using C = std::flat_set; + LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible_v); + C c; + C d = std::move(c); + } + { + using C = std::flat_set, std::deque>>; + LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible_v); + C c; + C d = std::move(c); + } +#if _LIBCPP_VERSION + { + // Container fails to be nothrow-move-constructible; this relies on libc++'s support for non-nothrow-copyable allocators + using C = std::flat_set, std::deque>>; + static_assert(!std::is_nothrow_move_constructible_v>>); + static_assert(!std::is_nothrow_move_constructible_v); + C c; + C d = std::move(c); + } +#endif // _LIBCPP_VERSION + { + // Comparator fails to be nothrow-move-constructible + using C = std::flat_set; + static_assert(!std::is_nothrow_move_constructible_v); + C c; + C d = std::move(c); + } +} + +#if !defined(TEST_HAS_NO_EXCEPTIONS) +static int countdown = 0; + +struct EvilContainer : std::vector { + EvilContainer() = default; + EvilContainer(EvilContainer&& rhs) { + // Throw on move-construction. + if (--countdown == 0) { + rhs.insert(rhs.end(), 0); + rhs.insert(rhs.end(), 0); + throw 42; + } + } +}; + +void test_move_exception() { + { + using M = std::flat_set, EvilContainer>; + M mo = {1, 2, 3}; + countdown = 1; + try { + M m = std::move(mo); + assert(false); // not reached + } catch (int x) { + assert(x == 42); + } + // The source flat_set maintains its class invariant. + check_invariant(mo); + LIBCPP_ASSERT(mo.empty()); + } +} +#endif // !defined(TEST_HAS_NO_EXCEPTIONS) + +int main(int, char**) { + test(); + test_move_noexcept(); +#if !defined(TEST_HAS_NO_EXCEPTIONS) + test_move_exception(); +#endif + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_alloc.pass.cpp new file mode 100644 index 000000000000..489b6ff36324 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_alloc.pass.cpp @@ -0,0 +1,79 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// flat_set(flat_set&&, const allocator_type&); + +#include +#include +#include +#include +#include +#include + +#include "../helpers.h" +#include "test_macros.h" +#include "../../../test_compare.h" +#include "test_allocator.h" + +void test() { + { + // The constructors in this subclause shall not participate in overload + // resolution unless uses_allocator_v is true. + + using C = test_less; + using A1 = test_allocator; + using A2 = other_allocator; + using V1 = std::vector; + using V2 = std::vector; + using M1 = std::flat_set; + using M2 = std::flat_set; + static_assert(std::is_constructible_v); + static_assert(std::is_constructible_v); + static_assert(!std::is_constructible_v); + static_assert(!std::is_constructible_v); + } + { + int expected[] = {1, 2, 3}; + using C = test_less; + using A = test_allocator; + using M = std::flat_set>; + auto mo = M(expected, expected + 3, C(5), A(7)); + auto m = M(std::move(mo), A(3)); + + assert(m.key_comp() == C(5)); + assert(m.size() == 3); + auto keys = std::move(m).extract(); + assert(keys.get_allocator() == A(3)); + assert(std::ranges::equal(keys, expected)); + + // The original flat_set is moved-from. + assert(std::is_sorted(mo.begin(), mo.end(), mo.value_comp())); + assert(mo.empty()); + assert(mo.key_comp() == C(5)); + assert(std::move(mo).extract().get_allocator() == A(7)); + } + { + // moved-from object maintains invariant if one of underlying container does not clear after move + using M = std::flat_set, CopyOnlyVector>; + M m1 = M({1, 2, 3}); + M m2(std::move(m1), std::allocator{}); + assert(m2.size() == 3); + check_invariant(m1); + LIBCPP_ASSERT(m1.empty()); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_assign.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_assign.pass.cpp new file mode 100644 index 000000000000..0e0ab0aa135f --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_assign.pass.cpp @@ -0,0 +1,241 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// flat_set& operator=(flat_set&&); + +#include +#include +#include +#include +#include +#include +#include + +#include "test_macros.h" +#include "MoveOnly.h" +#include "../helpers.h" +#include "../../../test_compare.h" +#include "test_allocator.h" +#include "min_allocator.h" + +struct MoveNegates { + int value_ = 0; + MoveNegates() = default; + MoveNegates(int v) : value_(v) {} + MoveNegates(MoveNegates&& rhs) : value_(rhs.value_) { rhs.value_ = -rhs.value_; } + MoveNegates& operator=(MoveNegates&& rhs) { + value_ = rhs.value_; + rhs.value_ = -rhs.value_; + return *this; + } + ~MoveNegates() = default; + auto operator<=>(const MoveNegates&) const = default; +}; + +struct MoveClears { + int value_ = 0; + MoveClears() = default; + MoveClears(int v) : value_(v) {} + MoveClears(MoveClears&& rhs) : value_(rhs.value_) { rhs.value_ = 0; } + MoveClears& operator=(MoveClears&& rhs) { + value_ = rhs.value_; + rhs.value_ = 0; + return *this; + } + ~MoveClears() = default; + auto operator<=>(const MoveClears&) const = default; +}; + +#if !defined(TEST_HAS_NO_EXCEPTIONS) +struct MoveAssignThrows : std::vector { + using std::vector::vector; + MoveAssignThrows& operator=(MoveAssignThrows&& other) { + push_back(0); + push_back(0); + other.push_back(0); + other.push_back(0); + throw 42; + } +}; +#endif // TEST_HAS_NO_EXCEPTIONS + +void test_move_assign_clears() { + // Preserves the class invariant for the moved-from flat_set. + { + const int expected[] = {1, 2, 3, 4, 5, 6, 7, 8}; + using M = std::flat_set>; + M m = M(expected, expected + 8); + M m2 = M(expected, expected + 3); + + m2 = std::move(m); + + assert(std::equal(m2.begin(), m2.end(), expected, expected + 8)); + LIBCPP_ASSERT(m.empty()); + assert(std::is_sorted(m.begin(), m.end(), m.key_comp())); // still sorted + assert(std::adjacent_find(m.begin(), m.end(), m.key_comp()) == m.end()); // still contains no duplicates + m.insert(1); + m.insert(2); + assert(m.contains(1)); + assert(m.find(2) != m.end()); + } + { + const int expected[] = {1, 2, 3, 4, 5, 6, 7, 8}; + using M = std::flat_set>; + M m = M(expected, expected + 8); + M m2 = M(expected, expected + 3); + + m2 = std::move(m); + + assert(std::equal(m2.begin(), m2.end(), expected, expected + 8)); + LIBCPP_ASSERT(m.empty()); + assert(std::is_sorted(m.begin(), m.end(), m.key_comp())); // still sorted + assert(std::adjacent_find(m.begin(), m.end(), m.key_comp()) == m.end()); // still contains no duplicates + m.insert(1); + m.insert(2); + assert(m.contains(1)); + assert(m.find(2) != m.end()); + } + { + // moved-from object maintains invariant if one of underlying container does not clear after move + using M = std::flat_set, std::vector>; + M m1 = M({1, 2, 3}); + M m2 = M({1, 2}); + m2 = std::move(m1); + assert(m2.size() == 3); + check_invariant(m1); + LIBCPP_ASSERT(m1.empty()); + } +#if !defined(TEST_HAS_NO_EXCEPTIONS) + { + using M = std::flat_set, MoveAssignThrows>; + M m1 = {1, 2, 3}; + M m2 = {1, 2}; + try { + m2 = std::move(m1); + assert(false); + } catch (int e) { + assert(e == 42); + } + check_invariant(m1); + check_invariant(m2); + LIBCPP_ASSERT(m1.empty()); + LIBCPP_ASSERT(m2.empty()); + } +#endif // TEST_HAS_NO_EXCEPTIONS +} + +struct MoveSensitiveComp { + MoveSensitiveComp() noexcept(false) = default; + MoveSensitiveComp(const MoveSensitiveComp&) noexcept(false) = default; + MoveSensitiveComp(MoveSensitiveComp&& rhs) { rhs.is_moved_from_ = true; } + MoveSensitiveComp& operator=(const MoveSensitiveComp&) noexcept = default; + MoveSensitiveComp& operator=(MoveSensitiveComp&& rhs) { + rhs.is_moved_from_ = true; + return *this; + } + bool operator()(const auto&, const auto&) const { return false; } + bool is_moved_from_ = false; +}; + +struct MoveThrowsComp { + MoveThrowsComp(MoveThrowsComp&&) noexcept(false); + MoveThrowsComp(const MoveThrowsComp&) noexcept(true); + MoveThrowsComp& operator=(MoveThrowsComp&&) noexcept(false); + MoveThrowsComp& operator=(const MoveThrowsComp&) noexcept(true); + bool operator()(const auto&, const auto&) const; +}; + +void test_move_assign_no_except() { + // This tests a conforming extension + + { + using C = std::flat_set; + LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable_v); + } + { + using C = std::flat_set, std::vector>>; + static_assert(!std::is_nothrow_move_assignable_v); + } + { + using C = std::flat_set, std::vector>>; + static_assert(!std::is_nothrow_move_assignable_v); + } + { + using C = std::flat_set, std::vector>>; + LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable_v); + } + { + using C = std::flat_set, std::vector>>; + LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable_v); + } + { + // Test with a comparator that throws on move-assignment. + using C = std::flat_set; + LIBCPP_STATIC_ASSERT(!std::is_nothrow_move_assignable_v); + } + { + // Test with a container that throws on move-assignment. + using C = std::flat_set, std::pmr::vector>; + static_assert(!std::is_nothrow_move_assignable_v); + } +} + +void test() { + { + using C = test_less; + using A1 = test_allocator; + using M = std::flat_set>; + M mo = M({1, 2, 3}, C(5), A1(7)); + M m = M({}, C(3), A1(7)); + std::same_as decltype(auto) r = m = std::move(mo); + assert(&r == &m); + assert((m == M{1, 2, 3})); + assert(m.key_comp() == C(5)); + auto ks = std::move(m).extract(); + assert(ks.get_allocator() == A1(7)); + assert(mo.empty()); + } + { + using C = test_less; + using A1 = other_allocator; + using M = std::flat_set>; + M mo = M({4, 5}, C(5), A1(7)); + M m = M({1, 2, 3, 4}, C(3), A1(7)); + std::same_as decltype(auto) r = m = std::move(mo); + assert(&r == &m); + assert((m == M{4, 5})); + assert(m.key_comp() == C(5)); + auto ks = std::move(m).extract(); + assert(ks.get_allocator() == A1(7)); + assert(mo.empty()); + } + { + using A = min_allocator; + using M = std::flat_set, std::vector>; + M mo = M({5, 4, 3}, A()); + M m = M({4, 3, 2, 1}, A()); + std::same_as decltype(auto) r = m = std::move(mo); + assert(&r == &m); + assert((m == M{5, 4, 3})); + auto ks = std::move(m).extract(); + assert(ks.get_allocator() == A()); + assert(mo.empty()); + } +} + +int main(int, char**) { + test(); + test_move_assign_clears(); + test_move_assign_no_except(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/pmr.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/pmr.pass.cpp new file mode 100644 index 000000000000..1a4eafa88029 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/pmr.pass.cpp @@ -0,0 +1,326 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 +// UNSUPPORTED: availability-pmr-missing + +// + +// Test various constructors with pmr + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "test_iterators.h" +#include "test_macros.h" +#include "test_allocator.h" +#include "../../../test_compare.h" + +void test() { + { + // flat_set(const Allocator& a); + using M = std::flat_set, std::pmr::vector>; + std::pmr::monotonic_buffer_resource mr; + std::pmr::polymorphic_allocator pa = &mr; + auto m1 = M(pa); + assert(m1.empty()); + assert(std::move(m1).extract().get_allocator() == pa); + auto m2 = M(&mr); + assert(m2.empty()); + assert(std::move(m2).extract().get_allocator() == pa); + } + { + // flat_set(const key_compare& comp, const Alloc& a); + using M = std::flat_set, std::pmr::vector>; + std::pmr::monotonic_buffer_resource mr; + std::pmr::vector vm(&mr); + vm.emplace_back(std::greater()); + assert(vm[0] == M{}); + assert(vm[0].key_comp()(2, 1) == true); + assert(vm[0].value_comp()(2, 1) == true); + assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); + } + { + // flat_set(const key_container_type& key_cont, const mapped_container_type& mapped_cont, + // const Allocator& a); + using M = std::flat_set, std::pmr::vector>; + std::pmr::monotonic_buffer_resource mr; + std::pmr::vector vm(&mr); + std::pmr::vector ks = {1, 1, 1, 2, 2, 3, 2, 3, 3}; + assert(ks.get_allocator().resource() != &mr); + vm.emplace_back(ks); + assert(ks.size() == 9); // ks' value is unchanged, since it was an lvalue above + assert((vm[0] == M{1, 2, 3})); + assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); + } + { + // flat_set(const flat_set&, const allocator_type&); + using C = test_less; + using M = std::flat_set>; + std::pmr::monotonic_buffer_resource mr1; + std::pmr::monotonic_buffer_resource mr2; + M mo = M({1, 2, 3}, C(5), &mr1); + M m = {mo, &mr2}; // also test the implicitness of this constructor + + assert(m.key_comp() == C(5)); + auto keys = std::move(m).extract(); + assert((keys == std::pmr::vector{1, 2, 3})); + assert(keys.get_allocator().resource() == &mr2); + + // mo is unchanged + assert(mo.key_comp() == C(5)); + auto keys2 = std::move(mo).extract(); + assert((keys2 == std::pmr::vector{1, 2, 3})); + assert(keys2.get_allocator().resource() == &mr1); + } + { + // flat_set(const flat_set&, const allocator_type&); + using M = std::flat_set, std::pmr::vector>; + std::pmr::vector vs; + M m = {1, 2, 3}; + vs.push_back(m); + assert(vs[0] == m); + } + { + // flat_set& operator=(const flat_set& m); + // pmr allocator is not propagated + using M = std::flat_set, std::pmr::deque>; + std::pmr::monotonic_buffer_resource mr1; + std::pmr::monotonic_buffer_resource mr2; + M mo = M({1, 2, 3}, &mr1); + M m = M({4, 5}, &mr2); + m = mo; + assert((m == M{1, 2, 3})); + assert(std::move(m).extract().get_allocator().resource() == &mr2); + + // mo is unchanged + assert((mo == M{1, 2, 3})); + assert(std::move(mo).extract().get_allocator().resource() == &mr1); + } + { + // flat_set(const flat_set& m); + using C = test_less; + std::pmr::monotonic_buffer_resource mr; + using M = std::flat_set>; + auto mo = M({1, 2, 3}, C(5), &mr); + auto m = mo; + + assert(m.key_comp() == C(5)); + assert((m == M{1, 2, 3})); + auto ks = std::move(m).extract(); + assert(ks.get_allocator().resource() == std::pmr::get_default_resource()); + + // mo is unchanged + assert(mo.key_comp() == C(5)); + assert((mo == M{1, 2, 3})); + auto kso = std::move(mo).extract(); + assert(kso.get_allocator().resource() == &mr); + } + { + // flat_set(initializer_list il, const Alloc& a); + using M = std::flat_set, std::pmr::vector>; + std::pmr::monotonic_buffer_resource mr; + std::pmr::vector vm(&mr); + std::initializer_list il = {3, 1, 4, 1, 5}; + vm.emplace_back(il); + assert((vm[0] == M{1, 3, 4, 5})); + assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); + } + { + // flat_set(initializer_list il, const key_compare& comp, const Alloc& a); + using C = test_less; + using M = std::flat_set>; + std::pmr::monotonic_buffer_resource mr; + std::pmr::vector vm(&mr); + std::initializer_list il = {3, 1, 4, 1, 5}; + vm.emplace_back(il, C(5)); + assert((vm[0] == M{1, 3, 4, 5})); + assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); + assert(vm[0].key_comp() == C(5)); + } + { + // flat_set(InputIterator first, InputIterator last, const Allocator& a); + int ar[] = {1, 1, 1, 2, 2, 3, 2, 3, 3}; + int expected[] = {1, 2, 3}; + { + // cpp17 iterator + using M = std::flat_set, std::pmr::vector>; + std::pmr::monotonic_buffer_resource mr; + std::pmr::vector vm(&mr); + vm.emplace_back(cpp17_input_iterator(ar), cpp17_input_iterator(ar + 9)); + assert(std::ranges::equal(vm[0], expected)); + assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); + } + { + using M = std::flat_set, std::pmr::vector>; + std::pmr::monotonic_buffer_resource mr; + std::pmr::vector vm(&mr); + vm.emplace_back(ar, ar); + assert(vm[0].empty()); + assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); + } + } + { + // flat_set(flat_set&&, const allocator_type&); + int expected[] = {1, 2, 3}; + using C = test_less; + using M = std::flat_set>; + std::pmr::monotonic_buffer_resource mr1; + std::pmr::monotonic_buffer_resource mr2; + M mo = M({1, 3, 1, 2}, C(5), &mr1); + M m = {std::move(mo), &mr2}; // also test the implicitness of this constructor + + assert(m.key_comp() == C(5)); + assert(m.size() == 3); + assert(std::equal(m.begin(), m.end(), expected, expected + 3)); + assert(std::move(m).extract().get_allocator().resource() == &mr2); + + // The original flat_set is moved-from. + assert(std::is_sorted(mo.begin(), mo.end(), mo.value_comp())); + assert(mo.key_comp() == C(5)); + assert(std::move(mo).extract().get_allocator().resource() == &mr1); + } + { + // flat_set(flat_set&&, const allocator_type&); + using M = std::flat_set, std::pmr::deque>; + std::pmr::vector vs; + M m = {1, 3, 1, 2}; + vs.push_back(std::move(m)); + assert((std::move(vs[0]).extract() == std::pmr::deque{1, 2, 3})); + } + { + // flat_set& operator=(flat_set&&); + using M = std::flat_set, std::pmr::vector>; + std::pmr::monotonic_buffer_resource mr1; + std::pmr::monotonic_buffer_resource mr2; + M mo = + M({"short", "very long string that definitely won't fit in the SSO buffer and therefore becomes empty on move"}, + &mr1); + M m = M({"don't care"}, &mr2); + m = std::move(mo); + assert(m.size() == 2); + assert(std::is_sorted(m.begin(), m.end(), m.value_comp())); + assert(m.begin()->get_allocator().resource() == &mr2); + + assert(std::is_sorted(mo.begin(), mo.end(), mo.value_comp())); + mo.insert("foo"); + assert(mo.begin()->get_allocator().resource() == &mr1); + } + { + // flat_set(from_range_t, R&&, const Alloc&); + int ar[] = {1, 1, 1, 2, 2, 3, 2, 3, 3}; + int expected[] = {1, 2, 3}; + { + // input_range + using M = std::flat_set, std::pmr::vector>; + using Iter = cpp20_input_iterator; + using Sent = sentinel_wrapper; + using R = std::ranges::subrange; + std::pmr::monotonic_buffer_resource mr; + std::pmr::vector vm(&mr); + vm.emplace_back(std::from_range, R(Iter(ar), Sent(Iter(ar + 9)))); + assert(std::ranges::equal(vm[0], expected)); + assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); + } + { + using M = std::flat_set, std::pmr::vector>; + using R = std::ranges::subrange; + std::pmr::monotonic_buffer_resource mr; + std::pmr::vector vm(&mr); + vm.emplace_back(std::from_range, R(ar, ar)); + assert(vm[0].empty()); + assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); + } + } + { + // flat_set(sorted_unique_t, const container_type& key_cont, const Alloc& a); + using M = std::flat_set, std::pmr::vector>; + std::pmr::monotonic_buffer_resource mr; + std::pmr::vector vm(&mr); + std::pmr::vector ks = {1, 2, 4, 10}; + vm.emplace_back(std::sorted_unique, ks); + assert(!ks.empty()); // it was an lvalue above + assert((vm[0] == M{1, 2, 4, 10})); + assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); + } + { + // flat_set(sorted_unique_t, const container_type& key_cont,const Alloc& a); + using M = std::flat_set, std::pmr::vector>; + std::pmr::monotonic_buffer_resource mr; + std::pmr::vector vm(&mr); + std::pmr::vector ks({1, 2, 4, 10}, &mr); + vm.emplace_back(std::sorted_unique, ks); + assert((vm[0] == M{1, 2, 4, 10})); + assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); + } + { + // flat_set(sorted_unique_t, initializer_list il, const Alloc& a); + // cpp_17 + using C = test_less; + using M = std::flat_set>; + std::pmr::monotonic_buffer_resource mr; + std::pmr::vector vm(&mr); + int ar[] = {1, 2, 4, 5}; + vm.emplace_back( + std::sorted_unique, cpp17_input_iterator(ar), cpp17_input_iterator(ar + 4), C(3)); + assert((vm[0] == M{1, 2, 4, 5})); + assert(vm[0].key_comp() == C(3)); + assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); + } + { + // flat_set(sorted_unique_t, initializer_list il, const Alloc& a); + using C = test_less; + using M = std::flat_set>; + std::pmr::monotonic_buffer_resource mr; + std::pmr::vector vm(&mr); + int ar[1] = {42}; + vm.emplace_back(std::sorted_unique, ar, ar, C(4)); + assert(vm[0] == M{}); + assert(vm[0].key_comp() == C(4)); + assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); + } + { + // flat_set(InputIterator first, InputIterator last, const Alloc& a); + // cpp_17 + using C = test_less; + using M = std::flat_set>; + std::pmr::monotonic_buffer_resource mr; + std::pmr::vector vm(&mr); + int ar[] = {1, 2, 4, 5}; + vm.emplace_back( + std::sorted_unique, cpp17_input_iterator(ar), cpp17_input_iterator(ar + 4), C(3)); + assert((vm[0] == M{1, 2, 4, 5})); + assert(vm[0].key_comp() == C(3)); + assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); + } + { + // flat_set(InputIterator first, InputIterator last, const Alloc& a); + using C = test_less; + using M = std::flat_set>; + std::pmr::monotonic_buffer_resource mr; + std::pmr::vector vm(&mr); + int ar[1] = {42}; + vm.emplace_back(std::sorted_unique, ar, ar, C(4)); + assert(vm[0] == M{}); + assert(vm[0].key_comp() == C(4)); + assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/range.pass.cpp new file mode 100644 index 000000000000..bd7b5c12432e --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/range.pass.cpp @@ -0,0 +1,177 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// template R> +// flat_set(from_range_t, R&&) +// template R> +// flat_set(from_range_t, R&&, const key_compare&) +// template R, class Alloc> +// flat_set(from_range_t, R&&, const Alloc&); +// template R, class Alloc> +// flat_set(from_range_t, R&&, const key_compare&, const Alloc&); + +#include +#include +#include +#include +#include +#include + +#include "min_allocator.h" +#include "test_allocator.h" +#include "test_iterators.h" +#include "test_macros.h" +#include "../../../test_compare.h" + +// test constraint container-compatible-range + +template +using RangeOf = std::ranges::subrange; +using Set = std::flat_set; + +static_assert(std::is_constructible_v>); +static_assert(std::is_constructible_v>); +static_assert(!std::is_constructible_v>>); + +static_assert(std::is_constructible_v, std::less>); +static_assert(std::is_constructible_v, std::less>); +static_assert(!std::is_constructible_v>, std::less>); + +static_assert(std::is_constructible_v, std::allocator>); +static_assert(std::is_constructible_v, std::allocator>); +static_assert(!std::is_constructible_v>, std::allocator>); + +static_assert(std::is_constructible_v, std::less, std::allocator>); +static_assert(std::is_constructible_v, std::less, std::allocator>); +static_assert( + !std:: + is_constructible_v>, std::less, std::allocator>); + +void test() { + { + // The constructors in this subclause shall not participate in overload + // resolution unless uses_allocator_v is true. + + using C = test_less; + using A1 = test_allocator; + using A2 = other_allocator; + using V1 = std::vector; + using V2 = std::vector; + using M1 = std::flat_set; + using M2 = std::flat_set; + static_assert(std::is_constructible_v); + static_assert(std::is_constructible_v); + static_assert(!std::is_constructible_v); + static_assert(!std::is_constructible_v); + + static_assert(std::is_constructible_v); + static_assert(std::is_constructible_v); + static_assert(!std::is_constructible_v); + static_assert(!std::is_constructible_v); + } + + int ar[] = {1, 1, 1, 2, 2, 3, 2, 3, 3}; + int expected[] = {1, 2, 3}; + { + // flat_set(from_range_t, R&&) + // input_range && !common + using M = std::flat_set; + using Iter = cpp20_input_iterator; + using Sent = sentinel_wrapper; + using R = std::ranges::subrange; + auto m = M(std::from_range, R(Iter(ar), Sent(Iter(ar + 9)))); + assert(std::ranges::equal(m, expected)); + LIBCPP_ASSERT(std::ranges::equal(m, expected)); + + // explicit(false) + M m2 = {std::from_range, R(Iter(ar), Sent(Iter(ar + 9)))}; + assert(m2 == m); + } + { + // flat_set(from_range_t, R&&) + // greater + using M = std::flat_set, std::deque>>; + using Iter = cpp20_input_iterator; + using Sent = sentinel_wrapper; + using R = std::ranges::subrange; + auto m = M(std::from_range, R(Iter(ar), Sent(Iter(ar + 9)))); + assert(std::ranges::equal(m, std::deque>{3, 2, 1})); + } + { + // flat_set(from_range_t, R&&) + // contiguous range + using M = std::flat_set; + using R = std::ranges::subrange; + auto m = M(std::from_range, R(ar, ar + 9)); + assert(std::ranges::equal(m, expected)); + } + { + // flat_set(from_range_t, R&&, const key_compare&) + using C = test_less; + using M = std::flat_set>; + using R = std::ranges::subrange; + auto m = M(std::from_range, R(ar, ar + 9), C(3)); + assert(std::ranges::equal(m, expected)); + assert(m.key_comp() == C(3)); + + // explicit(false) + M m2 = {std::from_range, R(ar, ar + 9), C(3)}; + assert(m2 == m); + assert(m2.key_comp() == C(3)); + } + { + // flat_set(from_range_t, R&&, const Allocator&) + using A1 = test_allocator; + using M = std::flat_set, std::vector>; + using R = std::ranges::subrange; + auto m = M(std::from_range, R(ar, ar + 9), A1(5)); + assert(std::ranges::equal(m, expected)); + assert(std::move(m).extract().get_allocator() == A1(5)); + } + { + // flat_set(from_range_t, R&&, const Allocator&) + // explicit(false) + using A1 = test_allocator; + using M = std::flat_set, std::deque>; + using R = std::ranges::subrange; + M m = {std::from_range, R(ar, ar + 9), A1(5)}; // implicit ctor + assert(std::ranges::equal(m, expected)); + assert(std::move(m).extract().get_allocator() == A1(5)); + } + { + // flat_set(from_range_t, R&&, const key_compare&, const Allocator&) + using C = test_less; + using A1 = test_allocator; + using M = std::flat_set>; + using R = std::ranges::subrange; + auto m = M(std::from_range, R(ar, ar + 9), C(3), A1(5)); + assert(std::ranges::equal(m, expected)); + assert(m.key_comp() == C(3)); + assert(std::move(m).extract().get_allocator() == A1(5)); + } + { + // flat_set(from_range_t, R&&, const key_compare&, const Allocator&) + // explicit(false) + using A1 = test_allocator; + using M = std::flat_set, std::deque>; + using R = std::ranges::subrange; + M m = {std::from_range, R(ar, ar + 9), {}, A1(5)}; // implicit ctor + assert(std::ranges::equal(m, expected)); + assert(std::move(m).extract().get_allocator() == A1(5)); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/sorted_container.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/sorted_container.pass.cpp new file mode 100644 index 000000000000..873ff32b6293 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/sorted_container.pass.cpp @@ -0,0 +1,147 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// flat_set(sorted_unique_t, container_type key_cont, const key_compare& comp = key_compare()); +// +// template +// flat_set(sorted_unique_t, const container_type& key_cont, const Alloc& a); +// template +// flat_set(sorted_unique_t, const container_type& key_cont, +// const key_compare& comp, const Alloc& a); + +#include +#include +#include +#include + +#include "min_allocator.h" +#include "MoveOnly.h" +#include "test_allocator.h" +#include "test_iterators.h" +#include "test_macros.h" +#include "../../../test_compare.h" + +void test() { + { + // The constructors in this subclause shall not participate in overload + // resolution unless uses_allocator_v is true. + + using C = test_less; + using A1 = test_allocator; + using A2 = other_allocator; + using V1 = std::vector; + using V2 = std::vector; + using M1 = std::flat_set; + using M2 = std::flat_set; + static_assert(std::is_constructible_v); + static_assert(std::is_constructible_v); + static_assert(!std::is_constructible_v); + static_assert(!std::is_constructible_v); + + static_assert(std::is_constructible_v); + static_assert(std::is_constructible_v); + static_assert(!std::is_constructible_v); + static_assert(!std::is_constructible_v); + } + { + // flat_set(sorted_unique_t, container_type) + using M = std::flat_set; + std::vector ks = {1, 2, 4, 10}; + auto ks2 = ks; + + auto m = M(std::sorted_unique, ks); + assert((m == M{1, 2, 4, 10})); + m = M(std::sorted_unique, std::move(ks)); + assert(ks.empty()); // it was moved-from + assert((m == M{1, 2, 4, 10})); + + // explicit(false) + M m2 = {std::sorted_unique, std::move(ks2)}; + assert(m == m2); + } + { + // flat_set(sorted_unique_t, container_type) + // non-default container, comparator and allocator type + using Ks = std::deque>; + using M = std::flat_set, Ks>; + Ks ks = {10, 4, 2, 1}; + auto m = M(std::sorted_unique, ks); + assert((m == M{1, 2, 4, 10})); + m = M(std::sorted_unique, std::move(ks)); + assert(ks.empty()); // it was moved-from + assert((m == M{1, 2, 4, 10})); + } + { + // flat_set(sorted_unique_t, container_type) + // allocator copied into the containers + using A = test_allocator; + using M = std::flat_set, std::deque>; + auto ks = std::deque({1, 2, 4, 10}, A(4)); + auto m = M(std::sorted_unique, std::move(ks)); + assert(ks.empty()); // it was moved-from + assert((m == M{1, 2, 4, 10})); + assert(std::move(m).extract().get_allocator() == A(4)); + } + { + // flat_set(sorted_unique_t, container_type , key_compare) + using C = test_less; + using M = std::flat_set; + std::vector ks = {1, 2, 4, 10}; + + auto m = M(std::sorted_unique, ks, C(4)); + assert((m == M{1, 2, 4, 10})); + assert(m.key_comp() == C(4)); + + // explicit(false) + M m2 = {std::sorted_unique, ks, C(4)}; + assert(m2 == m); + assert(m2.key_comp() == C(4)); + } + { + // flat_set(sorted_unique_t, container_type , key_compare, const Allocator&) + using C = test_less; + using A = test_allocator; + using M = std::flat_set>; + std::vector ks = {1, 2, 4, 10}; + auto m = M(std::sorted_unique, ks, C(4), A(5)); + assert((m == M{1, 2, 4, 10})); + assert(m.key_comp() == C(4)); + assert(M(m).extract().get_allocator() == A(5)); + + // explicit(false) + M m2 = {ks, C(4), A(5)}; + assert(m2 == m); + assert(m2.key_comp() == C(4)); + assert(std::move(m2).extract().get_allocator() == A(5)); + } + { + // flat_set(sorted_unique_t, container_type , const Allocator&) + using A = test_allocator; + using M = std::flat_set, std::deque>; + auto ks = std::deque({1, 2, 4, 10}, A(4)); + auto m = M(std::sorted_unique, ks, A(6)); // replaces the allocators + assert(!ks.empty()); // it was an lvalue above + assert((m == M{1, 2, 4, 10})); + assert(M(m).extract().get_allocator() == A(6)); + + // explicit(false) + M m2 = {std::sorted_unique, ks, A(6)}; + assert(m2 == m); + assert(std::move(m2).extract().get_allocator() == A(6)); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/sorted_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/sorted_initializer_list.pass.cpp new file mode 100644 index 000000000000..a8dac35aefee --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/sorted_initializer_list.pass.cpp @@ -0,0 +1,154 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// template +// flat_set(sorted_unique_t s, initializer_list il, +// const key_compare& comp = key_compare()) +// template +// flat_set(sorted_unique_t, initializer_list il, const Alloc& a); +// template +// flat_set(sorted_unique_t, initializer_list il, +// const key_compare& comp, const Alloc& a); + +#include +#include +#include +#include + +#include "min_allocator.h" +#include "test_allocator.h" +#include "test_iterators.h" +#include "test_macros.h" +#include "../../../test_compare.h" + +template +std::initializer_list il = {1, 2, 4, 5}; + +void test() { + const auto il1 = il; + const auto il2 = il; + + { + // The constructors in this subclause shall not participate in overload + // resolution unless uses_allocator_v is true. + + using C = test_less; + using A1 = test_allocator; + using A2 = other_allocator; + using V1 = std::vector; + using V2 = std::vector; + using M1 = std::flat_set; + using M2 = std::flat_set; + using IL = std::initializer_list; + + static_assert(std::is_constructible_v); + static_assert(std::is_constructible_v); + static_assert(!std::is_constructible_v); + static_assert(!std::is_constructible_v); + + static_assert(std::is_constructible_v); + static_assert(std::is_constructible_v); + static_assert(!std::is_constructible_v); + static_assert(!std::is_constructible_v); + } + { + // initializer_list needs to match exactly + using M = std::flat_set; + using C = typename M::key_compare; + static_assert(std::is_constructible_v>); + static_assert(std::is_constructible_v, C>); + static_assert(std::is_constructible_v, C, std::allocator>); + static_assert(std::is_constructible_v, std::allocator>); + static_assert(!std::is_constructible_v>); + static_assert(!std::is_constructible_v, C>); + static_assert( + !std::is_constructible_v, C, std::allocator>); + static_assert( + !std::is_constructible_v, std::allocator>); + static_assert(!std::is_constructible_v>); + static_assert(!std::is_constructible_v, C>); + static_assert( + !std::is_constructible_v, C, std::allocator>); + static_assert( + !std::is_constructible_v, std::allocator>); + } + + { + // flat_set(sorted_unique_t, initializer_list); + using M = std::flat_set; + auto m = M(std::sorted_unique, il1); + auto expected = M{1, 2, 4, 5}; + assert(m == expected); + + // explicit(false) + M m2 = {std::sorted_unique, il1}; + assert(m2 == m); + } + { + // flat_set(sorted_unique_t, initializer_list, const key_compare&); + using M = std::flat_set>; + auto m = M(std::sorted_unique, il1, std::less()); + assert(m == M({1, 2, 4, 5}, std::less<>())); + assert(m.key_comp()(1, 2) == true); + + // explicit(false) + M m2 = {std::sorted_unique, il1, std::less()}; + assert(m2 == m); + } + { + // flat_set(sorted_unique_t, initializer_list, const key_compare&); + // greater + using M = std::flat_set, std::deque>>; + std::initializer_list il4{5, 4, 2, 1}; + auto m = M(std::sorted_unique, il4, std::greater()); + assert((m == M{5, 4, 2, 1})); + } + { + // flat_set(sorted_unique_t, initializer_list, const Allocator&) + using A1 = test_allocator; + using M = std::flat_set, std::deque>; + auto m = M(std::sorted_unique, il2, A1(5)); + auto expected = M{1, 2, 4, 5}; + assert(m == expected); + assert(M(m).extract().get_allocator() == A1(5)); + + // explicit(false) + M m2 = {std::sorted_unique, il2, A1(5)}; + assert(m2 == m); + assert(std::move(m2).extract().get_allocator() == A1(5)); + } + { + // flat_set(sorted_unique_t, initializer_list, const key_compare&, const Allocator&); + using C = test_less; + using A1 = test_allocator; + using M = std::flat_set>; + auto m = M(std::sorted_unique, il2, C(3), A1(5)); + assert((m == M{1, 2, 4, 5})); + assert(m.key_comp() == C(3)); + assert(std::move(m).extract().get_allocator() == A1(5)); + } + { + // flat_set(sorted_unique_t, initializer_list, const key_compare&, const Allocator&); + // explicit(false) + using A1 = test_allocator; + using M = std::flat_set, std::deque>; + M m = {std::sorted_unique, il2, {}, A1(5)}; // implicit ctor + assert((m == M{1, 2, 4, 5})); + assert(std::move(m).extract().get_allocator() == A1(5)); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/sorted_iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/sorted_iter_iter.pass.cpp new file mode 100644 index 000000000000..b184ee9c3f5a --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/sorted_iter_iter.pass.cpp @@ -0,0 +1,160 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// template +// flat_set(sorted_unique_t, InputIterator first, InputIterator last, const key_compare& comp = key_compare()); +// template +// flat_set(sorted_unique_t, InputIterator first, InputIterator last, const Alloc& a); +// template +// flat_set(sorted_unique_t, InputIterator first, InputIterator last, const key_compare& comp, const Allocator& a); + +#include +#include +#include +#include + +#include "min_allocator.h" +#include "test_allocator.h" +#include "test_iterators.h" +#include "test_macros.h" +#include "../../../test_compare.h" + +void test() { + { + // The constructors in this subclause shall not participate in overload + // resolution unless uses_allocator_v is true. + + using C = test_less; + using A1 = test_allocator; + using A2 = other_allocator; + using V1 = std::vector; + using V2 = std::vector; + using M1 = std::flat_set; + using M2 = std::flat_set; + using Iter1 = typename M1::iterator; + using Iter2 = typename M2::iterator; + static_assert(std::is_constructible_v); + static_assert(std::is_constructible_v); + static_assert(!std::is_constructible_v); + static_assert(!std::is_constructible_v); + + static_assert(std::is_constructible_v); + static_assert(std::is_constructible_v); + static_assert(!std::is_constructible_v); + static_assert(!std::is_constructible_v); + } + { + // flat_set(sorted_unique_t, InputIterator, InputIterator); + // cpp17_input_iterator + using M = std::flat_set; + int ar[] = {1, 2, 4, 5}; + auto m = M(std::sorted_unique, cpp17_input_iterator(ar), cpp17_input_iterator(ar + 4)); + auto expected = M{1, 2, 4, 5}; + assert(m == expected); + + // explicit(false) + M m2 = {std::sorted_unique, cpp17_input_iterator(ar), cpp17_input_iterator(ar + 4)}; + assert(m2 == m); + } + { + // flat_set(sorted_unique_t, InputIterator, InputIterator); + // contiguous iterator + using C = test_less; + using M = std::flat_set>>; + int ar[] = {1, 2, 4, 5}; + auto m = M(std::sorted_unique, ar, ar + 4); + auto expected = M{1, 2, 4, 5}; + assert(m == expected); + } + { + // flat_set(sorted_unique_t, InputIterator, InputIterator, const key_compare&); + // cpp_17_input_iterator + using M = std::flat_set>; + int ar[] = {1, 2, 4, 5}; + auto m = M(std::sorted_unique, + cpp17_input_iterator(ar), + cpp17_input_iterator(ar + 4), + std::less()); + assert(m == M({1, 2, 4, 5}, std::less<>())); + assert(m.key_comp()(1, 2) == true); + + // explicit(false) + M m2 = {std::sorted_unique, + cpp17_input_iterator(ar), + cpp17_input_iterator(ar + 4), + std::less()}; + assert(m2 == m); + } + { + // flat_set(sorted_unique_t, InputIterator, InputIterator, const key_compare&); + // greater + using M = std::flat_set, std::deque>>; + int ar[] = {5, 4, 2, 1}; + auto m = M(std::sorted_unique, + cpp17_input_iterator(ar), + cpp17_input_iterator(ar + 4), + std::greater()); + assert((m == M{5, 4, 2, 1})); + } + { + // flat_set(sorted_unique_t, InputIterator, InputIterator, const key_compare&); + // contiguous iterator + using C = test_less; + using M = std::flat_set>>; + int ar[1] = {42}; + auto m = M(std::sorted_unique, ar, ar, C(5)); + assert(m.empty()); + assert(m.key_comp() == C(5)); + } + { + // flat_set(sorted_unique_t, InputIterator , InputIterator, const Allocator&) + using A1 = test_allocator; + using M = std::flat_set, std::vector>; + int ar[] = {1, 2, 4, 5}; + auto m = M(std::sorted_unique, ar, ar + 4, A1(5)); + auto expected = M{1, 2, 4, 5}; + assert(m == expected); + assert(M(m).extract().get_allocator() == A1(5)); + + // explicit(false) + M m2 = {std::sorted_unique, ar, ar + 4, A1(5)}; + assert(m2 == m); + assert(std::move(m2).extract().get_allocator() == A1(5)); + } + { + // flat_set(sorted_unique_t, InputIterator, InputIterator, const key_compare&, const Allocator&); + using C = test_less; + using A1 = test_allocator; + using M = std::flat_set>; + int ar[] = {1, 2, 4, 5}; + auto m = M(std::sorted_unique, ar, ar + 4, C(3), A1(5)); + assert((m == M{1, 2, 4, 5})); + assert(m.key_comp() == C(3)); + assert(std::move(m).extract().get_allocator() == A1(5)); + } + { + // flat_set(sorted_unique_t, InputIterator, InputIterator, const key_compare&, const Allocator&); + // explicit(false) + using A1 = test_allocator; + using M = std::flat_set, std::deque>; + int ar[] = {1, 2, 4, 5}; + M m = {std::sorted_unique, ar, ar + 4, {}, A1(5)}; // implicit ctor + assert((m == M{1, 2, 4, 5})); + assert(std::move(m).extract().get_allocator() == A1(5)); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.erasure/erase_if.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.erasure/erase_if.pass.cpp new file mode 100644 index 000000000000..d7d7a98f49d7 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.erasure/erase_if.pass.cpp @@ -0,0 +1,101 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// template +// typename flat_set::size_type +// erase_if(flat_set& c, Predicate pred); + +#include +#include +#include +#include +#include + +#include "test_macros.h" +#include "test_allocator.h" +#include "min_allocator.h" + +// Verify that `flat_set` (like `set`) does NOT support std::erase. +// +template +concept HasStdErase = requires(S& s, typename S::value_type x) { std::erase(s, x); }; +static_assert(HasStdErase>); +static_assert(!HasStdErase>); + +template +M make(std::initializer_list vals) { + M ret; + for (int v : vals) + ret.emplace(v); + return ret; +} + +template +void test0( + std::initializer_list vals, Pred p, std::initializer_list expected, std::size_t expected_erased_count) { + M s = make(vals); + ASSERT_SAME_TYPE(typename M::size_type, decltype(std::erase_if(s, p))); + assert(expected_erased_count == std::erase_if(s, p)); + assert(s == make(expected)); +} + +struct NotBool { + bool b; + explicit operator bool() const { return b; } +}; + +template +void test_one() { + // Test all the plausible signatures for this predicate. + auto is1 = [](typename S::const_reference v) { return v == 1; }; + auto is2 = [](typename S::value_type v) { return v == 2; }; + auto is3 = [](const typename S::value_type& v) { return v == 3; }; + auto is4 = [](auto v) { return v == 4; }; + auto True = [](const auto&) { return true; }; + auto False = [](auto&&) { return false; }; + auto nonBoolIs1 = [](const auto& v) { return NotBool{v == 1}; }; + + test0({}, is1, {}, 0); + + test0({1}, is1, {}, 1); + test0({1}, is2, {1}, 0); + + test0({1, 2}, is1, {2}, 1); + test0({1, 2}, is2, {1}, 1); + test0({1, 2}, is3, {1, 2}, 0); + + test0({1, 2, 3}, is1, {2, 3}, 1); + test0({1, 2, 3}, is2, {1, 3}, 1); + test0({1, 2, 3}, is3, {1, 2}, 1); + test0({1, 2, 3}, is4, {1, 2, 3}, 0); + + test0({1, 2, 3}, True, {}, 3); + test0({1, 2, 3}, False, {1, 2, 3}, 0); + + test0({1, 2, 3}, nonBoolIs1, {2, 3}, 1); +} + +void test() { + test_one>(); + test_one, std::vector>>>(); + test_one, std::vector>>>(); + test_one, std::deque>>>(); + test_one, std::deque>>>(); + test_one>(); + test_one>(); +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.erasure/erase_if_exceptions.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.erasure/erase_if_exceptions.pass.cpp new file mode 100644 index 000000000000..37b4a40f0165 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.erasure/erase_if_exceptions.pass.cpp @@ -0,0 +1,133 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 +// UNSUPPORTED: no-exceptions + +// + +// template +// typename flat_set::size_type +// erase_if(flat_set& c, Predicate pred); +// If any member function in [flat.set.defn] exits via an exception, the invariant is restored. +// (This is not a member function, but let's respect the invariant anyway.) + +#include +#include +#include +#include +#include +#include +#include + +#include "../helpers.h" +#include "test_macros.h" + +struct Counter { + int c1, c2, throws; + void tick() { + c1 -= 1; + if (c1 == 0) { + c1 = c2; + throws += 1; + throw 42; + } + } +}; +Counter g_counter = {0, 0, 0}; + +struct ThrowingAssignment { + ThrowingAssignment(int i) : i_(i) {} + ThrowingAssignment(const ThrowingAssignment&) = default; + ThrowingAssignment& operator=(const ThrowingAssignment& rhs) { + g_counter.tick(); + i_ = rhs.i_; + g_counter.tick(); + return *this; + } + operator int() const { return i_; } + int i_; +}; + +struct ThrowingComparator { + bool operator()(const ThrowingAssignment& a, const ThrowingAssignment& b) const { + g_counter.tick(); + return a.i_ < b.i_; + } +}; + +struct ErasurePredicate { + bool operator()(const auto& x) const { return (3 <= x && x <= 5); } +}; + +void test() { + const int expected[] = {1, 2, 3, 4, 5, 6, 7, 8}; + { + using M = std::flat_set; + for (int first_throw = 1; first_throw < 99; ++first_throw) { + for (int second_throw = 1; second_throw < 99; ++second_throw) { + g_counter = {0, 0, 0}; + M m = M({1, 2, 3, 4, 5, 6, 7, 8}); + try { + g_counter = {first_throw, second_throw, 0}; + auto n = std::erase_if(m, ErasurePredicate()); + assert(n == 3); + // If it didn't throw at all, we're done. + g_counter = {0, 0, 0}; + assert((m == M{1, 2, 6, 7, 8})); + first_throw = 99; // "done" + break; + } catch (int ex) { + assert(ex == 42); + check_invariant(m); + LIBCPP_ASSERT(m.empty() || std::equal(m.begin(), m.end(), expected, expected + 8)); + if (g_counter.throws == 1) { + // We reached the first throw but not the second throw. + break; + } + } + } + } + } + + { + using M = std::flat_set>; + for (int first_throw = 1; first_throw < 99; ++first_throw) { + for (int second_throw = 1; second_throw < 99; ++second_throw) { + g_counter = {0, 0, 0}; + std::deque container = {5, 6, 7, 8}; + container.insert(container.begin(), {1, 2, 3, 4}); + M m = M(std::move(container)); + try { + g_counter = {first_throw, second_throw, 0}; + auto n = std::erase_if(m, ErasurePredicate()); + assert(n == 3); + // If it didn't throw at all, we're done. + g_counter = {0, 0, 0}; + assert((m == M{1, 2, 6, 7, 8})); + first_throw = 99; // "done" + break; + } catch (int ex) { + assert(ex == 42); + check_invariant(m); + LIBCPP_ASSERT(m.empty() || std::equal(m.begin(), m.end(), expected, expected + 8)); + if (g_counter.throws == 1) { + // We reached the first throw but not the second throw. + break; + } + } + } + } + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.iterators/iterator.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.iterators/iterator.pass.cpp new file mode 100644 index 000000000000..846bcff63d77 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.iterators/iterator.pass.cpp @@ -0,0 +1,97 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// iterator begin() noexcept; +// const_iterator begin() const noexcept +// iterator end() noexcept; +// const_iterator end() const noexcept; +// +// const_iterator cbegin() const noexcept; +// const_iterator cend() const noexcept; + +#include +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "test_macros.h" +#include "min_allocator.h" + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set, KeyContainer>; + + M m = {1, 2, 3, 4}; + const M& cm = m; + ASSERT_SAME_TYPE(decltype(m.begin()), typename M::iterator); + ASSERT_SAME_TYPE(decltype(m.cbegin()), typename M::const_iterator); + ASSERT_SAME_TYPE(decltype(cm.begin()), typename M::const_iterator); + ASSERT_SAME_TYPE(decltype(m.end()), typename M::iterator); + ASSERT_SAME_TYPE(decltype(m.cend()), typename M::const_iterator); + ASSERT_SAME_TYPE(decltype(cm.end()), typename M::const_iterator); + static_assert(noexcept(m.begin())); + static_assert(noexcept(cm.begin())); + static_assert(noexcept(m.cbegin())); + static_assert(noexcept(m.end())); + static_assert(noexcept(cm.end())); + static_assert(noexcept(m.cend())); + assert(m.size() == 4); + assert(std::distance(m.begin(), m.end()) == 4); + assert(std::distance(cm.begin(), cm.end()) == 4); + assert(std::distance(m.cbegin(), m.cend()) == 4); + typename M::iterator i; // default-construct + i = m.begin(); // move-assignment + typename M::const_iterator k = i; // converting constructor + assert(i == k); // comparison + for (int j = 1; j <= 4; ++j, ++i) { // pre-increment + assert(*i == j); // operator* + } + assert(i == m.end()); + for (int j = 4; j >= 1; --j) { + --i; // pre-decrement + assert((*i) == j); + } + assert(i == m.begin()); +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); + + { + // N3644 testing + using C = std::flat_set; + C::iterator ii1{}, ii2{}; + C::iterator ii4 = ii1; + C::const_iterator cii{}; + assert(ii1 == ii2); + assert(ii1 == ii4); + assert(!(ii1 != ii2)); + + assert((ii1 == cii)); + assert((cii == ii1)); + assert(!(ii1 != cii)); + assert(!(cii != ii1)); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.iterators/iterator_comparison.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.iterators/iterator_comparison.pass.cpp new file mode 100644 index 000000000000..3027cdd4076e --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.iterators/iterator_comparison.pass.cpp @@ -0,0 +1,158 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// flat_set iterators should be C++20 random access iterators + +#include +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "test_macros.h" +#include "min_allocator.h" + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set, KeyContainer>; + using KI = typename KeyContainer::iterator; + using I = M::iterator; + using CI = M::const_iterator; + using RI = M::reverse_iterator; + using CRI = M::const_reverse_iterator; + + static_assert(std::equality_comparable); + static_assert(std::equality_comparable); + static_assert(std::equality_comparable); + static_assert(std::equality_comparable); + + static_assert(std::totally_ordered); + static_assert(std::totally_ordered); + static_assert(std::totally_ordered); + static_assert(std::totally_ordered); + + M m = {1, 2, 3, 4}; + + I i1 = m.begin(); + I i2 = m.begin() + 1; + + assert(i1 == i1); + assert(!(i1 != i1)); + assert(i1 != i2); + assert(!(i1 == i2)); + assert(i1 < i2); + assert(!(i1 < i1)); + assert(i1 <= i1); + assert(i1 <= i2); + assert(!(i2 <= i1)); + assert(i2 > i1); + assert(!(i2 > i2)); + assert(i2 >= i1); + assert(i2 >= i2); + assert(!(i1 >= i2)); + + CI ci1 = m.cbegin(); + CI ci2 = m.cbegin() + 1; + assert(ci1 == ci1); + assert(!(ci1 != ci1)); + assert(ci1 != ci2); + assert(!(ci1 == ci2)); + assert(ci1 < ci2); + assert(!(ci1 < ci1)); + assert(ci1 <= ci1); + assert(ci1 <= ci2); + assert(!(ci2 <= ci1)); + assert(ci2 > ci1); + assert(!(ci2 > ci2)); + assert(ci2 >= ci1); + assert(ci2 >= ci2); + assert(!(ci1 >= ci2)); + + RI ri1 = m.rbegin(); + RI ri2 = m.rbegin() + 1; + assert(ri1 == ri1); + assert(!(ri1 != ri1)); + assert(ri1 != ri2); + assert(!(ri1 == ri2)); + assert(ri1 < ri2); + assert(!(ri1 < ri1)); + assert(ri1 <= ri1); + assert(ri1 <= ri2); + assert(!(ri2 <= ri1)); + assert(ri2 > ri1); + assert(!(ri2 > ri2)); + assert(ri2 >= ri1); + assert(ri2 >= ri2); + assert(!(ri1 >= ri2)); + + CRI cri1 = m.crbegin(); + CRI cri2 = m.crbegin() + 1; + assert(cri1 == cri1); + assert(!(cri1 != cri1)); + assert(cri1 != cri2); + assert(!(cri1 == cri2)); + assert(cri1 < cri2); + assert(!(cri1 < cri1)); + assert(cri1 <= cri1); + assert(cri1 <= cri2); + assert(!(cri2 <= cri1)); + assert(cri2 > cri1); + assert(!(cri2 > cri2)); + assert(cri2 >= cri1); + assert(cri2 >= cri2); + assert(!(cri1 >= cri2)); + + if constexpr (std::three_way_comparable) { + static_assert(std::three_way_comparable); // ...of course the wrapped iterators still support <=>. + static_assert(std::three_way_comparable); + static_assert(std::three_way_comparable); + static_assert(std::three_way_comparable); + static_assert(std::same_as I()), std::strong_ordering>); + static_assert(std::same_as CI()), std::strong_ordering>); + static_assert(std::same_as CI()), std::strong_ordering>); + static_assert(std::same_as RI()), std::strong_ordering>); + static_assert(std::same_as CRI()), std::strong_ordering>); + static_assert(std::same_as CRI()), std::strong_ordering>); + + assert(i1 <=> i1 == std::strong_ordering::equivalent); + assert(i1 <=> i2 == std::strong_ordering::less); + assert(i2 <=> i1 == std::strong_ordering::greater); + + assert(ci1 <=> ci1 == std::strong_ordering::equivalent); + assert(ci1 <=> ci2 == std::strong_ordering::less); + assert(ci2 <=> ci1 == std::strong_ordering::greater); + + assert(ri1 <=> ri1 == std::strong_ordering::equivalent); + assert(ri1 <=> ri2 == std::strong_ordering::less); + assert(ri2 <=> ri1 == std::strong_ordering::greater); + + assert(cri1 <=> cri1 == std::strong_ordering::equivalent); + assert(cri1 <=> cri2 == std::strong_ordering::less); + assert(cri2 <=> cri1 == std::strong_ordering::greater); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.iterators/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.iterators/iterator_concept_conformance.compile.pass.cpp new file mode 100644 index 000000000000..35b45b6e7972 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.iterators/iterator_concept_conformance.compile.pass.cpp @@ -0,0 +1,77 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// iterator, const_iterator, reverse_iterator, const_reverse_iterator + +#include +#include +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "test_macros.h" +#include "min_allocator.h" + +template +void test() { + using Key = typename KeyContainer::value_type; + using C = std::flat_set, KeyContainer>; + using I = C::iterator; + using CI = C::const_iterator; + using RI = C::reverse_iterator; + using CRI = C::const_reverse_iterator; + static_assert(std::random_access_iterator); + static_assert(std::random_access_iterator); + static_assert(std::random_access_iterator); + static_assert(std::random_access_iterator); + static_assert(!std::contiguous_iterator); + static_assert(!std::contiguous_iterator); + static_assert(!std::indirectly_writable>); + static_assert(!std::indirectly_writable>); + static_assert(!std::indirectly_writable>); + static_assert(!std::indirectly_writable>); + static_assert(std::sentinel_for); + static_assert(std::sentinel_for); + static_assert(!std::sentinel_for); + static_assert(!std::sentinel_for); + static_assert(std::sentinel_for); + static_assert(std::sentinel_for); + static_assert(!std::sentinel_for); + static_assert(!std::sentinel_for); + static_assert(!std::sentinel_for); + static_assert(!std::sentinel_for); + static_assert(std::sentinel_for); + static_assert(std::sentinel_for); + static_assert(!std::sentinel_for); + static_assert(!std::sentinel_for); + static_assert(std::sentinel_for); + static_assert(std::sentinel_for); + static_assert(std::indirectly_movable_storable); + static_assert(std::indirectly_movable_storable); + static_assert(std::indirectly_movable_storable); + static_assert(std::indirectly_movable_storable); + + static_assert(std::is_same_v::iterator_category, std::random_access_iterator_tag>); + static_assert(std::is_same_v::iterator_category, std::random_access_iterator_tag>); + static_assert(std::is_same_v::iterator_category, std::random_access_iterator_tag>); + static_assert(std::is_same_v::iterator_category, std::random_access_iterator_tag>); +} + +void test() { + test>(); + test>(); + test>(); + test>>(); +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.iterators/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.iterators/range_concept_conformance.compile.pass.cpp new file mode 100644 index 000000000000..4ec64e706b70 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.iterators/range_concept_conformance.compile.pass.cpp @@ -0,0 +1,52 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +#include +#include +#include +#include +#include +#include +#include +#include "MinSequenceContainer.h" +#include "min_allocator.h" + +template +void test() { + { + using Key = typename KeyContainer::value_type; + using C = std::flat_set, KeyContainer>; + + static_assert(std::same_as, typename C::iterator>); + static_assert(std::ranges::random_access_range); + static_assert(std::ranges::common_range); + static_assert(std::ranges::input_range); + static_assert(!std::ranges::view); + static_assert(std::ranges::sized_range); + static_assert(!std::ranges::borrowed_range); + static_assert(std::ranges::viewable_range); + + static_assert(std::same_as, typename C::const_iterator>); + static_assert(std::ranges::random_access_range); + static_assert(std::ranges::common_range); + static_assert(std::ranges::input_range); + static_assert(!std::ranges::view); + static_assert(std::ranges::sized_range); + static_assert(!std::ranges::borrowed_range); + static_assert(!std::ranges::viewable_range); + } +} + +void test() { + test>(); + test>(); + test>(); + test>>(); +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.iterators/reverse_iterator.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.iterators/reverse_iterator.pass.cpp new file mode 100644 index 000000000000..d1e4cef3de19 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.iterators/reverse_iterator.pass.cpp @@ -0,0 +1,91 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// reverse_iterator rbegin() noexcept; +// const_reverse_iterator rbegin() const noexcept; +// reverse_iterator rend() noexcept; +// const_reverse_iterator rend() const noexcept; +// +// const_reverse_iterator crbegin() const noexcept; +// const_reverse_iterator crend() const noexcept; + +#include +#include +#include +#include +#include +#include + +#include + +#include "test_macros.h" +#include + +void test() { + { + using M = std::flat_set, std::deque>; + M m = {1, 2, 3, 4}; + const M& cm = m; + ASSERT_SAME_TYPE(decltype(m.rbegin()), M::reverse_iterator); + ASSERT_SAME_TYPE(decltype(m.crbegin()), M::const_reverse_iterator); + ASSERT_SAME_TYPE(decltype(cm.rbegin()), M::const_reverse_iterator); + ASSERT_SAME_TYPE(decltype(m.rend()), M::reverse_iterator); + ASSERT_SAME_TYPE(decltype(m.crend()), M::const_reverse_iterator); + ASSERT_SAME_TYPE(decltype(cm.rend()), M::const_reverse_iterator); + static_assert(noexcept(m.rbegin())); + static_assert(noexcept(cm.rbegin())); + static_assert(noexcept(m.crbegin())); + static_assert(noexcept(m.rend())); + static_assert(noexcept(cm.rend())); + static_assert(noexcept(m.crend())); + assert(m.size() == 4); + assert(std::distance(m.rbegin(), m.rend()) == 4); + assert(std::distance(cm.rbegin(), cm.rend()) == 4); + assert(std::distance(m.crbegin(), m.crend()) == 4); + assert(std::distance(cm.crbegin(), cm.crend()) == 4); + M::reverse_iterator i; // default-construct + ASSERT_SAME_TYPE(decltype(*i), const int&); + i = m.rbegin(); // move-assignment + M::const_reverse_iterator k = i; // converting constructor + assert(i == k); // comparison + for (int j = 4; j >= 1; --j, ++i) { // pre-increment + assert(*i == j); + } + assert(i == m.rend()); + for (int j = 1; j <= 4; ++j) { + --i; // pre-decrement + assert(*i == j); + } + assert(i == m.rbegin()); + } + { + // N3644 testing + using C = std::flat_set; + C::reverse_iterator ii1{}, ii2{}; + C::reverse_iterator ii4 = ii1; + C::const_reverse_iterator cii{}; + assert(ii1 == ii2); + assert(ii1 == ii4); + assert(!(ii1 != ii2)); + + assert((ii1 == cii)); + assert((cii == ii1)); + assert(!(ii1 != cii)); + assert(!(cii != ii1)); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/clear.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/clear.pass.cpp new file mode 100644 index 000000000000..5ecdc429b3c5 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/clear.pass.cpp @@ -0,0 +1,74 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// class flat_set + +// void clear() noexcept; + +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "../helpers.h" +#include "test_macros.h" +#include "min_allocator.h" + +// test noexcept + +template +concept NoExceptClear = requires(T t) { + { t.clear() } noexcept; +}; + +static_assert(NoExceptClear>); +#ifndef TEST_HAS_NO_EXCEPTIONS +static_assert(NoExceptClear, ThrowOnMoveContainer>>); +#endif + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set, KeyContainer>; + { + M m = {1, 2, 3, 4, 5}; + assert(m.size() == 5); + ASSERT_NOEXCEPT(m.clear()); + ASSERT_SAME_TYPE(decltype(m.clear()), void); + m.clear(); + assert(m.size() == 0); + } + { + // was empty + M m; + assert(m.size() == 0); + m.clear(); + assert(m.size() == 0); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>(); + test_one>>(); + test_one>>(); +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/emplace.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/emplace.pass.cpp new file mode 100644 index 000000000000..79800e894afb --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/emplace.pass.cpp @@ -0,0 +1,146 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// template +// pair emplace(Args&&... args); + +#include +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "../helpers.h" +#include "test_macros.h" +#include "../../../Emplaceable.h" +#include "DefaultOnly.h" +#include "min_allocator.h" + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set, KeyContainer>; + using R = std::pair; + { + // was empty + M m; + std::same_as decltype(auto) r = m.emplace(typename M::value_type(2)); + assert(r.second); + assert(r.first == m.begin()); + assert(m.size() == 1); + assert(*r.first == 2); + } + { + // key does not exist and inserted at the begin + M m = {3, 5, 6, 7}; + std::same_as decltype(auto) r = m.emplace(typename M::value_type(2)); + assert(r.second); + assert(r.first == m.begin()); + assert(m.size() == 5); + assert(*r.first == 2); + } + { + // key does not exist and inserted in the middle + M m = {0, 1, 3, 4}; + std::same_as decltype(auto) r = m.emplace(typename M::value_type(2)); + assert(r.second); + assert(r.first == m.begin() + 2); + assert(m.size() == 5); + assert(*r.first == 2); + } + { + // key does not exist and inserted at the end + M m = {0, 1}; + std::same_as decltype(auto) r = m.emplace(typename M::value_type(2)); + assert(r.second); + assert(r.first == m.begin() + 2); + assert(m.size() == 3); + assert(*r.first == 2); + } + { + // key already exists and original at the begin + M m = {2, 3, 5, 6}; + std::same_as decltype(auto) r = m.emplace(typename M::value_type(2)); + assert(!r.second); + assert(r.first == m.begin()); + assert(m.size() == 4); + assert(*r.first == 2); + } + { + // key already exists and original in the middle + M m = {0, 2, 3, 4}; + std::same_as decltype(auto) r = m.emplace(typename M::value_type(2)); + assert(!r.second); + assert(r.first == m.begin() + 1); + assert(m.size() == 4); + assert(*r.first == 2); + } + { + // key already exists and original at the end + M m = {0, 1, 2}; + std::same_as decltype(auto) r = m.emplace(typename M::value_type(2)); + assert(!r.second); + assert(r.first == m.begin() + 2); + assert(m.size() == 3); + assert(*r.first == 2); + } +} + +template +void test_emplaceable() { + using M = std::flat_set, KeyContainer>; + using R = std::pair; + + M m; + ASSERT_SAME_TYPE(decltype(m.emplace()), R); + R r = m.emplace(2, 0.0); + assert(r.second); + assert(r.first == m.begin()); + assert(m.size() == 1); + assert(*m.begin() == Emplaceable(2, 0.0)); + r = m.emplace(1, 3.5); + assert(r.second); + assert(r.first == m.begin()); + assert(m.size() == 2); + assert(*m.begin() == Emplaceable(1, 3.5)); + r = m.emplace(1, 3.5); + assert(!r.second); + assert(r.first == m.begin()); + assert(m.size() == 2); + assert(*m.begin() == Emplaceable(1, 3.5)); +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); + + test_emplaceable>(); + test_emplaceable>(); + test_emplaceable>(); + test_emplaceable>>(); +} + +void test_exception() { + auto emplace_func = [](auto& m, auto key_arg) { m.emplace(key_arg); }; + test_emplace_exception_guarantee(emplace_func); +} + +int main(int, char**) { + test(); + test_exception(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/emplace_hint.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/emplace_hint.pass.cpp new file mode 100644 index 000000000000..b3bd8adf0c35 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/emplace_hint.pass.cpp @@ -0,0 +1,159 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// template +// iterator emplace_hint(const_iterator position, Args&&... args); + +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "test_macros.h" +#include "../../../Emplaceable.h" +#include "DefaultOnly.h" +#include "min_allocator.h" +#include "../helpers.h" + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set, KeyContainer>; + using R = M::iterator; + { + // was empty + M m; + std::same_as decltype(auto) r = m.emplace_hint(m.end(), typename M::value_type(2)); + assert(r == m.begin()); + assert(m.size() == 1); + assert(*r == 2); + } + { + // hints correct at the begin + M m = {3, 4}; + auto hint = m.begin(); + std::same_as decltype(auto) r = m.emplace_hint(hint, typename M::value_type(2)); + assert(r == m.begin()); + assert(m.size() == 3); + assert(*r == 2); + } + { + // hints correct in the middle + M m = {0, 1, 3, 4}; + auto hint = m.begin() + 2; + std::same_as decltype(auto) r = m.emplace_hint(hint, typename M::value_type(2)); + assert(r == m.begin() + 2); + assert(m.size() == 5); + assert(*r == 2); + } + { + // hints correct at the end + M m = {0, 1}; + auto hint = m.end(); + std::same_as decltype(auto) r = m.emplace_hint(hint, typename M::value_type(2)); + assert(r == m.begin() + 2); + assert(m.size() == 3); + assert(*r == 2); + } + { + // hints correct but key already exists + M m = {0, 1, 2, 3, 4}; + auto hint = m.begin() + 2; + std::same_as decltype(auto) r = m.emplace_hint(hint, typename M::value_type(2)); + assert(r == m.begin() + 2); + assert(m.size() == 5); + assert(*r == 2); + } + { + // hints incorrectly at the begin + M m = {1, 4}; + auto hint = m.begin(); + std::same_as decltype(auto) r = m.emplace_hint(hint, typename M::value_type(2)); + assert(r == m.begin() + 1); + assert(m.size() == 3); + assert(*r == 2); + } + { + // hints incorrectly in the middle + M m = {0, 1, 3, 4}; + auto hint = m.begin() + 1; + std::same_as decltype(auto) r = m.emplace_hint(hint, typename M::value_type(2)); + assert(r == m.begin() + 2); + assert(m.size() == 5); + assert(*r == 2); + } + { + // hints incorrectly at the end + M m = {0, 3}; + auto hint = m.end(); + std::same_as decltype(auto) r = m.emplace_hint(hint, typename M::value_type(2)); + assert(r == m.begin() + 1); + assert(m.size() == 3); + assert(*r == 2); + } + { + // hints incorrect and key already exists + M m = {0, 1, 2, 3, 4}; + auto hint = m.begin(); + std::same_as decltype(auto) r = m.emplace_hint(hint, typename M::value_type(2)); + assert(r == m.begin() + 2); + assert(m.size() == 5); + assert(*r == 2); + } +} + +template +void test_emplaceable() { + using M = std::flat_set, KeyContainer>; + using R = M::iterator; + + M m; + ASSERT_SAME_TYPE(decltype(m.emplace_hint(m.cbegin())), R); + R r = m.emplace_hint(m.end(), 2, 0.0); + assert(r == m.begin()); + assert(m.size() == 1); + assert(*m.begin() == Emplaceable(2, 0.0)); + r = m.emplace_hint(m.end(), 1, 3.5); + assert(r == m.begin()); + assert(m.size() == 2); + assert(*m.begin() == Emplaceable(1, 3.5)); + r = m.emplace_hint(m.end(), 1, 3.5); + assert(r == m.begin()); + assert(m.size() == 2); + assert(*m.begin() == Emplaceable(1, 3.5)); +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); + + test_emplaceable>(); + test_emplaceable>(); + test_emplaceable>(); + test_emplaceable>>(); +} + +void test_exception() { + auto emplace_func = [](auto& m, auto key_arg) { m.emplace_hint(m.begin(), key_arg); }; + test_emplace_exception_guarantee(emplace_func); +} + +int main(int, char**) { + test(); + test_exception(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/erase_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/erase_iter.pass.cpp new file mode 100644 index 000000000000..27c6fadb5341 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/erase_iter.pass.cpp @@ -0,0 +1,114 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// iterator erase(iterator position); +// iterator erase(const_iterator position); + +#include +#include +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "../helpers.h" +#include "test_macros.h" +#include "min_allocator.h" + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set, KeyContainer>; + using I = M::iterator; + + int ar[] = { + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + }; + M m(ar, ar + sizeof(ar) / sizeof(ar[0])); + + auto make = [](std::initializer_list il) { + M m2; + for (int i : il) { + m2.emplace(i); + } + return m2; + }; + assert(m.size() == 8); + assert(m == make({1, 2, 3, 4, 5, 6, 7, 8})); + std::same_as decltype(auto) i1 = m.erase(std::next(m.cbegin(), 3)); + assert(m.size() == 7); + assert(i1 == std::next(m.begin(), 3)); + assert(m == make({1, 2, 3, 5, 6, 7, 8})); + + std::same_as decltype(auto) i2 = m.erase(std::next(m.begin(), 0)); + assert(m.size() == 6); + assert(i2 == m.begin()); + assert(m == make({2, 3, 5, 6, 7, 8})); + + std::same_as decltype(auto) i3 = m.erase(std::next(m.cbegin(), 5)); + assert(m.size() == 5); + assert(i3 == m.end()); + assert(m == make({2, 3, 5, 6, 7})); + + std::same_as decltype(auto) i4 = m.erase(std::next(m.begin(), 1)); + assert(m.size() == 4); + assert(i4 == std::next(m.begin())); + assert(m == make({2, 5, 6, 7})); + + std::same_as decltype(auto) i5 = m.erase(std::next(m.cbegin(), 2)); + assert(m.size() == 3); + assert(i5 == std::next(m.begin(), 2)); + assert(m == make({2, 5, 7})); + + std::same_as decltype(auto) i6 = m.erase(std::next(m.begin(), 2)); + assert(m.size() == 2); + assert(i6 == std::next(m.begin(), 2)); + assert(m == make({2, 5})); + + std::same_as decltype(auto) i7 = m.erase(std::next(m.cbegin(), 0)); + assert(m.size() == 1); + assert(i7 == std::next(m.begin(), 0)); + assert(m == make({5})); + + std::same_as decltype(auto) i8 = m.erase(m.begin()); + assert(m.size() == 0); + assert(i8 == m.begin()); + assert(i8 == m.end()); +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + +void test_exception() { + auto erase_function = [](auto& m, auto) { m.erase(m.begin() + 2); }; + test_erase_exception_guarantee(erase_function); +} + +int main(int, char**) { + test(); + test_exception(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/erase_iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/erase_iter_iter.pass.cpp new file mode 100644 index 000000000000..f44a8864bdbc --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/erase_iter_iter.pass.cpp @@ -0,0 +1,98 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// iterator erase(const_iterator first, const_iterator last); + +#include +#include +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "../helpers.h" +#include "test_macros.h" +#include "min_allocator.h" + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set, KeyContainer>; + using I = M::iterator; + + auto make = [](std::initializer_list il) { + M m; + for (int i : il) { + m.emplace(i); + } + return m; + }; + + int ar[] = { + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + }; + M m(ar, ar + sizeof(ar) / sizeof(ar[0])); + assert(m.size() == 8); + std::same_as decltype(auto) i1 = m.erase(m.cbegin(), m.cbegin()); + assert(m.size() == 8); + assert(i1 == m.begin()); + assert(m == make({1, 2, 3, 4, 5, 6, 7, 8})); + + std::same_as decltype(auto) i2 = m.erase(m.cbegin(), std::next(m.cbegin(), 2)); + assert(m.size() == 6); + assert(i2 == m.begin()); + assert(m == make({3, 4, 5, 6, 7, 8})); + + std::same_as decltype(auto) i3 = m.erase(std::next(m.cbegin(), 2), std::next(m.cbegin(), 6)); + assert(m.size() == 2); + assert(i3 == std::next(m.begin(), 2)); + assert(m == make({3, 4})); + + std::same_as decltype(auto) i4 = m.erase(m.cbegin(), m.cend()); + assert(m.size() == 0); + assert(i4 == m.begin()); + assert(i4 == m.end()); + + // was empty + std::same_as decltype(auto) i5 = m.erase(m.cbegin(), m.cend()); + assert(m.size() == 0); + assert(i5 == m.begin()); + assert(i5 == m.end()); +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + +void test_exception() { + auto erase_function = [](auto& m, auto) { m.erase(m.begin(), m.begin() + 2); }; + test_erase_exception_guarantee(erase_function); +} + +int main(int, char**) { + test(); + test_exception(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/erase_key.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/erase_key.pass.cpp new file mode 100644 index 000000000000..c50b219895b1 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/erase_key.pass.cpp @@ -0,0 +1,100 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// size_type erase(const key_type& k); + +#include +#include +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "../helpers.h" +#include "test_macros.h" +#include "min_allocator.h" + +template > +void test_one() { + using M = std::flat_set; + + auto make = [](std::initializer_list il) { + M m; + for (int i : il) { + m.emplace(i); + } + return m; + }; + M m = make({1, 2, 3, 4, 5, 6, 7, 8}); + ASSERT_SAME_TYPE(decltype(m.erase(9)), typename M::size_type); + auto n = m.erase(9); + assert(n == 0); + assert(m == make({1, 2, 3, 4, 5, 6, 7, 8})); + n = m.erase(4); + assert(n == 1); + assert(m == make({1, 2, 3, 5, 6, 7, 8})); + n = m.erase(1); + assert(n == 1); + assert(m == make({2, 3, 5, 6, 7, 8})); + n = m.erase(8); + assert(n == 1); + assert(m == make({2, 3, 5, 6, 7})); + n = m.erase(3); + assert(n == 1); + assert(m == make({2, 5, 6, 7})); + n = m.erase(4); + assert(n == 0); + assert(m == make({2, 5, 6, 7})); + n = m.erase(6); + assert(n == 1); + assert(m == make({2, 5, 7})); + n = m.erase(7); + assert(n == 1); + assert(m == make({2, 5})); + n = m.erase(2); + assert(n == 1); + assert(m == make({5})); + n = m.erase(5); + assert(n == 1); + assert(m.empty()); + // was empty + n = m.erase(5); + assert(n == 0); + assert(m.empty()); +} + +void test() { + test_one>(); + test_one, std::greater<>>(); + test_one>(); + test_one>(); + test_one>>(); +} + +void test_exception() { + auto erase_function = [](auto& m, auto key_arg) { + using Map = std::decay_t; + using Key = typename Map::key_type; + const Key key{key_arg}; + m.erase(key); + }; + test_erase_exception_guarantee(erase_function); +} + +int main(int, char**) { + test(); + test_exception(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/erase_key_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/erase_key_transparent.pass.cpp new file mode 100644 index 000000000000..9dd91628d1c2 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/erase_key_transparent.pass.cpp @@ -0,0 +1,157 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// size_type erase(K&& k); + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "../helpers.h" +#include "test_macros.h" +#include "min_allocator.h" + +// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type. +template +concept CanErase = requires(M m, Transparent k) { m.erase(k); }; +using TransparentSet = std::flat_set; +using NonTransparentSet = std::flat_set; +static_assert(CanErase); +static_assert(!CanErase); +static_assert(!CanErase); +static_assert(!CanErase); + +template +struct HeterogeneousKey { + explicit HeterogeneousKey(Key key, It it) : key_(key), it_(it) {} + operator It() && { return it_; } + auto operator<=>(Key key) const { return key_ <=> key; } + friend bool operator<(const HeterogeneousKey&, const HeterogeneousKey&) { + assert(false); + return false; + } + Key key_; + It it_; +}; + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set, KeyContainer>; + + M m = {1, 2, 3, 4}; + ASSERT_SAME_TYPE(decltype(m.erase(9)), typename M::size_type); + auto n = m.erase(3); // erase(K&&) [with K=int] + assert(n == 1); + assert((m == M{1, 2, 4})); + typename M::key_type lvalue = 2; + n = m.erase(lvalue); // erase(K&&) [with K=int&] + assert(n == 1); + assert((m == M{1, 4})); + const typename M::key_type const_lvalue = 1; + n = m.erase(const_lvalue); // erase(const key_type&) + assert(n == 1); + assert((m == M{4})); +} + +template +void test_transparent_comparator() { + using M = std::flat_set; + { + M m = {"alpha", "beta", "epsilon", "eta", "gamma"}; + ASSERT_SAME_TYPE(decltype(m.erase(Transparent{"abc"})), typename M::size_type); + + auto n = m.erase(Transparent{"epsilon"}); + assert(n == 1); + + M expected = {"alpha", "beta", "eta", "gamma"}; + assert(m == expected); + + auto n2 = m.erase(Transparent{"aaa"}); + assert(n2 == 0); + assert(m == expected); + } + { + // was empty + M m; + auto n = m.erase(Transparent{"epsilon"}); + assert(n == 0); + assert(m.empty()); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); + + test_transparent_comparator>(); + test_transparent_comparator>(); + test_transparent_comparator>(); + test_transparent_comparator>>(); + + { + // P2077's HeterogeneousKey example + using M = std::flat_set>; + M m = {1, 2, 3, 4, 5, 6, 7, 8}; + auto h1 = HeterogeneousKey(8, m.begin()); + std::same_as auto n = m.erase(h1); // lvalue is not convertible to It; erase(K&&) is the best match + assert(n == 1); + assert((m == M{1, 2, 3, 4, 5, 6, 7})); + std::same_as auto it = m.erase(std::move(h1)); // rvalue is convertible to It; erase(K&&) drops out + assert(it == m.begin()); + assert((m == M{2, 3, 4, 5, 6, 7})); + } + { + using M = std::flat_set>; + M m = {1, 2, 3, 4, 5, 6, 7, 8}; + auto h1 = HeterogeneousKey(8, m.begin()); + std::same_as auto n = m.erase(h1); // lvalue is not convertible to It; erase(K&&) is the best match + assert(n == 1); + assert((m == M{1, 2, 3, 4, 5, 6, 7})); + std::same_as auto it = m.erase(std::move(h1)); // rvalue is convertible to It; erase(K&&) drops out + assert(it == m.begin()); + assert((m == M{2, 3, 4, 5, 6, 7})); + } + { + bool transparent_used = false; + TransparentComparator c(transparent_used); + std::flat_set m(std::sorted_unique, {1, 2, 3}, c); + assert(!transparent_used); + auto n = m.erase(Transparent{3}); + assert(n == 1); + assert(transparent_used); + } +} + +void test_exception() { + auto erase_transparent = [](auto& m, auto key_arg) { + using Set = std::decay_t; + using Key = typename Set::key_type; + m.erase(Transparent{key_arg}); + }; + test_erase_exception_guarantee(erase_transparent); +} + +int main(int, char**) { + test(); + test_exception(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/extract.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/extract.pass.cpp new file mode 100644 index 000000000000..12e63e0d23e1 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/extract.pass.cpp @@ -0,0 +1,102 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// containers extract() &&; + +#include +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "../helpers.h" +#include "test_macros.h" +#include "min_allocator.h" + +template +concept CanExtract = requires(T&& t) { std::forward(t).extract(); }; + +static_assert(CanExtract&&>); +static_assert(!CanExtract&>); +static_assert(!CanExtract const&>); +static_assert(!CanExtract const&&>); + +template +void test_one() { + using M = std::flat_set, KeyContainer>; + { + M m = M({1, 2, 3}); + + std::same_as auto keys = std::move(m).extract(); + + auto expected_keys = {1, 2, 3}; + assert(std::ranges::equal(keys, expected_keys)); + check_invariant(m); + LIBCPP_ASSERT(m.empty()); + } + { + // was empty + M m; + assert(m.empty()); + auto keys = std::move(m).extract(); + assert(keys.empty()); + LIBCPP_ASSERT(m.empty()); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); + + { + // extracted object maintains invariant if the underlying container does not clear after move + using M = std::flat_set, CopyOnlyVector>; + M m = M({1, 2, 3}); + std::same_as auto keys = std::move(m).extract(); + assert(keys.size() == 3); + check_invariant(m); + LIBCPP_ASSERT(m.empty()); + } +} + +void test_exception() { + { +#ifndef TEST_HAS_NO_EXCEPTIONS + using KeyContainer = ThrowOnMoveContainer; + using M = std::flat_set; + + M m; + m.emplace(1); + m.emplace(2); + try { + auto c = std::move(m).extract(); + assert(false); + } catch (int) { + check_invariant(m); + // In libc++, we try to erase the key after value emplacement failure. + // and after erasure failure, we clear the flat_set + LIBCPP_ASSERT(m.size() == 0); + } +#endif + } +} + +int main(int, char**) { + test(); + test_exception(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_cv.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_cv.pass.cpp new file mode 100644 index 000000000000..e0cb80f74462 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_cv.pass.cpp @@ -0,0 +1,83 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// pair insert(const value_type& v); + +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "test_macros.h" +#include "../helpers.h" +#include "min_allocator.h" + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set, KeyContainer>; + using R = std::pair; + using VT = typename M::value_type; + M m; + + const VT v1(2); + std::same_as decltype(auto) r = m.insert(v1); + assert(r.second); + assert(r.first == m.begin()); + assert(m.size() == 1); + assert(*r.first == 2); + + const VT v2(1); + r = m.insert(v2); + assert(r.second); + assert(r.first == m.begin()); + assert(m.size() == 2); + assert(*r.first == 1); + + const VT v3(3); + r = m.insert(v3); + assert(r.second); + assert(r.first == std::ranges::prev(m.end())); + assert(m.size() == 3); + assert(*r.first == 3); + + const VT v4(3); + r = m.insert(v4); + assert(!r.second); + assert(r.first == std::ranges::prev(m.end())); + assert(m.size() == 3); + assert(*r.first == 3); +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + +void test_exception() { + auto insert_func = [](auto& m, auto key_arg) { + using value_type = typename std::decay_t::value_type; + const value_type p(key_arg); + m.insert(p); + }; + test_emplace_exception_guarantee(insert_func); +} + +int main(int, char**) { + test(); + test_exception(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_initializer_list.pass.cpp new file mode 100644 index 000000000000..992c96ecba1a --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_initializer_list.pass.cpp @@ -0,0 +1,92 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// void insert(initializer_list il); + +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "../helpers.h" +#include "test_macros.h" +#include "min_allocator.h" + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set, KeyContainer>; + using V = typename M::value_type; + + { + M m = {1, 1, 1, 3, 3, 3}; + m.insert({ + 4, + 4, + 4, + 1, + 1, + 1, + 2, + 2, + 2, + }); + assert(m.size() == 4); + assert(std::distance(m.begin(), m.end()) == 4); + assert(*m.begin() == V(1)); + assert(*std::next(m.begin()) == V(2)); + assert(*std::next(m.begin(), 2) == V(3)); + assert(*std::next(m.begin(), 3) == V(4)); + } + { + // was empty + M m; + m.insert({ + 4, + 4, + 4, + 1, + 1, + 1, + 2, + 2, + 2, + }); + M expected = {1, 2, 4}; + assert(m == expected); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + +void test_exception() { + auto insert_func = [](auto& m, const auto& newValues) { + using FlatSet = std::decay_t; + using value_type = typename FlatSet::value_type; + std::initializer_list il = {newValues[0]}; + m.insert(il); + }; + test_insert_range_exception_guarantee(insert_func); +} + +int main(int, char**) { + test(); + test_exception(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_cv.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_cv.pass.cpp new file mode 100644 index 000000000000..76b4d5f0eb7c --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_cv.pass.cpp @@ -0,0 +1,80 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// iterator insert(const_iterator position, const value_type& v); + +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "test_macros.h" +#include "../helpers.h" +#include "min_allocator.h" + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set, KeyContainer>; + using R = typename M::iterator; + using VT = typename M::value_type; + + M m; + const VT v1(2); + std::same_as decltype(auto) r = m.insert(m.end(), v1); + assert(r == m.begin()); + assert(m.size() == 1); + assert(*r == 2); + + const VT v2(1); + r = m.insert(m.end(), v2); + assert(r == m.begin()); + assert(m.size() == 2); + assert(*r == 1); + + const VT v3(3); + r = m.insert(m.end(), v3); + assert(r == std::ranges::prev(m.end())); + assert(m.size() == 3); + assert(*r == 3); + + const VT v4(3); + r = m.insert(m.end(), v4); + assert(r == std::ranges::prev(m.end())); + assert(m.size() == 3); + assert(*r == 3); +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + +void test_exception() { + auto insert_func = [](auto& m, auto key_arg) { + using FlatSet = std::decay_t; + using value_type = typename FlatSet::value_type; + const value_type p(key_arg); + m.insert(m.begin(), p); + }; + test_emplace_exception_guarantee(insert_func); +} + +int main(int, char**) { + test(); + test_exception(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_iter.pass.cpp new file mode 100644 index 000000000000..8063686c960e --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_iter.pass.cpp @@ -0,0 +1,94 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// template +// void insert(InputIterator first, InputIterator last); + +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "../helpers.h" +#include "test_macros.h" +#include "test_iterators.h" +#include "min_allocator.h" + +// test constraint InputIterator +template +concept CanInsert = requires(M m, Args&&... args) { m.insert(std::forward(args)...); }; + +using Set = std::flat_set; + +static_assert(CanInsert); +static_assert(CanInsert, cpp17_input_iterator>); +static_assert(!CanInsert); +static_assert(!CanInsert, cpp20_input_iterator>); + +template +void test_one() { + using M = std::flat_set, KeyContainer>; + + int ar1[] = { + 2, + 2, + 2, + 1, + 1, + 1, + 3, + 3, + 3, + }; + int ar2[] = { + 4, + 4, + 4, + 1, + 1, + 1, + 0, + 0, + 0, + }; + + M m; + m.insert(cpp17_input_iterator(ar1), cpp17_input_iterator(ar1 + sizeof(ar1) / sizeof(ar1[0]))); + assert(m.size() == 3); + M expected{1, 2, 3}; + assert(m == expected); + + m.insert(cpp17_input_iterator(ar2), cpp17_input_iterator(ar2 + sizeof(ar2) / sizeof(ar2[0]))); + assert(m.size() == 5); + M expected2{0, 1, 2, 3, 4}; + assert(m == expected2); +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + +void test_exception() { + auto insert_func = [](auto& m, const auto& newValues) { m.insert(newValues.begin(), newValues.end()); }; + test_insert_range_exception_guarantee(insert_func); +} + +int main(int, char**) { + test(); + test_exception(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_rv.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_rv.pass.cpp new file mode 100644 index 000000000000..d29de98e4d3d --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_iter_rv.pass.cpp @@ -0,0 +1,78 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// +// iterator insert(const_iterator position, value_type&&); + +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "MoveOnly.h" +#include "min_allocator.h" +#include "../helpers.h" +#include "test_macros.h" + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set, KeyContainer>; + using V = Key; + using R = typename M::iterator; + M m; + std::same_as decltype(auto) r = m.insert(m.end(), V(2)); + assert(r == m.begin()); + assert(m.size() == 1); + assert(*r == V(2)); + + r = m.insert(m.end(), V(1)); + assert(r == m.begin()); + assert(m.size() == 2); + assert(*r == V(1)); + + r = m.insert(m.end(), V(3)); + assert(r == std::ranges::prev(m.end())); + assert(m.size() == 3); + assert(*r == V(3)); + + r = m.insert(m.end(), V(3)); + assert(r == std::ranges::prev(m.end())); + assert(m.size() == 3); + assert(*r == V(3)); +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>(); + test_one>(); + test_one>(); + test_one>>(); + test_one>>(); +} + +void test_exception() { + auto insert_func = [](auto& m, auto key_arg) { + using FlatSet = std::decay_t; + using value_type = typename FlatSet::value_type; + value_type p(key_arg); + m.insert(m.begin(), std::move(p)); + }; + test_emplace_exception_guarantee(insert_func); +} + +int main(int, char**) { + test(); + test_exception(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_range.pass.cpp new file mode 100644 index 000000000000..966a696c096b --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_range.pass.cpp @@ -0,0 +1,111 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// template R> +// void insert_range(R&& rg); + +#include +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "../helpers.h" +#include "MoveOnly.h" +#include "test_macros.h" +#include "test_iterators.h" +#include "min_allocator.h" + +// test constraint container-compatible-range +template +concept CanInsertRange = requires(M m, R&& r) { m.insert_range(std::forward(r)); }; + +using Set = std::flat_set; + +static_assert(CanInsertRange>); +static_assert(CanInsertRange>); +static_assert(!CanInsertRange*>>); +static_assert(!CanInsertRange*>>); + +template +void test_one() { + using Key = typename KeyContainer::value_type; + + { + using M = std::flat_set, KeyContainer>; + using It = forward_iterator; + M m = {10, 8, 5, 2, 1}; + int ar[] = {3, 1, 4, 1, 5, 9}; + std::ranges::subrange r = {It(ar), It(ar + 6)}; + static_assert(std::ranges::common_range); + m.insert_range(r); + assert((m == M{1, 2, 3, 4, 5, 8, 9, 10})); + } + { + using M = std::flat_set, KeyContainer>; + using It = cpp20_input_iterator; + M m = {8, 5, 3, 2}; + int ar[] = {3, 1, 4, 1, 5, 9}; + std::ranges::subrange r = {It(ar), sentinel_wrapper(It(ar + 6))}; + static_assert(!std::ranges::common_range); + m.insert_range(r); + assert((m == M{1, 2, 3, 4, 5, 8, 9})); + } + { + // The "uniquing" part uses the comparator, not operator==. + struct ModTen { + bool operator()(int a, int b) const { return (a % 10) < (b % 10); } + }; + using M = std::flat_set; + M m = {21, 43, 15, 37}; + int ar[] = {33, 18, 55, 18, 42}; + m.insert_range(ar); + assert((m == M{21, 42, 43, 15, 37, 18})); + } + { + // was empty + using M = std::flat_set, KeyContainer>; + M m; + int ar[] = {3, 1, 4, 1, 5, 9}; + m.insert_range(ar); + assert((m == M{1, 3, 4, 5, 9})); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); + { + // Items are forwarded correctly from the input range. + MoveOnly a[] = {3, 1, 4, 1, 5}; + std::flat_set m; + m.insert_range(a | std::views::as_rvalue); + MoveOnly expected[] = {1, 3, 4, 5}; + assert(std::ranges::equal(m, expected)); + } +} + +void test_exception() { + auto insert_func = [](auto& m, const auto& newValues) { m.insert_range(newValues); }; + test_insert_range_exception_guarantee(insert_func); +} + +int main(int, char**) { + test(); + test_exception(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_rv.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_rv.pass.cpp new file mode 100644 index 000000000000..a179632d6421 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_rv.pass.cpp @@ -0,0 +1,86 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// class flat_set + +// pair insert(value_type&& v); + +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "MoveOnly.h" +#include "min_allocator.h" +#include "test_macros.h" +#include "../helpers.h" + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set; + using R = std::pair; + using V = typename M::value_type; + + M m; + std::same_as decltype(auto) r = m.insert(V(2)); + assert(r.second); + assert(r.first == m.begin()); + assert(m.size() == 1); + assert(*r.first == V(2)); + + r = m.insert(V(1)); + assert(r.second); + assert(r.first == m.begin()); + assert(m.size() == 2); + assert(*r.first == V(1)); + + r = m.insert(V(3)); + assert(r.second); + assert(r.first == std::ranges::prev(m.end())); + assert(m.size() == 3); + assert(*r.first == V(3)); + + r = m.insert(V(3)); + assert(!r.second); + assert(r.first == std::ranges::prev(m.end())); + assert(m.size() == 3); + assert(*r.first == V(3)); +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>(); + test_one>(); + test_one>(); + test_one>>(); + test_one>>(); +} + +void test_exception() { + auto insert_func = [](auto& m, auto key_arg) { + using FlatSet = std::decay_t; + using value_type = typename FlatSet::value_type; + value_type p(key_arg); + m.insert(std::move(p)); + }; + test_emplace_exception_guarantee(insert_func); +} + +int main(int, char**) { + test(); + test_exception(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_sorted_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_sorted_initializer_list.pass.cpp new file mode 100644 index 000000000000..fb0a8b049e72 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_sorted_initializer_list.pass.cpp @@ -0,0 +1,72 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// void insert(sorted_unique_t, initializer_list il); + +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "../helpers.h" +#include "test_macros.h" +#include "min_allocator.h" + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set, KeyContainer>; + using V = Key; + { + M m = {1, 1, 1, 3, 3, 3}; + m.insert(std::sorted_unique, {0, 1, 2, 4}); + assert(m.size() == 5); + assert(std::distance(m.begin(), m.end()) == 5); + assert(*m.begin() == V(0)); + assert(*std::next(m.begin()) == V(1)); + assert(*std::next(m.begin(), 2) == V(2)); + assert(*std::next(m.begin(), 3) == V(3)); + assert(*std::next(m.begin(), 4) == V(4)); + } + { + // empty + M m; + m.insert(std::sorted_unique, {0, 1, 2, 4}); + M expected = {0, 1, 2, 4}; + assert(m == expected); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + +void test_exception() { + auto insert_func = [](auto& m, const auto& newValues) { + using FlatSet = std::decay_t; + using value_type = typename FlatSet::value_type; + std::initializer_list il = {newValues[0]}; + m.insert(std::sorted_unique, il); + }; + test_insert_range_exception_guarantee(insert_func); +} + +int main(int, char**) { + test(); + test_exception(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_sorted_iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_sorted_iter_iter.pass.cpp new file mode 100644 index 000000000000..6258c4dbfdcb --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_sorted_iter_iter.pass.cpp @@ -0,0 +1,82 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// template +// void insert(sorted_unique_t, InputIterator first, InputIterator last); + +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "../helpers.h" +#include "test_macros.h" +#include "test_iterators.h" +#include "min_allocator.h" + +// test constraint InputIterator +template +concept CanInsert = requires(M m, Args&&... args) { m.insert(std::forward(args)...); }; + +using Set = std::flat_set; + +static_assert(CanInsert); +static_assert(CanInsert, cpp17_input_iterator>); +static_assert(!CanInsert); +static_assert(!CanInsert, cpp20_input_iterator>); + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set, KeyContainer>; + + int ar1[] = {1, 2, 3}; + + int ar2[] = {0, 2, 4}; + + M m; + m.insert(std::sorted_unique, + cpp17_input_iterator(ar1), + cpp17_input_iterator(ar1 + sizeof(ar1) / sizeof(ar1[0]))); + assert(m.size() == 3); + M expected{1, 2, 3}; + assert(m == expected); + + m.insert(std::sorted_unique, + cpp17_input_iterator(ar2), + cpp17_input_iterator(ar2 + sizeof(ar2) / sizeof(ar2[0]))); + assert(m.size() == 5); + M expected2{0, 1, 2, 3, 4}; + assert(m == expected2); +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + +void test_exception() { + auto insert_func = [](auto& m, const auto& newValues) { + m.insert(std::sorted_unique, newValues.begin(), newValues.end()); + }; + test_insert_range_exception_guarantee(insert_func); +} + +int main(int, char**) { + test(); + test_exception(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_transparent.pass.cpp new file mode 100644 index 000000000000..105d2e31ddc9 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/insert_transparent.pass.cpp @@ -0,0 +1,186 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// template pair insert(P&& x); +// template iterator insert(const_iterator hint, P&& x); + +#include +#include +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "../helpers.h" +#include "test_macros.h" +#include "test_iterators.h" +#include "min_allocator.h" + +// Constraints: is_constructible_v is true. +template +concept CanInsert = requires(M m, Args&&... args) { m.insert(std::forward(args)...); }; + +using Set = std::flat_set; +using Iter = Set::const_iterator; + +static_assert(CanInsert); +static_assert(CanInsert); +static_assert(!CanInsert); +static_assert(!CanInsert); + +static int expensive_comparisons = 0; +static int cheap_comparisons = 0; + +struct CompareCounter { + int i_ = 0; + CompareCounter(int i) : i_(i) {} + friend auto operator<=>(const CompareCounter& x, const CompareCounter& y) { + expensive_comparisons += 1; + return x.i_ <=> y.i_; + } + bool operator==(const CompareCounter&) const = default; + friend auto operator<=>(const CompareCounter& x, int y) { + cheap_comparisons += 1; + return x.i_ <=> y; + } +}; + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set, KeyContainer>; + + const int expected[] = {1, 2, 3, 4, 5}; + { + // insert(P&&) + // Unlike flat_set, here we can't use key_compare to compare value_type versus P, + // so we must eagerly convert to value_type. + M m = {1, 2, 4, 5}; + expensive_comparisons = 0; + cheap_comparisons = 0; + std::same_as> auto p = m.insert(3); // conversion happens first + assert(expensive_comparisons >= 2); + assert(cheap_comparisons == 0); + assert(p == std::make_pair(m.begin() + 2, true)); + assert(std::ranges::equal(m, expected)); + } + { + // insert(const_iterator, P&&) + M m = {1, 2, 4, 5}; + expensive_comparisons = 0; + cheap_comparisons = 0; + std::same_as auto it = m.insert(m.begin(), 3); + assert(expensive_comparisons >= 2); + assert(cheap_comparisons == 0); + assert(it == m.begin() + 2); + assert(std::ranges::equal(m, expected)); + } + { + // insert(value_type&&) + M m = {1, 2, 4, 5}; + expensive_comparisons = 0; + cheap_comparisons = 0; + std::same_as> auto p = m.insert(3); // conversion happens last + assert(expensive_comparisons >= 2); + assert(cheap_comparisons == 0); + assert(p == std::make_pair(m.begin() + 2, true)); + assert(std::ranges::equal(m, expected)); + } + { + // insert(const_iterator, value_type&&) + M m = {1, 2, 4, 5}; + expensive_comparisons = 0; + cheap_comparisons = 0; + std::same_as auto it = m.insert(m.begin(), 3); + assert(expensive_comparisons >= 2); + assert(cheap_comparisons == 0); + assert(it == m.begin() + 2); + assert(std::ranges::equal(m, expected)); + } + { + // emplace(Args&&...) + M m = {1, 2, 4, 5}; + expensive_comparisons = 0; + cheap_comparisons = 0; + std::same_as> auto p = m.emplace(3); // conversion happens first + assert(expensive_comparisons >= 2); + assert(cheap_comparisons == 0); + assert(p == std::make_pair(m.begin() + 2, true)); + assert(std::ranges::equal(m, expected)); + } + { + // was empty + M m; + std::same_as> auto p = m.insert(3); + assert(p == std::make_pair(m.begin(), true)); + M expected2 = {3}; + assert(std::ranges::equal(m, expected2)); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); + + { + // no ambiguity between insert(pos, P&&) and insert(first, last) + using M = std::flat_set; + struct Evil { + operator M::value_type() const; + operator M::const_iterator() const; + }; + std::flat_set m; + ASSERT_SAME_TYPE(decltype(m.insert(Evil())), std::pair); + ASSERT_SAME_TYPE(decltype(m.insert(m.begin(), Evil())), M::iterator); + ASSERT_SAME_TYPE(decltype(m.insert(m.begin(), m.end())), void); + } +} + +void test_exception() { + { + auto insert_func = [](auto& m, auto key_arg) { + using FlatSet = std::decay_t; + struct T { + typename FlatSet::key_type key_; + T(typename FlatSet::key_type key) : key_(key) {} + operator typename FlatSet::value_type() const { return key_; } + }; + T t(key_arg); + m.insert(t); + }; + test_emplace_exception_guarantee(insert_func); + } + { + auto insert_func_iter = [](auto& m, auto key_arg) { + using FlatSet = std::decay_t; + struct T { + typename FlatSet::key_type key_; + T(typename FlatSet::key_type key) : key_(key) {} + operator typename FlatSet::value_type() const { return key_; } + }; + T t(key_arg); + m.insert(m.begin(), t); + }; + test_emplace_exception_guarantee(insert_func_iter); + } +} + +int main(int, char**) { + test(); + test_exception(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/replace.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/replace.pass.cpp new file mode 100644 index 000000000000..591def4c0f93 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/replace.pass.cpp @@ -0,0 +1,86 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// void replace(container_type&& key_cont); + +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "../helpers.h" +#include "test_macros.h" +#include "min_allocator.h" + +template +concept CanReplace = requires(T t, Args&&... args) { t.replace(std::forward(args)...); }; + +using Set = std::flat_set; +static_assert(CanReplace>); +static_assert(!CanReplace&>); + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set, KeyContainer>; + { + // was empty + M m; + KeyContainer new_keys = {7, 8}; + auto expected_keys = new_keys; + m.replace(std::move(new_keys)); + assert(m.size() == 2); + assert(std::ranges::equal(m, expected_keys)); + } + M m = M({1, 2, 3}); + KeyContainer new_keys = {7, 8}; + auto expected_keys = new_keys; + m.replace(std::move(new_keys)); + assert(m.size() == 2); + assert(std::ranges::equal(m, expected_keys)); +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + +void test_exception() { +#ifndef TEST_HAS_NO_EXCEPTIONS + using KeyContainer = ThrowOnMoveContainer; + using M = std::flat_set; + + M m; + m.emplace(1); + m.emplace(2); + try { + KeyContainer new_keys{3, 4}; + m.replace(std::move(new_keys)); + assert(false); + } catch (int) { + check_invariant(m); + // In libc++, we clear the map + LIBCPP_ASSERT(m.size() == 0); + } +#endif +} + +int main(int, char**) { + test(); + test_exception(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/swap_exception.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/swap_exception.pass.cpp new file mode 100644 index 000000000000..23a2dc85989b --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/swap_exception.pass.cpp @@ -0,0 +1,61 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 +// `check_assertion.h` requires Unix headers and regex support. +// REQUIRES: has-unix-headers +// UNSUPPORTED: no-localization +// UNSUPPORTED: no-exceptions + +// + +// void swap(flat_set& y) noexcept; +// friend void swap(flat_set& x, flat_set& y) noexcept + +// Test that std::terminate is called if any exception is thrown during swap + +#include +#include +#include +#include +#include + +#include "test_macros.h" +#include "../helpers.h" +#include "check_assertion.h" + +template +void test_swap_exception_guarantee([[maybe_unused]] F&& swap_function) { + { + // key swap throws + using KeyContainer = ThrowOnMoveContainer; + using M = std::flat_set; + + M m1, m2; + m1.emplace(1); + m1.emplace(2); + m2.emplace(3); + m2.emplace(4); + // swap is noexcept + EXPECT_STD_TERMINATE([&] { swap_function(m1, m2); }); + } +} + +int main(int, char**) { + { + auto swap_func = [](auto& m1, auto& m2) { swap(m1, m2); }; + test_swap_exception_guarantee(swap_func); + } + + { + auto swap_func = [](auto& m1, auto& m2) { m1.swap(m2); }; + test_swap_exception_guarantee(swap_func); + } + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/swap_free.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/swap_free.pass.cpp new file mode 100644 index 000000000000..686fe93a593f --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/swap_free.pass.cpp @@ -0,0 +1,98 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// friend void swap(flat_set& x, flat_set& y) noexcept + +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "MoveOnly.h" +#include "min_allocator.h" +#include "test_macros.h" +#include "../helpers.h" + +// test noexcept + +template +concept NoExceptAdlSwap = requires(T t1, T t2) { + { swap(t1, t2) } noexcept; +}; + +static_assert(NoExceptAdlSwap>); + +#ifndef TEST_HAS_NO_EXCEPTIONS +static_assert(NoExceptAdlSwap, ThrowOnMoveContainer>>); +#endif + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set, KeyContainer>; + + { + M m1; + M m2; + M m1_save = m1; + M m2_save = m2; + swap(m1, m2); + assert(m1 == m2_save); + assert(m2 == m1_save); + } + { + int ar2[] = {5, 6, 7, 8, 9, 10, 11, 12}; + M m1; + M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0])); + M m1_save = m1; + M m2_save = m2; + swap(m1, m2); + assert(m1 == m2_save); + assert(m2 == m1_save); + } + { + int ar1[] = {1, 2, 3, 4}; + M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0])); + M m2; + M m1_save = m1; + M m2_save = m2; + swap(m1, m2); + assert(m1 == m2_save); + assert(m2 == m1_save); + } + { + int ar1[] = {1, 2, 3, 4}; + int ar2[] = {5, 6, 7, 8, 9, 10, 11, 12}; + M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0])); + M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0])); + M m1_save = m1; + M m2_save = m2; + swap(m1, m2); + assert(m1 == m2_save); + assert(m2 == m1_save); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/swap_member.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/swap_member.pass.cpp new file mode 100644 index 000000000000..1eac55d768ce --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.modifiers/swap_member.pass.cpp @@ -0,0 +1,96 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// void swap(flat_set& y) noexcept; + +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "MoveOnly.h" +#include "min_allocator.h" +#include "test_macros.h" +#include "../helpers.h" + +// test noexcept + +template +concept NoExceptMemberSwap = requires(T t1, T t2) { + { t1.swap(t2) } noexcept; +}; + +static_assert(NoExceptMemberSwap>); +#ifndef TEST_HAS_NO_EXCEPTIONS +static_assert(NoExceptMemberSwap, ThrowOnMoveContainer>>); +#endif + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set, KeyContainer>; + { + M m1; + M m2; + M m1_save = m1; + M m2_save = m2; + m1.swap(m2); + assert(m1 == m2_save); + assert(m2 == m1_save); + } + { + int ar2[] = {5, 6, 7, 8, 9, 10, 11, 12}; + M m1; + M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0])); + M m1_save = m1; + M m2_save = m2; + m1.swap(m2); + assert(m1 == m2_save); + assert(m2 == m1_save); + } + { + int ar1[] = {1, 2, 3, 4}; + M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0])); + M m2; + M m1_save = m1; + M m2_save = m2; + m1.swap(m2); + assert(m1 == m2_save); + assert(m2 == m1_save); + } + { + int ar1[] = {1, 2, 3, 4}; + int ar2[] = {5, 6, 7, 8, 9, 10, 11, 12}; + M m1(ar1, ar1 + sizeof(ar1) / sizeof(ar1[0])); + M m2(ar2, ar2 + sizeof(ar2) / sizeof(ar2[0])); + M m1_save = m1; + M m2_save = m2; + m1.swap(m2); + assert(m1 == m2_save); + assert(m2 == m1_save); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.observers/comp.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.observers/comp.pass.cpp new file mode 100644 index 000000000000..ba2c428c9e30 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.observers/comp.pass.cpp @@ -0,0 +1,76 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// key_compare key_comp() const; +// value_compare value_comp() const; + +#include +#include +#include +#include +#include + +#include "test_macros.h" + +void test() { + { + using M = std::flat_set; + using Comp = std::less; // the default + M m = {}; + ASSERT_SAME_TYPE(M::key_compare, Comp); + ASSERT_SAME_TYPE(decltype(m.key_comp()), Comp); + ASSERT_SAME_TYPE(decltype(m.value_comp()), Comp); + Comp kc = m.key_comp(); + assert(kc(1, 2)); + assert(!kc(2, 1)); + auto vc = m.value_comp(); + assert(vc(1, 2)); + assert(!vc(2, 1)); + } + { + using Comp = std::function; + using M = std::flat_set; + Comp comp = std::greater(); + M m({}, comp); + ASSERT_SAME_TYPE(M::key_compare, Comp); + ASSERT_SAME_TYPE(decltype(m.key_comp()), Comp); + ASSERT_SAME_TYPE(decltype(m.value_comp()), Comp); + Comp kc = m.key_comp(); + assert(!kc(1, 2)); + assert(kc(2, 1)); + auto vc = m.value_comp(); + assert(!vc(1, 2)); + assert(vc(2, 1)); + } + { + using Comp = std::less<>; + using M = std::flat_set; + M m = {}; + ASSERT_SAME_TYPE(M::key_compare, Comp); + ASSERT_SAME_TYPE(decltype(m.key_comp()), Comp); + ASSERT_SAME_TYPE(decltype(m.value_comp()), Comp); + Comp kc = m.key_comp(); + assert(kc(1, 2)); + assert(!kc(2, 1)); + auto vc = m.value_comp(); + auto a = std::make_pair(1, 2); + ASSERT_SAME_TYPE(decltype(vc(a, a)), bool); + assert(vc(1, 2)); + assert(!vc(2, 1)); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/contains.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/contains.pass.cpp new file mode 100644 index 000000000000..e0416fc261ff --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/contains.pass.cpp @@ -0,0 +1,80 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// bool contains(const key_type& x) const; + +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "test_macros.h" +#include "min_allocator.h" + +template +void test_one() { + using Key = typename KeyContainer::value_type; + { + using M = std::flat_set, KeyContainer>; + M m = {1, 2, 4, 5, 8}; + assert(!m.contains(0)); + assert(m.contains(1)); + assert(m.contains(2)); + assert(!m.contains(3)); + assert(m.contains(4)); + assert(m.contains(5)); + assert(!m.contains(6)); + assert(!m.contains(7)); + assert(std::as_const(m).contains(8)); + assert(!std::as_const(m).contains(9)); + m.clear(); + assert(!m.contains(1)); + } + { + using M = std::flat_set, KeyContainer>; + M m = {1, 2, 4, 5, 8}; + assert(!m.contains(0)); + assert(m.contains(1)); + assert(m.contains(2)); + assert(!m.contains(3)); + assert(m.contains(4)); + assert(m.contains(5)); + assert(!m.contains(6)); + assert(!m.contains(7)); + assert(std::as_const(m).contains(8)); + assert(!std::as_const(m).contains(9)); + m.clear(); + assert(!m.contains(1)); + } + { + // empty + using M = std::flat_set, KeyContainer>; + M m; + assert(!m.contains(0)); + assert(!m.contains(1)); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/contains_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/contains_transparent.pass.cpp new file mode 100644 index 000000000000..cae8eea89471 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/contains_transparent.pass.cpp @@ -0,0 +1,83 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// template bool contains(const K& x) const; + +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "../helpers.h" +#include "test_macros.h" +#include "min_allocator.h" + +// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type. +template +concept CanContains = requires(M m, Transparent k) { m.contains(k); }; +using TransparentSet = std::flat_set; +using NonTransparentSet = std::flat_set; +static_assert(CanContains); +static_assert(CanContains); +static_assert(!CanContains); +static_assert(!CanContains); + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set; + + { + M m = {"alpha", "beta", "epsilon", "eta", "gamma"}; + ASSERT_SAME_TYPE(decltype(m.contains(Transparent{"abc"})), bool); + ASSERT_SAME_TYPE(decltype(std::as_const(m).contains(Transparent{"b"})), bool); + assert(m.contains(Transparent{"alpha"}) == true); + assert(m.contains(Transparent{"beta"}) == true); + assert(m.contains(Transparent{"epsilon"}) == true); + assert(m.contains(Transparent{"eta"}) == true); + assert(m.contains(Transparent{"gamma"}) == true); + assert(m.contains(Transparent{"al"}) == false); + assert(m.contains(Transparent{""}) == false); + assert(m.contains(Transparent{"g"}) == false); + } + { + // empty + M m; + assert(m.contains(Transparent{"gamma"}) == false); + assert(m.contains(Transparent{"al"}) == false); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); + + { + bool transparent_used = false; + TransparentComparator c(transparent_used); + std::flat_set m(std::sorted_unique, {1, 2, 3}, c); + assert(!transparent_used); + auto b = m.contains(Transparent{3}); + assert(b); + assert(transparent_used); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/count.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/count.pass.cpp new file mode 100644 index 000000000000..51aec21ca212 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/count.pass.cpp @@ -0,0 +1,80 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// size_type count(const key_type& x) const; + +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "test_macros.h" +#include "min_allocator.h" + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using S = typename KeyContainer::size_type; + + { + using M = std::flat_set, KeyContainer>; + M m = {1, 2, 4, 5, 8}; + ASSERT_SAME_TYPE(decltype(m.count(0)), S); + assert(m.count(0) == 0); + assert(m.count(1) == 1); + assert(m.count(2) == 1); + assert(m.count(3) == 0); + assert(m.count(4) == 1); + assert(m.count(5) == 1); + assert(m.count(6) == 0); + assert(m.count(7) == 0); + assert(std::as_const(m).count(8) == 1); + assert(std::as_const(m).count(9) == 0); + } + { + using M = std::flat_set, KeyContainer>; + M m = {1, 2, 4, 5, 8}; + ASSERT_SAME_TYPE(decltype(m.count(0)), S); + assert(m.count(0) == 0); + assert(m.count(1) == 1); + assert(m.count(2) == 1); + assert(m.count(3) == 0); + assert(m.count(4) == 1); + assert(m.count(5) == 1); + assert(m.count(6) == 0); + assert(m.count(7) == 0); + assert(std::as_const(m).count(8) == 1); + assert(std::as_const(m).count(9) == 0); + } + { + // empty + using M = std::flat_set, KeyContainer>; + M m; + assert(m.count(0) == 0); + assert(m.count(1) == 0); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/count_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/count_transparent.pass.cpp new file mode 100644 index 000000000000..b24b6fa712fa --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/count_transparent.pass.cpp @@ -0,0 +1,82 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// template size_type count(const K& x) const; + +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "../helpers.h" +#include "test_macros.h" +#include "min_allocator.h" + +// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type. +template +concept CanCount = requires(M m, Transparent k) { m.count(k); }; +using TransparentSet = std::flat_set; +using NonTransparentSet = std::flat_set; +static_assert(CanCount); +static_assert(CanCount); +static_assert(!CanCount); +static_assert(!CanCount); + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set; + { + M m = {"alpha", "beta", "epsilon", "eta", "gamma"}; + ASSERT_SAME_TYPE(decltype(m.count(Transparent{"abc"})), typename M::size_type); + ASSERT_SAME_TYPE(decltype(std::as_const(m).count(Transparent{"b"})), typename M::size_type); + assert(m.count(Transparent{"alpha"}) == 1); + assert(m.count(Transparent{"beta"}) == 1); + assert(m.count(Transparent{"epsilon"}) == 1); + assert(m.count(Transparent{"eta"}) == 1); + assert(m.count(Transparent{"gamma"}) == 1); + assert(m.count(Transparent{"al"}) == 0); + assert(m.count(Transparent{""}) == 0); + assert(m.count(Transparent{"g"}) == 0); + } + { + // empty + M m; + assert(m.count(Transparent{"alpha"}) == 0); + assert(m.count(Transparent{"beta"}) == 0); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); + + { + bool transparent_used = false; + TransparentComparator c(transparent_used); + std::flat_set m(std::sorted_unique, {1, 2, 3}, c); + assert(!transparent_used); + auto n = m.count(Transparent{3}); + assert(n == 1); + assert(transparent_used); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/equal_range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/equal_range.pass.cpp new file mode 100644 index 000000000000..7a8b19273289 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/equal_range.pass.cpp @@ -0,0 +1,88 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// pair equal_range(const key_type& k); +// pair equal_range(const key_type& k) const; + +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "test_macros.h" +#include "min_allocator.h" + +template +void test_one() { + using Key = typename KeyContainer::value_type; + { + using M = std::flat_set, KeyContainer>; + using R = std::pair; + using CR = std::pair; + M m = {1, 2, 4, 5, 8}; + ASSERT_SAME_TYPE(decltype(m.equal_range(0)), R); + ASSERT_SAME_TYPE(decltype(std::as_const(m).equal_range(0)), CR); + auto begin = m.begin(); + assert(m.equal_range(0) == std::pair(begin, begin)); + assert(m.equal_range(1) == std::pair(begin, begin + 1)); + assert(m.equal_range(2) == std::pair(begin + 1, begin + 2)); + assert(m.equal_range(3) == std::pair(begin + 2, begin + 2)); + assert(m.equal_range(4) == std::pair(begin + 2, begin + 3)); + assert(m.equal_range(5) == std::pair(begin + 3, begin + 4)); + assert(m.equal_range(6) == std::pair(begin + 4, begin + 4)); + assert(m.equal_range(7) == std::pair(begin + 4, begin + 4)); + assert(std::as_const(m).equal_range(8) == std::pair(m.cbegin() + 4, m.cbegin() + 5)); + assert(std::as_const(m).equal_range(9) == std::pair(m.cbegin() + 5, m.cbegin() + 5)); + } + + { + using M = std::flat_set, KeyContainer>; + using R = std::pair; + using CR = std::pair; + M m = {1, 2, 4, 5, 8}; + ASSERT_SAME_TYPE(decltype(m.equal_range(0)), R); + ASSERT_SAME_TYPE(decltype(std::as_const(m).equal_range(0)), CR); + auto begin = m.begin(); + assert(m.equal_range(0) == std::pair(begin + 5, begin + 5)); + assert(m.equal_range(1) == std::pair(begin + 4, begin + 5)); + assert(m.equal_range(2) == std::pair(begin + 3, begin + 4)); + assert(m.equal_range(3) == std::pair(begin + 3, begin + 3)); + assert(m.equal_range(4) == std::pair(begin + 2, begin + 3)); + assert(m.equal_range(5) == std::pair(begin + 1, begin + 2)); + assert(m.equal_range(6) == std::pair(begin + 1, begin + 1)); + assert(m.equal_range(7) == std::pair(begin + 1, begin + 1)); + assert(std::as_const(m).equal_range(8) == std::pair(m.cbegin(), m.cbegin() + 1)); + assert(std::as_const(m).equal_range(9) == std::pair(m.cbegin(), m.cbegin())); + } + { + // empty + using M = std::flat_set, KeyContainer>; + M m; + auto end = m.end(); + assert(m.equal_range(0) == std::pair(end, end)); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/equal_range_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/equal_range_transparent.pass.cpp new file mode 100644 index 000000000000..8a270ffa1591 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/equal_range_transparent.pass.cpp @@ -0,0 +1,110 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// template pair equal_range(const K& x); +// template pair equal_range(const K& x) const; + +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "../helpers.h" +#include "test_macros.h" +#include "min_allocator.h" + +// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type. +template +concept CanEqualRange = requires(M m, Transparent k) { m.equal_range(k); }; +using TransparentSet = std::flat_set; +using NonTransparentSet = std::flat_set; +static_assert(CanEqualRange); +static_assert(CanEqualRange); +static_assert(!CanEqualRange); +static_assert(!CanEqualRange); + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set; + + using R = std::pair; + using CR = std::pair; + + auto test_found = [](auto&& map, const std::string& expected_key) { + auto [first, last] = map.equal_range(Transparent{expected_key}); + assert(last - first == 1); + assert(*first == expected_key); + }; + + auto test_not_found = [](auto&& map, const std::string& expected_key, long expected_offset) { + auto [first, last] = map.equal_range(Transparent{expected_key}); + assert(first == last); + assert(first - map.begin() == expected_offset); + }; + { + M m = {"alpha", "beta", "epsilon", "eta", "gamma"}; + const auto& cm = m; + ASSERT_SAME_TYPE(decltype(m.equal_range(Transparent{"abc"})), R); + ASSERT_SAME_TYPE(decltype(std::as_const(m).equal_range(Transparent{"b"})), CR); + + test_found(m, "alpha"); + test_found(m, "beta"); + test_found(m, "epsilon"); + test_found(m, "eta"); + test_found(m, "gamma"); + test_found(cm, "alpha"); + test_found(cm, "beta"); + test_found(cm, "epsilon"); + test_found(cm, "eta"); + test_found(cm, "gamma"); + + test_not_found(m, "charlie", 2); + test_not_found(m, "aaa", 0); + test_not_found(m, "zzz", 5); + test_not_found(cm, "charlie", 2); + test_not_found(cm, "aaa", 0); + test_not_found(cm, "zzz", 5); + } + { + // empty + M m; + const auto& cm = m; + test_not_found(m, "aaa", 0); + test_not_found(cm, "charlie", 0); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); + + { + bool transparent_used = false; + TransparentComparator c(transparent_used); + std::flat_set m(std::sorted_unique, {1, 2, 3}, c); + assert(!transparent_used); + auto p = m.equal_range(Transparent{3}); + assert(p.first != p.second); + assert(transparent_used); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/find.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/find.pass.cpp new file mode 100644 index 000000000000..953b8fe63854 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/find.pass.cpp @@ -0,0 +1,64 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// iterator find(const key_type& k); +// const_iterator find(const key_type& k) const; + +#include +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "test_macros.h" +#include "min_allocator.h" + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set, KeyContainer>; + { + M m = {1, 2, 4, 5, 8}; + ASSERT_SAME_TYPE(decltype(m.find(0)), typename M::iterator); + ASSERT_SAME_TYPE(decltype(std::as_const(m).find(0)), typename M::const_iterator); + assert(m.find(0) == m.end()); + assert(m.find(1) == m.begin()); + assert(m.find(2) == m.begin() + 1); + assert(m.find(3) == m.end()); + assert(m.find(4) == m.begin() + 2); + assert(m.find(5) == m.begin() + 3); + assert(m.find(6) == m.end()); + assert(m.find(7) == m.end()); + assert(std::as_const(m).find(8) == m.begin() + 4); + assert(std::as_const(m).find(9) == m.end()); + } + { + // empty + M m; + assert(m.find(0) == m.end()); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/find_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/find_transparent.pass.cpp new file mode 100644 index 000000000000..6ba91bd5ebe4 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/find_transparent.pass.cpp @@ -0,0 +1,100 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// template iterator find(const K& x); +// template const_iterator find(const K& x) const; + +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "../helpers.h" +#include "test_macros.h" +#include "min_allocator.h" + +// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type. +template +concept CanFind = requires(M m, Transparent k) { m.find(k); }; +using TransparentSet = std::flat_set; +using NonTransparentSet = std::flat_set; +static_assert(CanFind); +static_assert(CanFind); +static_assert(!CanFind); +static_assert(!CanFind); + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set; + + { + M m = {"alpha", "beta", "epsilon", "eta", "gamma"}; + + const auto& cm = m; + ASSERT_SAME_TYPE(decltype(m.find(Transparent{"abc"})), typename M::iterator); + ASSERT_SAME_TYPE(decltype(std::as_const(m).find(Transparent{"b"})), typename M::const_iterator); + + auto test_find = [](auto&& map, const std::string& expected_key, long expected_offset) { + auto iter = map.find(Transparent{expected_key}); + assert(iter - map.begin() == expected_offset); + }; + + test_find(m, "alpha", 0); + test_find(m, "beta", 1); + test_find(m, "epsilon", 2); + test_find(m, "eta", 3); + test_find(m, "gamma", 4); + test_find(m, "charlie", 5); + test_find(m, "aaa", 5); + test_find(m, "zzz", 5); + test_find(cm, "alpha", 0); + test_find(cm, "beta", 1); + test_find(cm, "epsilon", 2); + test_find(cm, "eta", 3); + test_find(cm, "gamma", 4); + test_find(cm, "charlie", 5); + test_find(cm, "aaa", 5); + test_find(cm, "zzz", 5); + } + { + // empty + M m; + auto iter = m.find(Transparent{"a"}); + assert(iter == m.end()); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); + + { + bool transparent_used = false; + TransparentComparator c(transparent_used); + std::flat_set m(std::sorted_unique, {1, 2, 3}, c); + assert(!transparent_used); + auto it = m.find(Transparent{3}); + assert(it != m.end()); + assert(transparent_used); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/lower_bound.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/lower_bound.pass.cpp new file mode 100644 index 000000000000..32796b7a164f --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/lower_bound.pass.cpp @@ -0,0 +1,80 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// iterator lower_bound(const key_type& k); +// const_iterator lower_bound(const key_type& k) const; + +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "test_macros.h" +#include "min_allocator.h" + +template +void test_one() { + using Key = typename KeyContainer::value_type; + { + using M = std::flat_set, KeyContainer>; + M m = {1, 2, 4, 5, 8}; + ASSERT_SAME_TYPE(decltype(m.lower_bound(0)), typename M::iterator); + ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(0)), typename M::const_iterator); + assert(m.lower_bound(0) == m.begin()); + assert(m.lower_bound(1) == m.begin()); + assert(m.lower_bound(2) == m.begin() + 1); + assert(m.lower_bound(3) == m.begin() + 2); + assert(m.lower_bound(4) == m.begin() + 2); + assert(m.lower_bound(5) == m.begin() + 3); + assert(m.lower_bound(6) == m.begin() + 4); + assert(m.lower_bound(7) == m.begin() + 4); + assert(std::as_const(m).lower_bound(8) == m.begin() + 4); + assert(std::as_const(m).lower_bound(9) == m.end()); + } + { + using M = std::flat_set, KeyContainer>; + M m = {1, 2, 4, 5, 8}; + ASSERT_SAME_TYPE(decltype(m.lower_bound(0)), typename M::iterator); + ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(0)), typename M::const_iterator); + assert(m.lower_bound(0) == m.end()); + assert(m.lower_bound(1) == m.begin() + 4); + assert(m.lower_bound(2) == m.begin() + 3); + assert(m.lower_bound(3) == m.begin() + 3); + assert(m.lower_bound(4) == m.begin() + 2); + assert(m.lower_bound(5) == m.begin() + 1); + assert(m.lower_bound(6) == m.begin() + 1); + assert(m.lower_bound(7) == m.begin() + 1); + assert(std::as_const(m).lower_bound(8) == m.begin()); + assert(std::as_const(m).lower_bound(9) == m.begin()); + } + { + // empty + using M = std::flat_set, KeyContainer>; + M m; + assert(m.lower_bound(0) == m.end()); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/lower_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/lower_bound_transparent.pass.cpp new file mode 100644 index 000000000000..8fcfe4d9d432 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/lower_bound_transparent.pass.cpp @@ -0,0 +1,106 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// template iterator lower_bound(const K& x); +// template const_iterator lower_bound(const K& x) const; + +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "../helpers.h" +#include "test_macros.h" +#include "min_allocator.h" + +// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type. +template +concept CanLowerBound = requires(M m, Transparent k) { m.lower_bound(k); }; +using TransparentSet = std::flat_set; +using NonTransparentSet = std::flat_set; +static_assert(CanLowerBound); +static_assert(CanLowerBound); +static_assert(!CanLowerBound); +static_assert(!CanLowerBound); + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set; + + { + M m = {"alpha", "beta", "epsilon", "eta", "gamma"}; + const auto& cm = m; + ASSERT_SAME_TYPE(decltype(m.lower_bound(Transparent{"abc"})), typename M::iterator); + ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(Transparent{"b"})), typename M::const_iterator); + + auto test_lower_bound = [&](auto&& map, const std::string& expected_key, long expected_offset) { + auto iter = map.lower_bound(Transparent{expected_key}); + assert(iter - map.begin() == expected_offset); + }; + + test_lower_bound(m, "abc", 0); + test_lower_bound(m, "alpha", 0); + test_lower_bound(m, "beta", 1); + test_lower_bound(m, "bets", 2); + test_lower_bound(m, "charlie", 2); + test_lower_bound(m, "echo", 2); + test_lower_bound(m, "epsilon", 2); + test_lower_bound(m, "eta", 3); + test_lower_bound(m, "gamma", 4); + test_lower_bound(m, "golf", 5); + test_lower_bound(m, "zzz", 5); + + test_lower_bound(cm, "abc", 0); + test_lower_bound(cm, "alpha", 0); + test_lower_bound(cm, "beta", 1); + test_lower_bound(cm, "bets", 2); + test_lower_bound(cm, "charlie", 2); + test_lower_bound(cm, "echo", 2); + test_lower_bound(cm, "epsilon", 2); + test_lower_bound(cm, "eta", 3); + test_lower_bound(cm, "gamma", 4); + test_lower_bound(cm, "golf", 5); + test_lower_bound(cm, "zzz", 5); + } + { + // empty + M m; + auto iter = m.lower_bound(Transparent{"a"}); + assert(iter == m.end()); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); + + { + bool transparent_used = false; + TransparentComparator c(transparent_used); + std::flat_set m(std::sorted_unique, {1, 2, 3}, c); + assert(!transparent_used); + auto it = m.lower_bound(Transparent{3}); + assert(it != m.end()); + assert(transparent_used); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/upper_bound.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/upper_bound.pass.cpp new file mode 100644 index 000000000000..6a967cb2371b --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/upper_bound.pass.cpp @@ -0,0 +1,81 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// iterator upper_bound(const key_type& k); +// const_iterator upper_bound(const key_type& k) const; + +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "test_macros.h" +#include "min_allocator.h" + +template +void test_one() { + using Key = typename KeyContainer::value_type; + { + using M = std::flat_set, KeyContainer>; + M m = {1, 2, 4, 5, 8}; + ASSERT_SAME_TYPE(decltype(m.upper_bound(0)), typename M::iterator); + ASSERT_SAME_TYPE(decltype(std::as_const(m).upper_bound(0)), typename M::const_iterator); + assert(m.upper_bound(0) == m.begin()); + assert(m.upper_bound(1) == m.begin() + 1); + assert(m.upper_bound(2) == m.begin() + 2); + assert(m.upper_bound(3) == m.begin() + 2); + assert(m.upper_bound(4) == m.begin() + 3); + assert(m.upper_bound(5) == m.begin() + 4); + assert(m.upper_bound(6) == m.begin() + 4); + assert(std::as_const(m).upper_bound(7) == m.begin() + 4); + assert(std::as_const(m).upper_bound(8) == m.end()); + assert(std::as_const(m).upper_bound(9) == m.end()); + } + + { + using M = std::flat_set, KeyContainer>; + M m = {1, 2, 4, 5, 8}; + ASSERT_SAME_TYPE(decltype(m.upper_bound(0)), typename M::iterator); + ASSERT_SAME_TYPE(decltype(std::as_const(m).upper_bound(0)), typename M::const_iterator); + assert(m.upper_bound(0) == m.end()); + assert(m.upper_bound(1) == m.end()); + assert(m.upper_bound(2) == m.begin() + 4); + assert(m.upper_bound(3) == m.begin() + 3); + assert(m.upper_bound(4) == m.begin() + 3); + assert(m.upper_bound(5) == m.begin() + 2); + assert(m.upper_bound(6) == m.begin() + 1); + assert(m.upper_bound(7) == m.begin() + 1); + assert(std::as_const(m).upper_bound(8) == m.begin() + 1); + assert(std::as_const(m).upper_bound(9) == m.begin()); + } + { + // empty + using M = std::flat_set, KeyContainer>; + M m; + assert(m.upper_bound(0) == m.end()); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/upper_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/upper_bound_transparent.pass.cpp new file mode 100644 index 000000000000..db89614dd815 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.operations/upper_bound_transparent.pass.cpp @@ -0,0 +1,106 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// template iterator upper_bound(const K& x); +// template const_iterator upper_bound(const K& x) const; + +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "../helpers.h" +#include "test_macros.h" +#include "min_allocator.h" + +// Constraints: The qualified-id Compare::is_transparent is valid and denotes a type. +template +concept CanUpperBound = requires(M m, Transparent k) { m.upper_bound(k); }; +using TransparentSet = std::flat_set; +using NonTransparentSet = std::flat_set; +static_assert(CanUpperBound); +static_assert(CanUpperBound); +static_assert(!CanUpperBound); +static_assert(!CanUpperBound); + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_set; + + { + M m = {"alpha", "beta", "epsilon", "eta", "gamma"}; + const auto& cm = m; + ASSERT_SAME_TYPE(decltype(m.lower_bound(Transparent{"abc"})), typename M::iterator); + ASSERT_SAME_TYPE(decltype(std::as_const(m).lower_bound(Transparent{"b"})), typename M::const_iterator); + + auto test_upper_bound = [&](auto&& map, const std::string& expected_key, long expected_offset) { + auto iter = map.upper_bound(Transparent{expected_key}); + assert(iter - map.begin() == expected_offset); + }; + + test_upper_bound(m, "abc", 0); + test_upper_bound(m, "alpha", 1); + test_upper_bound(m, "beta", 2); + test_upper_bound(m, "bets", 2); + test_upper_bound(m, "charlie", 2); + test_upper_bound(m, "echo", 2); + test_upper_bound(m, "epsilon", 3); + test_upper_bound(m, "eta", 4); + test_upper_bound(m, "gamma", 5); + test_upper_bound(m, "golf", 5); + test_upper_bound(m, "zzz", 5); + + test_upper_bound(cm, "abc", 0); + test_upper_bound(cm, "alpha", 1); + test_upper_bound(cm, "beta", 2); + test_upper_bound(cm, "bets", 2); + test_upper_bound(cm, "charlie", 2); + test_upper_bound(cm, "echo", 2); + test_upper_bound(cm, "epsilon", 3); + test_upper_bound(cm, "eta", 4); + test_upper_bound(cm, "gamma", 5); + test_upper_bound(cm, "golf", 5); + test_upper_bound(cm, "zzz", 5); + } + { + // empty + M m; + auto iter = m.upper_bound(Transparent{"a"}); + assert(iter == m.end()); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); + + { + bool transparent_used = false; + TransparentComparator c(transparent_used); + std::flat_set m(std::sorted_unique, {1, 2, 3}, c); + assert(!transparent_used); + auto it = m.upper_bound(Transparent{2}); + assert(it != m.end()); + assert(transparent_used); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/helpers.h b/libcxx/test/std/containers/container.adaptors/flat.set/helpers.h new file mode 100644 index 000000000000..d686ef5b9a28 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/helpers.h @@ -0,0 +1,307 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef TEST_STD_CONTAINERS_CONTAINER_ADAPTORS_FLAT_SET_HELPERS_H +#define TEST_STD_CONTAINERS_CONTAINER_ADAPTORS_FLAT_SET_HELPERS_H + +#include +#include +#include +#include +#include + +#include "test_allocator.h" +#include "test_macros.h" + +template +void check_invariant(const std::flat_set& m) { + assert(std::is_sorted(m.begin(), m.end(), m.key_comp())); + auto key_equal = [&](const auto& x, const auto& y) { + const auto& c = m.key_comp(); + return !c(x, y) && !c(y, x); + }; + assert(std::adjacent_find(m.begin(), m.end(), key_equal) == m.end()); +} + +struct StartsWith { + explicit StartsWith(char ch) : lower_(1, ch), upper_(1, ch + 1) {} + StartsWith(const StartsWith&) = delete; + void operator=(const StartsWith&) = delete; + struct Less { + using is_transparent = void; + bool operator()(const std::string& a, const std::string& b) const { return a < b; } + bool operator()(const StartsWith& a, const std::string& b) const { return a.upper_ <= b; } + bool operator()(const std::string& a, const StartsWith& b) const { return a < b.lower_; } + bool operator()(const StartsWith&, const StartsWith&) const { + assert(false); // should not be called + return false; + } + }; + +private: + std::string lower_; + std::string upper_; +}; + +template +struct CopyOnlyVector : std::vector { + using std::vector::vector; + + CopyOnlyVector(const CopyOnlyVector&) = default; + CopyOnlyVector(CopyOnlyVector&& other) : CopyOnlyVector(other) {} + CopyOnlyVector(CopyOnlyVector&& other, std::vector::allocator_type alloc) : CopyOnlyVector(other, alloc) {} + + CopyOnlyVector& operator=(const CopyOnlyVector&) = default; + CopyOnlyVector& operator=(CopyOnlyVector& other) { return this->operator=(other); } +}; + +template +struct Transparent { + T t; + + operator T() const + requires ConvertibleToT + { + return t; + } +}; + +template +using ConvertibleTransparent = Transparent; + +template +using NonConvertibleTransparent = Transparent; + +struct TransparentComparator { + using is_transparent = void; + + bool* transparent_used = nullptr; + TransparentComparator() = default; + TransparentComparator(bool& used) : transparent_used(&used) {} + + template + bool operator()(const T& t, const Transparent& transparent) const { + if (transparent_used != nullptr) { + *transparent_used = true; + } + return t < transparent.t; + } + + template + bool operator()(const Transparent& transparent, const T& t) const { + if (transparent_used != nullptr) { + *transparent_used = true; + } + return transparent.t < t; + } + + template + bool operator()(const T& t1, const T& t2) const { + return t1 < t2; + } +}; + +struct NonTransparentComparator { + template + bool operator()(const T&, const Transparent&) const; + + template + bool operator()(const Transparent&, const T&) const; + + template + bool operator()(const T&, const T&) const; +}; + +struct NoDefaultCtr { + NoDefaultCtr() = delete; +}; + +#ifndef TEST_HAS_NO_EXCEPTIONS +template +struct EmplaceUnsafeContainer : std::vector { + using std::vector::vector; + + template + auto emplace(Args&&... args) -> decltype(std::declval>().emplace(std::forward(args)...)) { + if (this->size() > 1) { + auto it1 = this->begin(); + auto it2 = it1 + 1; + // messing up the container + std::iter_swap(it1, it2); + } + + throw 42; + } + + template + auto insert(Args&&... args) -> decltype(std::declval>().insert(std::forward(args)...)) { + if (this->size() > 1) { + auto it1 = this->begin(); + auto it2 = it1 + 1; + // messing up the container + std::iter_swap(it1, it2); + } + + throw 42; + } + + template + auto insert_range(Args&&... args) + -> decltype(std::declval>().insert_range(std::forward(args)...)) { + if (this->size() > 1) { + auto it1 = this->begin(); + auto it2 = it1 + 1; + // messing up the container + std::iter_swap(it1, it2); + } + + throw 42; + } +}; + +template +struct ThrowOnEraseContainer : std::vector { + using std::vector::vector; + + template + auto erase(Args&&... args) -> decltype(std::declval>().erase(std::forward(args)...)) { + throw 42; + } +}; + +template +struct ThrowOnMoveContainer : std::vector { + using std::vector::vector; + + ThrowOnMoveContainer(ThrowOnMoveContainer&&) { throw 42; } + + ThrowOnMoveContainer& operator=(ThrowOnMoveContainer&&) { throw 42; } +}; + +#endif + +template +void test_emplace_exception_guarantee([[maybe_unused]] F&& emplace_function) { +#ifndef TEST_HAS_NO_EXCEPTIONS + using C = TransparentComparator; + { + // Throw on emplace the key, and underlying has strong exception guarantee + using KeyContainer = std::vector>; + using M = std::flat_set; + + LIBCPP_STATIC_ASSERT(std::__container_traits::__emplacement_has_strong_exception_safety_guarantee); + + test_allocator_statistics stats; + + KeyContainer a({1, 2, 3, 4}, test_allocator{&stats}); + [[maybe_unused]] auto expected_keys = a; + M m(std::sorted_unique, std::move(a)); + + stats.throw_after = 1; + try { + emplace_function(m, 0); + assert(false); + } catch (const std::bad_alloc&) { + check_invariant(m); + // In libc++, the flat_set is unchanged + LIBCPP_ASSERT(m.size() == 4); + LIBCPP_ASSERT(std::ranges::equal(m, expected_keys)); + } + } + { + // Throw on emplace the key, and underlying has no strong exception guarantee + using KeyContainer = EmplaceUnsafeContainer; + using M = std::flat_set; + + LIBCPP_STATIC_ASSERT(!std::__container_traits::__emplacement_has_strong_exception_safety_guarantee); + KeyContainer a = {1, 2, 3, 4}; + M m(std::sorted_unique, std::move(a)); + try { + emplace_function(m, 0); + assert(false); + } catch (int) { + check_invariant(m); + // In libc++, the flat_set is cleared + LIBCPP_ASSERT(m.size() == 0); + } + } +#endif +} + +template +void test_insert_range_exception_guarantee([[maybe_unused]] F&& insert_function) { +#ifndef TEST_HAS_NO_EXCEPTIONS + using KeyContainer = EmplaceUnsafeContainer; + using M = std::flat_set; + test_allocator_statistics stats; + KeyContainer a{1, 2, 3, 4}; + M m(std::sorted_unique, std::move(a)); + + std::vector newValues = {0, 1, 5, 6, 7, 8}; + stats.throw_after = 1; + try { + insert_function(m, newValues); + assert(false); + } catch (int) { + check_invariant(m); + // In libc++, we clear if anything goes wrong when inserting a range + LIBCPP_ASSERT(m.size() == 0); + } +#endif +} + +template +void test_erase_exception_guarantee([[maybe_unused]] F&& erase_function) { +#ifndef TEST_HAS_NO_EXCEPTIONS + { + // key erase throws + using KeyContainer = ThrowOnEraseContainer; + using M = std::flat_set; + + KeyContainer a{1, 2, 3, 4}; + M m(std::sorted_unique, std::move(a)); + try { + erase_function(m, 3); + assert(false); + } catch (int) { + check_invariant(m); + // In libc++, we clear if anything goes wrong when erasing + LIBCPP_ASSERT(m.size() == 0); + } + } +#endif +} +class Moveable { + int int_; + double double_; + +public: + Moveable() : int_(0), double_(0) {} + Moveable(int i, double d) : int_(i), double_(d) {} + Moveable(Moveable&& x) : int_(x.int_), double_(x.double_) { + x.int_ = -1; + x.double_ = -1; + } + Moveable& operator=(Moveable&& x) { + int_ = x.int_; + x.int_ = -1; + double_ = x.double_; + x.double_ = -1; + return *this; + } + + Moveable(const Moveable&) = delete; + Moveable& operator=(const Moveable&) = delete; + bool operator==(const Moveable& x) const { return int_ == x.int_ && double_ == x.double_; } + bool operator<(const Moveable& x) const { return int_ < x.int_ || (int_ == x.int_ && double_ < x.double_); } + + int get() const { return int_; } + bool moved() const { return int_ == -1; } +}; + +#endif // TEST_STD_CONTAINERS_CONTAINER_ADAPTORS_FLAT_SET_HELPERS_H diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/incomplete_type.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/incomplete_type.pass.cpp new file mode 100644 index 000000000000..faf746861df3 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/incomplete_type.pass.cpp @@ -0,0 +1,36 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// Check that std::flat_set and its iterators can be instantiated with an incomplete +// type. + +#include +#include + +struct A { + using Set = std::flat_set; + int data; + Set m; + Set::iterator it; + Set::const_iterator cit; +}; + +// Implement the operator< required in order to instantiate flat_set +bool operator<(A const& L, A const& R) { return L.data < R.data; } + +void test() { A a; } + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/op_compare.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/op_compare.pass.cpp new file mode 100644 index 000000000000..3e7aecee77fd --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/op_compare.pass.cpp @@ -0,0 +1,110 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// + +// friend bool operator==(const flat_set& x, const flat_set& y); +// friend synth-three-way-result +// operator<=>(const flat_set& x, const flat_set& y); + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "test_macros.h" +#include "min_allocator.h" +#include "test_allocator.h" +#include "test_comparisons.h" +#include "test_container_comparisons.h" + +template +void test_one() { + using Key = typename KeyContainer::value_type; + + { + using C = std::flat_set; + C s1 = {1}; + C s2 = {2}; + ASSERT_SAME_TYPE(decltype(s1 <=> s2), std::strong_ordering); + AssertComparisonsReturnBool(); + assert(testComparisons(s1, s2, false, true)); + s2 = {1}; + assert(testComparisons(s1, s2, true, false)); + s2 = {1, 2}; + assert(testComparisons(s1, s2, false, true)); + s1 = {0, 1, 2}; + assert(testComparisons(s1, s2, false, true)); + s2 = {0, 1, 3}; + assert(testComparisons(s1, s2, false, true)); + } + { + // Comparisons use value_type's native operators, not the comparator + using C = std::flat_set>; + C s1 = {1}; + C s2 = {2}; + ASSERT_SAME_TYPE(decltype(s1 <=> s2), std::strong_ordering); + AssertComparisonsReturnBool(); + assert(testComparisons(s1, s2, false, true)); + s2 = {1}; + assert(testComparisons(s1, s2, true, false)); + s2 = {1, 2}; + assert(testComparisons(s1, s2, false, true)); + s1 = {0, 1, 2}; + assert(testComparisons(s1, s2, false, false)); + s2 = {0, 1, 3}; + assert(testComparisons(s1, s2, false, true)); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); + + { + using C = std::flat_set; + C s1 = {1}; + C s2 = C(std::sorted_unique, {std::numeric_limits::quiet_NaN()}); + ASSERT_SAME_TYPE(decltype(s1 <=> s2), std::partial_ordering); + AssertComparisonsReturnBool(); + assert(testComparisonsComplete(s1, s2, false, false, false)); + } + { + // Comparisons use value_type's native operators, not the comparator + struct StrongComp { + bool operator()(double a, double b) const { return std::strong_order(a, b) < 0; } + }; + using C = std::flat_set; + C s1 = {1}; + C s2 = {std::numeric_limits::quiet_NaN(), std::numeric_limits::quiet_NaN()}; + ASSERT_SAME_TYPE(decltype(s1 <=> s2), std::partial_ordering); + AssertComparisonsReturnBool(); + assert(testComparisonsComplete(s1, s2, false, false, false)); + s1 = {1, std::numeric_limits::quiet_NaN(), 1}; + s2 = {std::numeric_limits::quiet_NaN(), 1}; + assert(std::lexicographical_compare_three_way(s1.begin(), s1.end(), s2.begin(), s2.end(), std::strong_order) == + std::strong_ordering::equal); + assert(s1 != s2); + assert((s1 <=> s2) == std::partial_ordering::unordered); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/types.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/types.compile.pass.cpp new file mode 100644 index 000000000000..a845b2b81e89 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/types.compile.pass.cpp @@ -0,0 +1,94 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20 + +// using key_type = Key; +// using value_type = Key; +// using key_compare = Compare; +// using value_compare = Compare; +// using reference = value_type&; +// using const_reference = const value_type&; +// using size_type = typename KeyContainer::size_type; +// using difference_type = typename KeyContainer::difference_type; +// using iterator = implementation-defined; // see [container.requirements] +// using const_iterator = implementation-defined; // see [container.requirements] +// using reverse_iterator = std::reverse_iterator; +// using const_reverse_iterator = std::reverse_iterator; +// using container_type = KeyContainer; + +#include +#include +#include +#include +#include +#include +#include +#include "min_allocator.h" + +void test() { + { + using M = std::flat_set; + static_assert(std::is_same_v); + static_assert(std::is_same_v); + static_assert(std::is_same_v>); + static_assert(std::is_same_v>); + static_assert(std::is_same_v); + static_assert(std::is_same_v); + static_assert(std::is_same_v); + static_assert(std::is_same_v); + static_assert(requires { typename M::iterator; }); + static_assert(requires { typename M::const_iterator; }); + static_assert(std::is_same_v>); + static_assert( + std::is_same_v>); + static_assert(std::is_same_v>); + static_assert(requires { typename M::value_compare; }); + } + + { + struct A {}; + struct Compare { + bool operator()(const std::string&, const std::string&) const; + }; + using M = std::flat_set>; + static_assert(std::is_same_v); + static_assert(std::is_same_v); + static_assert(std::is_same_v); + static_assert(std::is_same_v); + static_assert(std::is_same_v); + static_assert(std::is_same_v); + static_assert(std::is_same_v); + static_assert(std::is_same_v); + static_assert(requires { typename M::iterator; }); + static_assert(requires { typename M::const_iterator; }); + static_assert(std::is_same_v>); + static_assert( + std::is_same_v>); + static_assert(std::is_same_v>); + } + { + using C = std::flat_set, std::deque>>; + static_assert(std::is_same_v); + static_assert(std::is_same_v); + static_assert(std::is_same_v>); + static_assert(std::is_same_v>); + static_assert(std::is_same_v); + static_assert(std::is_same_v); + static_assert(std::random_access_iterator); + static_assert(std::random_access_iterator); + static_assert(std::random_access_iterator); + static_assert(std::random_access_iterator); + static_assert(std::is_same_v>); + static_assert(std::is_same_v>); + // size_type is invariably size_t + static_assert(std::is_same_v); + static_assert(std::is_same_v); + static_assert(std::is_same_v>>); + } +} diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/flat_set.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/flat_set.version.compile.pass.cpp new file mode 100644 index 000000000000..f9d0b0a6b4e4 --- /dev/null +++ b/libcxx/test/std/language.support/support.limits/support.limits.general/flat_set.version.compile.pass.cpp @@ -0,0 +1,80 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// WARNING: This test was generated by generate_feature_test_macro_components.py +// and should not be edited manually. +// +// clang-format off + +// + +// Test the feature test macros defined by + +/* Constant Value + __cpp_lib_flat_set 202207L [C++23] +*/ + +#include +#include "test_macros.h" + +#if TEST_STD_VER < 14 + +# ifdef __cpp_lib_flat_set +# error "__cpp_lib_flat_set should not be defined before c++23" +# endif + +#elif TEST_STD_VER == 14 + +# ifdef __cpp_lib_flat_set +# error "__cpp_lib_flat_set should not be defined before c++23" +# endif + +#elif TEST_STD_VER == 17 + +# ifdef __cpp_lib_flat_set +# error "__cpp_lib_flat_set should not be defined before c++23" +# endif + +#elif TEST_STD_VER == 20 + +# ifdef __cpp_lib_flat_set +# error "__cpp_lib_flat_set should not be defined before c++23" +# endif + +#elif TEST_STD_VER == 23 + +# if !defined(_LIBCPP_VERSION) +# ifndef __cpp_lib_flat_set +# error "__cpp_lib_flat_set should be defined in c++23" +# endif +# if __cpp_lib_flat_set != 202207L +# error "__cpp_lib_flat_set should have the value 202207L in c++23" +# endif +# else // _LIBCPP_VERSION +# ifdef __cpp_lib_flat_set +# error "__cpp_lib_flat_set should not be defined because it is unimplemented in libc++!" +# endif +# endif + +#elif TEST_STD_VER > 23 + +# if !defined(_LIBCPP_VERSION) +# ifndef __cpp_lib_flat_set +# error "__cpp_lib_flat_set should be defined in c++26" +# endif +# if __cpp_lib_flat_set != 202207L +# error "__cpp_lib_flat_set should have the value 202207L in c++26" +# endif +# else // _LIBCPP_VERSION +# ifdef __cpp_lib_flat_set +# error "__cpp_lib_flat_set should not be defined because it is unimplemented in libc++!" +# endif +# endif + +#endif // TEST_STD_VER > 23 + diff --git a/libcxx/utils/libcxx/header_information.py b/libcxx/utils/libcxx/header_information.py index 9a723b61524c..9811b42d510c 100644 --- a/libcxx/utils/libcxx/header_information.py +++ b/libcxx/utils/libcxx/header_information.py @@ -164,7 +164,6 @@ module_c_headers = [h for h in all_headers if h.has_cxx20_module() and h.is_cstd # modules will fail to build if a header is added but this list is not updated. headers_not_available = list(map(Header, [ "debugging", - "flat_set", "generator", "hazard_pointer", "inplace_vector", @@ -261,6 +260,7 @@ mandatory_inclusions = { "deque": ["compare", "initializer_list"], "filesystem": ["compare"], "flat_map": ["compare", "initializer_list"], + "flat_set": ["compare", "initializer_list"], "forward_list": ["compare", "initializer_list"], "ios": ["iosfwd"], "iostream": ["ios", "istream", "ostream", "streambuf"], diff --git a/libcxx/utils/libcxx/test/modules.py b/libcxx/utils/libcxx/test/modules.py index 4824ca3cb270..4c4cd273be3c 100644 --- a/libcxx/utils/libcxx/test/modules.py +++ b/libcxx/utils/libcxx/test/modules.py @@ -92,6 +92,9 @@ ExtraHeader["ranges"] = "v1/__fwd/subrange.h$" # same definition. ExtraHeader["functional"] = "v1/__compare/compare_three_way.h$" +# reuses some functionality defined inside +ExtraHeader["flat_set"] = "v1/__flat_map/sorted_unique.h$" + # Some C compatibility headers define std::size_t, which is in <__cstddef/size_t.h> for header in ("cstdio", "cstdlib", "cstring", "ctime", "cuchar", "cwchar"): ExtraHeader[header] = "v1/__cstddef/size_t.h$"