From 9e358fb9527e2c6ec112b1296b4d207802af9473 Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Fri, 31 Jan 2025 15:53:09 +0000 Subject: [PATCH 01/23] [libc++] implement std::flat_set --- .../flat.set.capacity/empty.verify.cpp | 20 ++++ .../copy_assign.addressof.compile.pass.cpp | 30 ++++++ .../flat.set.cons/default_noexcept.pass.cpp | 58 ++++++++++ .../flat.set.cons/move_assign_clears.pass.cpp | 101 ++++++++++++++++++ .../move_assign_noexcept.pass.cpp | 85 +++++++++++++++ .../flat.set.cons/move_exceptions.pass.cpp | 58 ++++++++++ .../flat.set.cons/move_noexcept.pass.cpp | 94 ++++++++++++++++ 7 files changed, 446 insertions(+) create mode 100644 libcxx/test/std/containers/container.adaptors/flat.set/flat.set.capacity/empty.verify.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/copy_assign.addressof.compile.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/default_noexcept.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_assign_clears.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_assign_noexcept.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_exceptions.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_noexcept.pass.cpp diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.capacity/empty.verify.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.capacity/empty.verify.cpp new file mode 100644 index 0000000000000..161fe533eabac --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.capacity/empty.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/std/containers/container.adaptors/flat.set/flat.set.cons/copy_assign.addressof.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/copy_assign.addressof.compile.pass.cpp new file mode 100644 index 0000000000000..169b469f3bca6 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/copy_assign.addressof.compile.pass.cpp @@ -0,0 +1,30 @@ +//===----------------------------------------------------------------------===// +// +// 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& s); + +// Validate whether the container can be copy-assigned (move-assigned, swapped) +// with an ADL-hijacking operator& + +#include +#include + +#include "test_macros.h" +#include "operator_hijacker.h" + +void test() { + std::flat_set so; + std::flat_set s; + s = so; + s = std::move(so); + swap(s, so); +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/default_noexcept.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/default_noexcept.pass.cpp new file mode 100644 index 0000000000000..b4a3b6de205a3 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/default_noexcept.pass.cpp @@ -0,0 +1,58 @@ +//===----------------------------------------------------------------------===// +// +// 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() +// noexcept( +// is_nothrow_default_constructible_v && +// is_nothrow_default_constructible_v); + +// This tests a conforming extension + +#include +#include +#include +#include + +#include "test_macros.h" +#include "MoveOnly.h" +#include "test_allocator.h" + +struct ThrowingCtorComp { + ThrowingCtorComp() noexcept(false) {} + bool operator()(const auto&, const auto&) const { return false; } +}; + +int main(int, char**) { +#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; + } + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_assign_clears.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_assign_clears.pass.cpp new file mode 100644 index 0000000000000..50817f4be8a81 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_assign_clears.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 + +// + +// flat_set& operator=(flat_set&&); +// Preserves the class invariant for the moved-from flat_set. + +#include +#include +#include +#include +#include +#include +#include + +#include "../helpers.h" +#include "test_macros.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; +}; + +int main(int, char**) { + { + 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()); + } + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_assign_noexcept.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_assign_noexcept.pass.cpp new file mode 100644 index 0000000000000..86f3568f0d67a --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_assign_noexcept.pass.cpp @@ -0,0 +1,85 @@ +//===----------------------------------------------------------------------===// +// +// 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&& c) +// noexcept( +// is_nothrow_move_assignable::value && +// is_nothrow_move_assignable::value && +// is_nothrow_copy_assignable::value); + +// This tests a conforming extension + +#include +#include +#include +#include +#include + +#include "MoveOnly.h" +#include "test_allocator.h" +#include "test_macros.h" + +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; +}; + +int main(int, char**) { + { + 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); + } + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_exceptions.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_exceptions.pass.cpp new file mode 100644 index 0000000000000..17e4e40387606 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_exceptions.pass.cpp @@ -0,0 +1,58 @@ +//===----------------------------------------------------------------------===// +// +// 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 + +// + +// flat_set(flat_set&& s); +// If any member function in [flat.map.defn] exits via an exception, the invariant is restored. + +#include +#include +#include +#include +#include +#include + +#include "../helpers.h" +#include "test_macros.h" + +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; + } + } +}; + +int main(int, char**) { + { + 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()); + } + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_noexcept.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_noexcept.pass.cpp new file mode 100644 index 0000000000000..49d1151fd8a99 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_noexcept.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 + +// + +// flat_set(flat_set&&) +// noexcept(is_nothrow_move_constructible::value && +// is_nothrow_move_constructible::value && +// is_nothrow_copy_constructible::value); + +// This tests a conforming extension + +#include +#include +#include +#include +#include +#include +#include + +#include "test_macros.h" +#include "MoveOnly.h" +#include "test_allocator.h" + +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; +}; + +int main(int, char**) { + { + 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); + } + return 0; +} From bec8d2071f8cbf90524192f96b2204364fc82e25 Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Sun, 2 Feb 2025 13:21:24 +0000 Subject: [PATCH 02/23] review --- .../copy_assign.addressof.compile.pass.cpp | 30 ------ .../flat.set.cons/default_noexcept.pass.cpp | 58 ---------- .../flat.set.cons/move_assign_clears.pass.cpp | 101 ------------------ .../move_assign_noexcept.pass.cpp | 85 --------------- .../flat.set.cons/move_exceptions.pass.cpp | 58 ---------- .../flat.set.cons/move_noexcept.pass.cpp | 94 ---------------- .../flat.set.erasure/erase_if.pass.cpp | 10 ++ .../flat.set.modifiers/clear.pass.cpp | 9 ++ .../flat.set.modifiers/swap_free.pass.cpp | 2 + .../flat.set.operations/contains.pass.cpp | 7 ++ .../flat.set.operations/count.pass.cpp | 7 ++ .../flat.set.operations/equal_range.pass.cpp | 7 ++ .../flat.set.operations/find.pass.cpp | 7 ++ .../flat.set.operations/lower_bound.pass.cpp | 7 ++ .../flat.set.operations/upper_bound.pass.cpp | 7 ++ 15 files changed, 63 insertions(+), 426 deletions(-) delete mode 100644 libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/copy_assign.addressof.compile.pass.cpp delete mode 100644 libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/default_noexcept.pass.cpp delete mode 100644 libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_assign_clears.pass.cpp delete mode 100644 libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_assign_noexcept.pass.cpp delete mode 100644 libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_exceptions.pass.cpp delete mode 100644 libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_noexcept.pass.cpp diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/copy_assign.addressof.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/copy_assign.addressof.compile.pass.cpp deleted file mode 100644 index 169b469f3bca6..0000000000000 --- a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/copy_assign.addressof.compile.pass.cpp +++ /dev/null @@ -1,30 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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& s); - -// Validate whether the container can be copy-assigned (move-assigned, swapped) -// with an ADL-hijacking operator& - -#include -#include - -#include "test_macros.h" -#include "operator_hijacker.h" - -void test() { - std::flat_set so; - std::flat_set s; - s = so; - s = std::move(so); - swap(s, so); -} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/default_noexcept.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/default_noexcept.pass.cpp deleted file mode 100644 index b4a3b6de205a3..0000000000000 --- a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/default_noexcept.pass.cpp +++ /dev/null @@ -1,58 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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() -// noexcept( -// is_nothrow_default_constructible_v && -// is_nothrow_default_constructible_v); - -// This tests a conforming extension - -#include -#include -#include -#include - -#include "test_macros.h" -#include "MoveOnly.h" -#include "test_allocator.h" - -struct ThrowingCtorComp { - ThrowingCtorComp() noexcept(false) {} - bool operator()(const auto&, const auto&) const { return false; } -}; - -int main(int, char**) { -#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; - } - return 0; -} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_assign_clears.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_assign_clears.pass.cpp deleted file mode 100644 index 50817f4be8a81..0000000000000 --- a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_assign_clears.pass.cpp +++ /dev/null @@ -1,101 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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&&); -// Preserves the class invariant for the moved-from flat_set. - -#include -#include -#include -#include -#include -#include -#include - -#include "../helpers.h" -#include "test_macros.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; -}; - -int main(int, char**) { - { - 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()); - } - return 0; -} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_assign_noexcept.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_assign_noexcept.pass.cpp deleted file mode 100644 index 86f3568f0d67a..0000000000000 --- a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_assign_noexcept.pass.cpp +++ /dev/null @@ -1,85 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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&& c) -// noexcept( -// is_nothrow_move_assignable::value && -// is_nothrow_move_assignable::value && -// is_nothrow_copy_assignable::value); - -// This tests a conforming extension - -#include -#include -#include -#include -#include - -#include "MoveOnly.h" -#include "test_allocator.h" -#include "test_macros.h" - -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; -}; - -int main(int, char**) { - { - 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); - } - - return 0; -} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_exceptions.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_exceptions.pass.cpp deleted file mode 100644 index 17e4e40387606..0000000000000 --- a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_exceptions.pass.cpp +++ /dev/null @@ -1,58 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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 - -// - -// flat_set(flat_set&& s); -// If any member function in [flat.map.defn] exits via an exception, the invariant is restored. - -#include -#include -#include -#include -#include -#include - -#include "../helpers.h" -#include "test_macros.h" - -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; - } - } -}; - -int main(int, char**) { - { - 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()); - } - - return 0; -} diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_noexcept.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_noexcept.pass.cpp deleted file mode 100644 index 49d1151fd8a99..0000000000000 --- a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.cons/move_noexcept.pass.cpp +++ /dev/null @@ -1,94 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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&&) -// noexcept(is_nothrow_move_constructible::value && -// is_nothrow_move_constructible::value && -// is_nothrow_copy_constructible::value); - -// This tests a conforming extension - -#include -#include -#include -#include -#include -#include -#include - -#include "test_macros.h" -#include "MoveOnly.h" -#include "test_allocator.h" - -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; -}; - -int main(int, char**) { - { - 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); - } - 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 index d7d7a98f49d77..d75a5c576abb6 100644 --- 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 @@ -94,6 +94,16 @@ void test() { test_one>(); } +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(); 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 index 5ecdc429b3c58..87f9e1a965d29 100644 --- 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 @@ -67,6 +67,15 @@ void test() { test_one>>(); } +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>(); + test_one>>(); + test_one>>(); +} + int main(int, char**) { test(); 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 index 686fe93a593f5..ed13ba1ef3fea 100644 --- 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 @@ -24,6 +24,8 @@ #include "test_macros.h" #include "../helpers.h" +#include "check_assertion.h" + // test noexcept template 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 index e0416fc261ffc..5d731cef4f002 100644 --- 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 @@ -73,6 +73,13 @@ void test() { test_one>>(); } +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + int main(int, char**) { test(); 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 index 51aec21ca212b..0b02f7bacae7d 100644 --- 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 @@ -73,6 +73,13 @@ void test() { test_one>>(); } +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + int main(int, char**) { test(); 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 index 7a8b19273289d..ca5231f441901 100644 --- 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 @@ -81,6 +81,13 @@ void test() { test_one>>(); } +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + int main(int, char**) { test(); 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 index 953b8fe638547..4391c2c0ff8a1 100644 --- 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 @@ -57,6 +57,13 @@ void test() { test_one>>(); } +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + int main(int, char**) { test(); 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 index 32796b7a164f7..eaaa206cf0ada 100644 --- 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 @@ -73,6 +73,13 @@ void test() { test_one>>(); } +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + int main(int, char**) { test(); 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 index 6a967cb2371ba..9574a66dc7400 100644 --- 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 @@ -74,6 +74,13 @@ void test() { test_one>>(); } +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + int main(int, char**) { test(); From b3201e41fac7b783e382b20df67d55eb07832e9b Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Sun, 2 Feb 2025 18:45:39 +0000 Subject: [PATCH 03/23] CI --- libcxx/include/module.modulemap | 1 + 1 file changed, 1 insertion(+) diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap index 0ce42fc4d3633..e1d6059627e88 100644 --- a/libcxx/include/module.modulemap +++ b/libcxx/include/module.modulemap @@ -1306,6 +1306,7 @@ module std [system] { header "__flat_set/flat_set.h" export std.vector.vector export std.vector.fwd + export std.flat_map.sorted_unique } module ra_iterator { header "__flat_set/ra_iterator.h" } From c0c8e247dffd51f6c75d35dc9ed0c5418bd564bc Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Sun, 2 Feb 2025 19:14:41 +0000 Subject: [PATCH 04/23] CI again --- libcxx/include/module.modulemap | 1 - 1 file changed, 1 deletion(-) diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap index e1d6059627e88..0ce42fc4d3633 100644 --- a/libcxx/include/module.modulemap +++ b/libcxx/include/module.modulemap @@ -1306,7 +1306,6 @@ module std [system] { header "__flat_set/flat_set.h" export std.vector.vector export std.vector.fwd - export std.flat_map.sorted_unique } module ra_iterator { header "__flat_set/ra_iterator.h" } From 68fb9d3b71b82508fea57f9b3bab5ea5669ec52b Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Sat, 22 Feb 2025 17:29:12 +0000 Subject: [PATCH 05/23] review --- .../flat.set/flat.set.modifiers/swap_free.pass.cpp | 2 -- 1 file changed, 2 deletions(-) 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 index ed13ba1ef3fea..686fe93a593f5 100644 --- 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 @@ -24,8 +24,6 @@ #include "test_macros.h" #include "../helpers.h" -#include "check_assertion.h" - // test noexcept template From 6a98cf0d74b7fdb9d612b8cec721d2e061ea1265 Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Sat, 22 Feb 2025 10:59:31 +0000 Subject: [PATCH 06/23] update --- libcxx/docs/FeatureTestMacroTable.rst | 2 +- libcxx/docs/Status/Cxx23Papers.csv | 2 +- libcxx/include/CMakeLists.txt | 1 + libcxx/include/__flat_set/flat_multiset.h | 861 ++++++++++++++++++ libcxx/include/flat_set | 17 + libcxx/include/module.modulemap | 1 + libcxx/include/version | 2 +- libcxx/modules/std/flat_set.inc | 4 +- .../flat_set.version.compile.pass.cpp | 32 +- .../version.version.compile.pass.cpp | 32 +- .../generate_feature_test_macro_components.py | 1 - 11 files changed, 904 insertions(+), 51 deletions(-) create mode 100644 libcxx/include/__flat_set/flat_multiset.h diff --git a/libcxx/docs/FeatureTestMacroTable.rst b/libcxx/docs/FeatureTestMacroTable.rst index bbcc76b52f0a9..786b26eaebadc 100644 --- a/libcxx/docs/FeatureTestMacroTable.rst +++ b/libcxx/docs/FeatureTestMacroTable.rst @@ -332,7 +332,7 @@ Status ---------------------------------------------------------- ----------------- ``__cpp_lib_flat_map`` ``202207L`` ---------------------------------------------------------- ----------------- - ``__cpp_lib_flat_set`` *unimplemented* + ``__cpp_lib_flat_set`` ``202207L`` ---------------------------------------------------------- ----------------- ``__cpp_lib_format_ranges`` ``202207L`` ---------------------------------------------------------- ----------------- diff --git a/libcxx/docs/Status/Cxx23Papers.csv b/libcxx/docs/Status/Cxx23Papers.csv index 4e45debd419ef..fab9900ce71aa 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)","|In progress|","","" +"`P1222R4 `__","A Standard ``flat_set``","2022-07 (Virtual)","|Complete|","21","" "`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 a021b9bb44d67..e70e27bcdcf9f 100644 --- a/libcxx/include/CMakeLists.txt +++ b/libcxx/include/CMakeLists.txt @@ -369,6 +369,7 @@ set(files __flat_map/sorted_equivalent.h __flat_map/sorted_unique.h __flat_map/utils.h + __flat_set/flat_multiset.h __flat_set/flat_set.h __flat_set/ra_iterator.h __format/buffer.h diff --git a/libcxx/include/__flat_set/flat_multiset.h b/libcxx/include/__flat_set/flat_multiset.h new file mode 100644 index 0000000000000..6aa160f0af54b --- /dev/null +++ b/libcxx/include/__flat_set/flat_multiset.h @@ -0,0 +1,861 @@ +// -*- 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_MAP_FLAT_MULTISET_H +#define _LIBCPP___FLAT_MAP_FLAT_MULTISET_H + +#include <__algorithm/lexicographical_compare_three_way.h> +#include <__algorithm/min.h> +#include <__algorithm/ranges_equal.h> +#include <__algorithm/ranges_equal_range.h> +#include <__algorithm/ranges_inplace_merge.h> +#include <__algorithm/ranges_is_sorted.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/convertible_to.h> +#include <__concepts/swappable.h> +#include <__config> +#include <__cstddef/byte.h> +#include <__cstddef/ptrdiff_t.h> +#include <__flat_map/key_value_iterator.h> +#include <__flat_map/sorted_equivalent.h> +#include <__flat_map/utils.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/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 <__ranges/zip_view.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_nothrow_constructible.h> +#include <__type_traits/is_same.h> +#include <__type_traits/maybe_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 +#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_multiset { + template + friend class flat_multiset; + + static_assert(is_same_v<_Key, typename _KeyContainer::value_type>); + static_assert(!is_same_v<_KeyContainer, std::vector>, "vector is not a sequence container"); + +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 = typename _KeyContainer::const_iterator; + using const_iterator = iterator; + using reverse_iterator = std::reverse_iterator; + using const_reverse_iterator = std::reverse_iterator; + using container_type = _KeyContainer; + +public: + // [flat.multiset.cons], constructors + _LIBCPP_HIDE_FROM_ABI flat_multiset() noexcept(is_nothrow_default_constructible_v<_KeyContainer> && + is_nothrow_default_constructible_v<_Compare>) + : __keys_(), __compare_() {} + + _LIBCPP_HIDE_FROM_ABI flat_multiset(const flat_multiset&) = default; + + // The copy/move constructors are not specified in the spec, which means they should be defaulted. + // However, the move constructor can potentially leave a moved-from object in an inconsistent + // state if an exception is thrown. + _LIBCPP_HIDE_FROM_ABI flat_multiset(flat_multiset&& __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_multiset(const key_compare& __comp) : __keys_(), __compare_(__comp) {} + + _LIBCPP_HIDE_FROM_ABI explicit flat_multiset(container_type __keys, const key_compare& __comp = key_compare()) + : __keys_(std::move(__keys)), __compare_(__comp) { + ranges::sort(__keys_, __compare_); + } + + _LIBCPP_HIDE_FROM_ABI + flat_multiset(sorted_equivalent_t, container_type __keys, const key_compare& __comp = key_compare()) + : __keys_(std::move(__keys)), __compare_(__comp) { + _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(ranges::is_sorted(__keys_, __compare_), "Key container is not sorted"); + } + + template + requires __has_input_iterator_category<_InputIterator>::value + _LIBCPP_HIDE_FROM_ABI + flat_multiset(_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_multiset( + sorted_equivalent_t, _InputIterator __first, _InputIterator __last, const key_compare& __comp = key_compare()) + : __keys_(__first, __last), __compare_(__comp) { + _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(ranges::is_sorted(__keys_, __compare_), "Key container is not sorted"); + } + + template <_ContainerCompatibleRange _Range> + _LIBCPP_HIDE_FROM_ABI flat_multiset(from_range_t __fr, _Range&& __rg) + : flat_multiset(__fr, std::forward<_Range>(__rg), key_compare()) {} + + template <_ContainerCompatibleRange _Range> + _LIBCPP_HIDE_FROM_ABI flat_multiset(from_range_t, _Range&& __rg, const key_compare& __comp) : flat_multiset(__comp) { + insert_range(std::forward<_Range>(__rg)); + } + + _LIBCPP_HIDE_FROM_ABI flat_multiset(initializer_list __il, const key_compare& __comp = key_compare()) + : flat_multiset(__il.begin(), __il.end(), __comp) {} + + _LIBCPP_HIDE_FROM_ABI + flat_multiset(sorted_equivalent_t, initializer_list __il, const key_compare& __comp = key_compare()) + : flat_multiset(sorted_equivalent, __il.begin(), __il.end(), __comp) {} + + template + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI explicit flat_multiset(const _Allocator& __alloc) + : __keys_(std::make_obj_using_allocator(__alloc)), __compare_() {} + + template + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI flat_multiset(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_multiset(const container_type& __keys, const _Allocator& __alloc) + : __keys_(std::make_obj_using_allocator(__alloc, __keys)), __compare_() { + ranges::sort(__keys_, __compare_); + } + + template + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI + flat_multiset(const container_type& __keys, const key_compare& __comp, const _Allocator& __alloc) + : __keys_(std::make_obj_using_allocator(__alloc, __keys)), __compare_(__comp) { + ranges::sort(__keys_, __compare_); + } + + template + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI flat_multiset(sorted_equivalent_t, const container_type& __keys, const _Allocator& __alloc) + : __keys_(std::make_obj_using_allocator(__alloc, __keys)), __compare_() { + _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(ranges::is_sorted(__keys_, __compare_), "Key container is not sorted"); + } + + template + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI + flat_multiset(sorted_equivalent_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(ranges::is_sorted(__keys_, __compare_), "Key container is not sorted"); + } + + template + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI flat_multiset(const flat_multiset& __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_multiset(flat_multiset&& __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_multiset(_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_multiset(_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_multiset(sorted_equivalent_t, _InputIterator __first, _InputIterator __last, const _Allocator& __alloc) + : __keys_(std::make_obj_using_allocator(__alloc, __first, __last)), __compare_() { + _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(ranges::is_sorted(__keys_, __compare_), "Key container is not sorted"); + } + + template + requires(__has_input_iterator_category<_InputIterator>::value && uses_allocator::value) + _LIBCPP_HIDE_FROM_ABI + flat_multiset(sorted_equivalent_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(ranges::is_sorted(__keys_, __compare_), "Key container is not sorted"); + } + + template <_ContainerCompatibleRange _Range, class _Allocator> + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI flat_multiset(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_multiset(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_multiset(initializer_list __il, const _Allocator& __alloc) + : flat_multiset(__il.begin(), __il.end(), __alloc) {} + + template + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI + flat_multiset(initializer_list __il, const key_compare& __comp, const _Allocator& __alloc) + : flat_multiset(__il.begin(), __il.end(), __comp, __alloc) {} + + template + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI flat_multiset(sorted_equivalent_t, initializer_list __il, const _Allocator& __alloc) + : flat_multiset(sorted_equivalent, __il.begin(), __il.end(), __alloc) {} + + template + requires uses_allocator::value + _LIBCPP_HIDE_FROM_ABI flat_multiset( + sorted_equivalent_t, initializer_list __il, const key_compare& __comp, const _Allocator& __alloc) + : flat_multiset(sorted_equivalent, __il.begin(), __il.end(), __comp, __alloc) {} + + _LIBCPP_HIDE_FROM_ABI flat_multiset& operator=(initializer_list __il) { + clear(); + insert(__il); + return *this; + } + + // copy/move assignment are not specified in the spec (defaulted) + // but move assignment can potentially leave moved from object in an inconsistent + // state if an exception is thrown + _LIBCPP_HIDE_FROM_ABI flat_multiset& operator=(const flat_multiset&) = default; + + _LIBCPP_HIDE_FROM_ABI flat_multiset& operator=(flat_multiset&& __other) noexcept( + is_nothrow_move_assignable_v<_KeyContainer> && is_nothrow_move_assignable_v<_Compare>) { + auto __clear_other_guard = std::__make_scope_guard([&]() noexcept { __other.clear() /* noexcept */; }); + auto __clear_self_guard = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; }); + __keys_ = std::move(__other.__keys_); + __compare_ = std::move(__other.__compare_); + __clear_self_guard.__complete(); + return *this; + } + + // iterators + _LIBCPP_HIDE_FROM_ABI iterator begin() noexcept { return __keys_.begin(); } + _LIBCPP_HIDE_FROM_ABI const_iterator begin() const noexcept { return __keys_.begin(); } + _LIBCPP_HIDE_FROM_ABI iterator end() noexcept { return __keys_.end(); } + _LIBCPP_HIDE_FROM_ABI const_iterator end() const noexcept { return __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()); } + + // 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.multiset.modifiers], modifiers + template + requires is_constructible_v + _LIBCPP_HIDE_FROM_ABI iterator emplace(_Args&&... __args) { + auto __key_it = ranges::upper_bound(__containers_.keys, __pair.first, __compare_); + auto __mapped_it = __corresponding_mapped_it(*this, __key_it); + + return __flat_map_utils::__emplace_exact_pos( + *this, std::move(__key_it), std::move(__mapped_it), std::move(__pair.first), std::move(__pair.second)); + } + + template + requires is_constructible_v + _LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator __hint, _Args&&... __args) { + std::pair __pair(std::forward<_Args>(__args)...); + + auto __prev_larger = __hint != cbegin() && __compare_(__pair.first, (__hint - 1)->first); + auto __next_smaller = __hint != cend() && __compare_(__hint->first, __pair.first); + + auto __hint_distance = __hint.__key_iter_ - __containers_.keys.cbegin(); + auto __key_iter = __containers_.keys.begin() + __hint_distance; + auto __mapped_iter = __containers_.values.begin() + __hint_distance; + + if (!__prev_larger && !__next_smaller) [[likely]] { + // hint correct, just use exact hint iterators + } else if (__prev_larger && !__next_smaller) { + // the hint position is more to the right than the key should have been. + // we want to emplace the element to a position as right as possible + // e.g. Insert new element "2" in the following range + // 1, 1, 2, 2, 2, 3, 4, 6 + // ^ + // | + // hint + // We want to insert "2" after the last existing "2" + __key_iter = ranges::upper_bound(__containers_.keys.begin(), __key_iter, __pair.first, __compare_); + __mapped_iter = __corresponding_mapped_it(*this, __key_iter); + } else { + _LIBCPP_ASSERT_INTERNAL(!__prev_larger && __next_smaller, "this means that the multiset is not sorted"); + + // the hint position is more to the left than the key should have been. + // we want to emplace the element to a position as left as possible + // 1, 1, 2, 2, 2, 3, 4, 6 + // ^ + // | + // hint + // We want to insert "2" before the first existing "2" + __key_iter = ranges::lower_bound(__key_iter, __containers_.keys.end(), __pair.first, __compare_); + __mapped_iter = __corresponding_mapped_it(*this, __key_iter); + } + return __flat_map_utils::__emplace_exact_pos( + *this, __key_iter, __mapped_iter, std::move(__pair.first), std::move(__pair.second)); + } + + _LIBCPP_HIDE_FROM_ABI iterator insert(const value_type& __x) { return emplace(__x); } + + _LIBCPP_HIDE_FROM_ABI iterator insert(value_type&& __x) { return emplace(std::move(__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 __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(std::move(__first), std::move(__last)); + } + + template + requires __has_input_iterator_category<_InputIterator>::value + _LIBCPP_HIDE_FROM_ABI void insert(sorted_equivalent_t, _InputIterator __first, _InputIterator __last) { + if constexpr (sized_sentinel_for<_InputIterator, _InputIterator>) { + __reserve(__last - __first); + } + + __append_sort_merge(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(ranges::begin(__range), ranges::end(__range)); + } + + _LIBCPP_HIDE_FROM_ABI void insert(initializer_list __il) { insert(__il.begin(), __il.end()); } + + _LIBCPP_HIDE_FROM_ABI void insert(sorted_equivalent_t, initializer_list __il) { + insert(sorted_equivalent, __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(ranges::is_sorted(__keys, __compare_), "Key container is not sorted"); + auto __guard = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; }); + __keys_ = std::move(__keys); + __guard.__complete(); + } + + _LIBCPP_HIDE_FROM_ABI iterator erase(iterator __position) { + return __erase(__position.__key_iter_, __position.__mapped_iter_); + } + + // iterator and const_iterator are the same type + // iterator erase(const_iterator __position); + + _LIBCPP_HIDE_FROM_ABI size_type erase(const key_type& __x) { + auto [__first, __last] = equal_range(__x); + auto __res = __last - __first; + erase(__first, __last); + return __res; + } + + template + requires(__is_compare_transparent && !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 = __containers_.keys.erase(__first.__key_iter_, __last.__key_iter_); + auto __mapped_it = __containers_.values.erase(__first.__mapped_iter_, __last.__mapped_iter_); + __on_failure.__complete(); + return iterator(std::move(__key_it), std::move(__mapped_it)); + } + + _LIBCPP_HIDE_FROM_ABI void swap(flat_multiset& __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 + ranges::swap(__compare_, __y.__compare_); + ranges::swap(__containers_.keys, __y.__containers_.keys); + ranges::swap(__containers_.values, __y.__containers_.values); + } + + _LIBCPP_HIDE_FROM_ABI void clear() noexcept { + __containers_.keys.clear(); + __containers_.values.clear(); + } + + // observers + _LIBCPP_HIDE_FROM_ABI key_compare key_comp() const { return __compare_; } + _LIBCPP_HIDE_FROM_ABI value_compare value_comp() const { return value_compare(__compare_); } + + _LIBCPP_HIDE_FROM_ABI const key_container_type& keys() const noexcept { return __containers_.keys; } + _LIBCPP_HIDE_FROM_ABI const mapped_container_type& values() const noexcept { return __containers_.values; } + + // map 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_compare_transparent + _LIBCPP_HIDE_FROM_ABI iterator find(const _Kp& __x) { + return __find_impl(*this, __x); + } + + template + requires __is_compare_transparent + _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 { + auto [__first, __last] = equal_range(__x); + return __last - __first; + } + + template + requires __is_compare_transparent + _LIBCPP_HIDE_FROM_ABI size_type count(const _Kp& __x) const { + auto [__first, __last] = equal_range(__x); + return __last - __first; + } + + _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __x) const { return find(__x) != end(); } + + template + requires __is_compare_transparent + _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 __lower_bound(*this, __x); } + + _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const key_type& __x) const { + return __lower_bound(*this, __x); + } + + template + requires __is_compare_transparent + _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _Kp& __x) { + return __lower_bound(*this, __x); + } + + template + requires __is_compare_transparent + _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _Kp& __x) const { + return __lower_bound(*this, __x); + } + + _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __x) { return __upper_bound(*this, __x); } + + _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const key_type& __x) const { + return __upper_bound(*this, __x); + } + + template + requires __is_compare_transparent + _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _Kp& __x) { + return __upper_bound(*this, __x); + } + + template + requires __is_compare_transparent + _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _Kp& __x) const { + return __upper_bound(*this, __x); + } + + _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_compare_transparent + _LIBCPP_HIDE_FROM_ABI pair equal_range(const _Kp& __x) { + return __equal_range_impl(*this, __x); + } + template + requires __is_compare_transparent + _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_multiset& __x, const flat_multiset& __y) { + return ranges::equal(__x, __y); + } + + friend _LIBCPP_HIDE_FROM_ABI auto operator<=>(const flat_multiset& __x, const flat_multiset& __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_multiset& __x, flat_multiset& __y) noexcept { __x.swap(__y); } + +private: + template + _LIBCPP_HIDE_FROM_ABI void __append_sort_merge(_InputIterator __first, _Sentinel __last) { + auto __on_failure = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; }); + size_t __num_appended = __flat_map_utils::__append(*this, std::move(__first), std::move(__last)); + if (__num_appended != 0) { + auto __zv = ranges::views::zip(__containers_.keys, __containers_.values); + auto __append_start_offset = __containers_.keys.size() - __num_appended; + auto __end = __zv.end(); + auto __compare_key = [this](const auto& __p1, const auto& __p2) { + return __compare_(std::get<0>(__p1), std::get<0>(__p2)); + }; + if constexpr (!_WasSorted) { + ranges::sort(__zv.begin() + __append_start_offset, __end, __compare_key); + } else { + _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT( + __is_sorted(__containers_.keys | ranges::views::drop(__append_start_offset)), + "Key container is not sorted"); + } + ranges::inplace_merge(__zv.begin(), __zv.begin() + __append_start_offset, __end, __compare_key); + } + __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->first)) { + return __last; + } + return __it; + } + + template + _LIBCPP_HIDE_FROM_ABI static auto __equal_range_impl(_Self&& __self, const _Kp& __key) { + auto [__key_first, __key_last] = ranges::equal_range(__self.__containers_.keys, __key, __self.__compare_); + + using __iterator_type = ranges::iterator_t; + return std::make_pair(__iterator_type(__key_first, __corresponding_mapped_it(__self, __key_first)), + __iterator_type(__key_last, __corresponding_mapped_it(__self, __key_last))); + } + + template + _LIBCPP_HIDE_FROM_ABI static _Res __lower_bound(_Self&& __self, _Kp& __x) { + auto __key_iter = ranges::lower_bound(__self.__containers_.keys, __x, __self.__compare_); + auto __mapped_iter = __corresponding_mapped_it(__self, __key_iter); + return _Res(std::move(__key_iter), std::move(__mapped_iter)); + } + + template + _LIBCPP_HIDE_FROM_ABI static _Res __upper_bound(_Self&& __self, _Kp& __x) { + auto __key_iter = ranges::upper_bound(__self.__containers_.keys, __x, __self.__compare_); + auto __mapped_iter = __corresponding_mapped_it(__self, __key_iter); + return _Res(std::move(__key_iter), std::move(__mapped_iter)); + } + + _LIBCPP_HIDE_FROM_ABI void __reserve(size_t __size) { + if constexpr (requires { __containers_.keys.reserve(__size); }) { + __containers_.keys.reserve(__size); + } + + if constexpr (requires { __containers_.values.reserve(__size); }) { + __containers_.values.reserve(__size); + } + } + + template + _LIBCPP_HIDE_FROM_ABI iterator __erase(_KIter __key_iter_to_remove, _MIter __mapped_iter_to_remove) { + auto __on_failure = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; }); + auto __key_iter = __containers_.keys.erase(__key_iter_to_remove); + auto __mapped_iter = __containers_.values.erase(__mapped_iter_to_remove); + __on_failure.__complete(); + return iterator(std::move(__key_iter), std::move(__mapped_iter)); + } + + template + friend typename flat_multiset<_Key2, _Tp2, _Compare2, _KeyContainer2, _MappedContainer2>::size_type + erase_if(flat_multiset<_Key2, _Tp2, _Compare2, _KeyContainer2, _MappedContainer2>&, _Predicate); + + friend __flat_map_utils; + + _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_(std::get<0>(__x), std::get<0>(__y)) && !__comp_(std::get<0>(__y), std::get<0>(__x)); + } + key_compare __comp_; + }; +}; + +template > + requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value && + !__is_allocator<_MappedContainer>::value && + is_invocable_v) +flat_multiset(_KeyContainer, _MappedContainer, _Compare = _Compare()) + -> flat_multiset; + +template + requires(uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator> && + !__is_allocator<_KeyContainer>::value && !__is_allocator<_MappedContainer>::value) +flat_multiset(_KeyContainer, _MappedContainer, _Allocator) + -> flat_multiset, + _KeyContainer, + _MappedContainer>; + +template + requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value && + !__is_allocator<_MappedContainer>::value && uses_allocator_v<_KeyContainer, _Allocator> && + uses_allocator_v<_MappedContainer, _Allocator> && + is_invocable_v) +flat_multiset(_KeyContainer, _MappedContainer, _Compare, _Allocator) + -> flat_multiset; + +template > + requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value && + !__is_allocator<_MappedContainer>::value && + is_invocable_v) +flat_multiset(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Compare = _Compare()) + -> flat_multiset; + +template + requires(uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator> && + !__is_allocator<_KeyContainer>::value && !__is_allocator<_MappedContainer>::value) +flat_multiset(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Allocator) + -> flat_multiset, + _KeyContainer, + _MappedContainer>; + +template + requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value && + !__is_allocator<_MappedContainer>::value && uses_allocator_v<_KeyContainer, _Allocator> && + uses_allocator_v<_MappedContainer, _Allocator> && + is_invocable_v) +flat_multiset(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Compare, _Allocator) + -> flat_multiset; + +template >> + requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator<_Compare>::value) +flat_multiset(_InputIterator, _InputIterator, _Compare = _Compare()) + -> flat_multiset<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare>; + +template >> + requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator<_Compare>::value) +flat_multiset(sorted_equivalent_t, _InputIterator, _InputIterator, _Compare = _Compare()) + -> flat_multiset<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare>; + +template >, + class _Allocator = allocator, + class = __enable_if_t::value && __is_allocator<_Allocator>::value>> +flat_multiset(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator()) -> flat_multiset< + __range_key_type<_Range>, + __range_mapped_type<_Range>, + _Compare, + vector<__range_key_type<_Range>, __allocator_traits_rebind_t<_Allocator, __range_key_type<_Range>>>, + vector<__range_mapped_type<_Range>, __allocator_traits_rebind_t<_Allocator, __range_mapped_type<_Range>>>>; + +template ::value>> +flat_multiset(from_range_t, _Range&&, _Allocator) -> flat_multiset< + __range_key_type<_Range>, + __range_mapped_type<_Range>, + less<__range_key_type<_Range>>, + vector<__range_key_type<_Range>, __allocator_traits_rebind_t<_Allocator, __range_key_type<_Range>>>, + vector<__range_mapped_type<_Range>, __allocator_traits_rebind_t<_Allocator, __range_mapped_type<_Range>>>>; + +template > + requires(!__is_allocator<_Compare>::value) +flat_multiset(initializer_list>, _Compare = _Compare()) -> flat_multiset<_Key, _Tp, _Compare>; + +template > + requires(!__is_allocator<_Compare>::value) +flat_multiset(sorted_equivalent_t, initializer_list>, _Compare = _Compare()) + -> flat_multiset<_Key, _Tp, _Compare>; + +template +struct uses_allocator, _Allocator> + : bool_constant && uses_allocator_v<_MappedContainer, _Allocator>> {}; + +template +_LIBCPP_HIDE_FROM_ABI typename flat_multiset<_Key, _Tp, _Compare, _KeyContainer, _MappedContainer>::size_type +erase_if(flat_multiset<_Key, _Tp, _Compare, _KeyContainer, _MappedContainer>& __flat_multiset, _Predicate __pred) { + auto __zv = ranges::views::zip(__flat_multiset.__containers_.keys, __flat_multiset.__containers_.values); + auto __first = __zv.begin(); + auto __last = __zv.end(); + auto __guard = std::__make_exception_guard([&] { __flat_multiset.clear(); }); + auto __it = std::remove_if(__first, __last, [&](auto&& __zipped) -> bool { + using _Ref = typename flat_multiset<_Key, _Tp, _Compare, _KeyContainer, _MappedContainer>::const_reference; + return __pred(_Ref(std::get<0>(__zipped), std::get<1>(__zipped))); + }); + auto __res = __last - __it; + auto __offset = __it - __first; + + const auto __erase_container = [&](auto& __cont) { __cont.erase(__cont.begin() + __offset, __cont.end()); }; + + __erase_container(__flat_multiset.__containers_.keys); + __erase_container(__flat_multiset.__containers_.values); + + __guard.__complete(); + return __res; +} + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP_STD_VER >= 23 + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___FLAT_MAP_FLAT_MULTISET_H diff --git a/libcxx/include/flat_set b/libcxx/include/flat_set index d03645fafafdb..5051b27097d2a 100644 --- a/libcxx/include/flat_set +++ b/libcxx/include/flat_set @@ -31,6 +31,21 @@ namespace std { template typename flat_set::size_type erase_if(flat_set& c, Predicate pred); + + // [flat.multiset], class template flat_multiset + template, class KeyContainer = vector> + class flat_multiset; + + struct sorted_equivalent_t { explicit sorted_equivalent_t() = default; }; + inline constexpr sorted_equivalent_t sorted_equivalent{}; + + template + struct uses_allocator, Allocator>; + + // [flat.multiset.erasure], erasure for flat_multiset + template + typename flat_multiset::size_type + erase_if(flat_multiset& c, Predicate pred); } */ @@ -41,7 +56,9 @@ namespace std { # if _LIBCPP_STD_VER >= 23 # include <__flat_map/sorted_unique.h> +# include <__flat_map/sorted_equivalent.h> # include <__flat_set/flat_set.h> +# include <__flat_set/flat_multiset.h> # endif // for feature-test macros diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap index 0ce42fc4d3633..8bcbf67eb6165 100644 --- a/libcxx/include/module.modulemap +++ b/libcxx/include/module.modulemap @@ -1311,6 +1311,7 @@ module std [system] { header "flat_set" export std.flat_map.sorted_unique + export std.flat_map.sorted_equivalent export * } diff --git a/libcxx/include/version b/libcxx/include/version index 83ae11dabd2bc..afdb029cebfb1 100644 --- a/libcxx/include/version +++ b/libcxx/include/version @@ -486,7 +486,7 @@ __cpp_lib_void_t 201411L # define __cpp_lib_containers_ranges 202202L # define __cpp_lib_expected 202211L # define __cpp_lib_flat_map 202207L -// # define __cpp_lib_flat_set 202207L +# define __cpp_lib_flat_set 202207L # define __cpp_lib_format_ranges 202207L // # define __cpp_lib_formatters 202302L # define __cpp_lib_forward_like 202207L diff --git a/libcxx/modules/std/flat_set.inc b/libcxx/modules/std/flat_set.inc index 3f2c6e09a0ebe..51f39b75458b9 100644 --- a/libcxx/modules/std/flat_set.inc +++ b/libcxx/modules/std/flat_set.inc @@ -19,13 +19,11 @@ 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; using std::sorted_equivalent; using std::sorted_equivalent_t; -#endif +#endif // _LIBCPP_STD_VER >= 23 } // namespace std 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 index f9d0b0a6b4e4f..1d96845288b29 100644 --- 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 @@ -48,32 +48,20 @@ #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 +# 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 #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 +# 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 #endif // TEST_STD_VER > 23 diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp index e5a657207923b..915e5115ff238 100644 --- a/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp +++ b/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp @@ -5128,17 +5128,11 @@ # error "__cpp_lib_flat_map should have the value 202207L in c++23" # endif -# 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 +# 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 # if !defined(_LIBCPP_VERSION) || _LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT @@ -6841,17 +6835,11 @@ # error "__cpp_lib_flat_map should have the value 202207L in c++26" # endif -# 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 +# 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 # if !defined(_LIBCPP_VERSION) || _LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT diff --git a/libcxx/utils/generate_feature_test_macro_components.py b/libcxx/utils/generate_feature_test_macro_components.py index 53252d5e2d673..fef22ee6264d5 100755 --- a/libcxx/utils/generate_feature_test_macro_components.py +++ b/libcxx/utils/generate_feature_test_macro_components.py @@ -520,7 +520,6 @@ def add_version_header(tc): "name": "__cpp_lib_flat_set", "values": {"c++23": 202207}, "headers": ["flat_set"], - "unimplemented": True, }, { "name": "__cpp_lib_format", From ca34b383f982bb1ab2bd5fcc933a4611ffa4df77 Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Sun, 9 Mar 2025 13:56:27 +0000 Subject: [PATCH 07/23] build --- libcxx/include/__flat_set/flat_multiset.h | 361 +++++++++------------- 1 file changed, 151 insertions(+), 210 deletions(-) diff --git a/libcxx/include/__flat_set/flat_multiset.h b/libcxx/include/__flat_set/flat_multiset.h index 6aa160f0af54b..6ad62a75da464 100644 --- a/libcxx/include/__flat_set/flat_multiset.h +++ b/libcxx/include/__flat_set/flat_multiset.h @@ -31,7 +31,7 @@ #include <__cstddef/ptrdiff_t.h> #include <__flat_map/key_value_iterator.h> #include <__flat_map/sorted_equivalent.h> -#include <__flat_map/utils.h> +#include <__flat_set/ra_iterator.h> #include <__functional/invoke.h> #include <__functional/is_transparent.h> #include <__functional/operations.h> @@ -60,13 +60,13 @@ #include <__type_traits/is_nothrow_constructible.h> #include <__type_traits/is_same.h> #include <__type_traits/maybe_const.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 -#include #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) # pragma GCC system_header @@ -97,7 +97,7 @@ class flat_multiset { using const_reference = const value_type&; using size_type = typename _KeyContainer::size_type; using difference_type = typename _KeyContainer::difference_type; - using iterator = typename _KeyContainer::const_iterator; + using iterator = __ra_iterator; using const_iterator = iterator; using reverse_iterator = std::reverse_iterator; using const_reverse_iterator = std::reverse_iterator; @@ -331,10 +331,10 @@ class flat_multiset { } // iterators - _LIBCPP_HIDE_FROM_ABI iterator begin() noexcept { return __keys_.begin(); } - _LIBCPP_HIDE_FROM_ABI const_iterator begin() const noexcept { return __keys_.begin(); } - _LIBCPP_HIDE_FROM_ABI iterator end() noexcept { return __keys_.end(); } - _LIBCPP_HIDE_FROM_ABI const_iterator end() const noexcept { return __keys_.end(); } + _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()); } @@ -353,18 +353,24 @@ class flat_multiset { // [flat.multiset.modifiers], modifiers template - requires is_constructible_v - _LIBCPP_HIDE_FROM_ABI iterator emplace(_Args&&... __args) { - auto __key_it = ranges::upper_bound(__containers_.keys, __pair.first, __compare_); - auto __mapped_it = __corresponding_mapped_it(*this, __key_it); - - return __flat_map_utils::__emplace_exact_pos( - *this, std::move(__key_it), std::move(__mapped_it), std::move(__pair.first), std::move(__pair.second)); + requires is_constructible_v + _LIBCPP_HIDE_FROM_ABI iterator emplace(_Args&&... __args) { + if constexpr (sizeof...(__args) == 1 && (is_same_v, _Key> && ...)) { + return __try_emplace(std::forward<_Args>(__args)...); + } else { + return __try_emplace(_Key(std::forward<_Args>(__args)...)); + } } template - requires is_constructible_v + requires is_constructible_v _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)...)); + } + /* std::pair __pair(std::forward<_Args>(__args)...); auto __prev_larger = __hint != cbegin() && __compare_(__pair.first, (__hint - 1)->first); @@ -402,6 +408,7 @@ class flat_multiset { } return __flat_map_utils::__emplace_exact_pos( *this, __key_iter, __mapped_iter, std::move(__pair.first), std::move(__pair.second)); + */ } _LIBCPP_HIDE_FROM_ABI iterator insert(const value_type& __x) { return emplace(__x); } @@ -458,13 +465,16 @@ class flat_multiset { _LIBCPP_HIDE_FROM_ABI void replace(container_type&& __keys) { _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(ranges::is_sorted(__keys, __compare_), "Key container is not sorted"); - auto __guard = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; }); - __keys_ = std::move(__keys); + auto __guard = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; }); + __keys_ = std::move(__keys); __guard.__complete(); } _LIBCPP_HIDE_FROM_ABI iterator erase(iterator __position) { - return __erase(__position.__key_iter_, __position.__mapped_iter_); + auto __on_failure = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; }); + auto __key_iter = __keys_.erase(__position.__base()); + __on_failure.__complete(); + return iterator(__key_iter); } // iterator and const_iterator are the same type @@ -478,7 +488,7 @@ class flat_multiset { } template - requires(__is_compare_transparent && !is_convertible_v<_Kp &&, iterator> && + 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); @@ -489,32 +499,25 @@ class flat_multiset { _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 = __containers_.keys.erase(__first.__key_iter_, __last.__key_iter_); - auto __mapped_it = __containers_.values.erase(__first.__mapped_iter_, __last.__mapped_iter_); + auto __key_it = __keys_.erase(__first.__base(), __last.__base()); __on_failure.__complete(); - return iterator(std::move(__key_it), std::move(__mapped_it)); + return iterator(std::move(__key_it)); } _LIBCPP_HIDE_FROM_ABI void swap(flat_multiset& __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(__containers_.keys, __y.__containers_.keys); - ranges::swap(__containers_.values, __y.__containers_.values); + ranges::swap(__keys_, __y.__keys_); } - _LIBCPP_HIDE_FROM_ABI void clear() noexcept { - __containers_.keys.clear(); - __containers_.values.clear(); - } + _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 value_compare(__compare_); } - - _LIBCPP_HIDE_FROM_ABI const key_container_type& keys() const noexcept { return __containers_.keys; } - _LIBCPP_HIDE_FROM_ABI const mapped_container_type& values() const noexcept { return __containers_.values; } + _LIBCPP_HIDE_FROM_ABI value_compare value_comp() const { return __compare_; } // map operations _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __x) { return __find_impl(*this, __x); } @@ -522,13 +525,13 @@ class flat_multiset { _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __x) const { return __find_impl(*this, __x); } template - requires __is_compare_transparent + requires __is_transparent_v<_Compare> _LIBCPP_HIDE_FROM_ABI iterator find(const _Kp& __x) { return __find_impl(*this, __x); } template - requires __is_compare_transparent + requires __is_transparent_v<_Compare> _LIBCPP_HIDE_FROM_ABI const_iterator find(const _Kp& __x) const { return __find_impl(*this, __x); } @@ -539,7 +542,7 @@ class flat_multiset { } template - requires __is_compare_transparent + requires __is_transparent_v<_Compare> _LIBCPP_HIDE_FROM_ABI size_type count(const _Kp& __x) const { auto [__first, __last] = equal_range(__x); return __last - __first; @@ -548,45 +551,49 @@ class flat_multiset { _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __x) const { return find(__x) != end(); } template - requires __is_compare_transparent + 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 __lower_bound(*this, __x); } + _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 __lower_bound(*this, __x); + return const_iterator(ranges::lower_bound(__keys_, __x, __compare_)); } template - requires __is_compare_transparent + requires __is_transparent_v<_Compare> _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _Kp& __x) { - return __lower_bound(*this, __x); + return iterator(ranges::lower_bound(std::as_const(__keys_), __x, __compare_)); } template - requires __is_compare_transparent + requires __is_transparent_v<_Compare> _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _Kp& __x) const { - return __lower_bound(*this, __x); + return const_iterator(ranges::lower_bound(__keys_, __x, __compare_)); } - _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __x) { return __upper_bound(*this, __x); } + _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 __upper_bound(*this, __x); + return const_iterator(ranges::upper_bound(__keys_, __x, __compare_)); } template - requires __is_compare_transparent + requires __is_transparent_v<_Compare> _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _Kp& __x) { - return __upper_bound(*this, __x); + return iterator(ranges::upper_bound(std::as_const(__keys_), __x, __compare_)); } template - requires __is_compare_transparent + requires __is_transparent_v<_Compare> _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _Kp& __x) const { - return __upper_bound(*this, __x); + return const_iterator(ranges::upper_bound(__keys_, __x, __compare_)); } _LIBCPP_HIDE_FROM_ABI pair equal_range(const key_type& __x) { @@ -598,12 +605,12 @@ class flat_multiset { } template - requires __is_compare_transparent + requires __is_transparent_v<_Compare> _LIBCPP_HIDE_FROM_ABI pair equal_range(const _Kp& __x) { return __equal_range_impl(*this, __x); } template - requires __is_compare_transparent + requires __is_transparent_v<_Compare> _LIBCPP_HIDE_FROM_ABI pair equal_range(const _Kp& __x) const { return __equal_range_impl(*this, __x); } @@ -620,25 +627,40 @@ class flat_multiset { friend _LIBCPP_HIDE_FROM_ABI void swap(flat_multiset& __x, flat_multiset& __y) noexcept { __x.swap(__y); } private: - template - _LIBCPP_HIDE_FROM_ABI void __append_sort_merge(_InputIterator __first, _Sentinel __last) { - auto __on_failure = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; }); - size_t __num_appended = __flat_map_utils::__append(*this, std::move(__first), std::move(__last)); - if (__num_appended != 0) { - auto __zv = ranges::views::zip(__containers_.keys, __containers_.values); - auto __append_start_offset = __containers_.keys.size() - __num_appended; - auto __end = __zv.end(); - auto __compare_key = [this](const auto& __p1, const auto& __p2) { - return __compare_(std::get<0>(__p1), std::get<0>(__p2)); - }; + // todo: share with flat_set + 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(_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(__zv.begin() + __append_start_offset, __end, __compare_key); + ranges::sort(__keys_.begin() + __old_size, __keys_.end(), __compare_); } else { - _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT( - __is_sorted(__containers_.keys | ranges::views::drop(__append_start_offset)), - "Key container is not sorted"); + _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(__zv.begin(), __zv.begin() + __append_start_offset, __end, __compare_key); + ranges::inplace_merge(__keys_.begin(), __keys_.begin() + __old_size, __keys_.end(), __compare_); } __on_failure.__complete(); } @@ -655,51 +677,14 @@ class flat_multiset { template _LIBCPP_HIDE_FROM_ABI static auto __equal_range_impl(_Self&& __self, const _Kp& __key) { - auto [__key_first, __key_last] = ranges::equal_range(__self.__containers_.keys, __key, __self.__compare_); - - using __iterator_type = ranges::iterator_t; - return std::make_pair(__iterator_type(__key_first, __corresponding_mapped_it(__self, __key_first)), - __iterator_type(__key_last, __corresponding_mapped_it(__self, __key_last))); + using __iter = _If>, const_iterator, iterator>; + auto [__key_first, __key_last] = ranges::equal_range(__self.__keys_, __key, __self.__compare_); + return std::make_pair(__iter(__key_first), __iter(__key_last)); } - template - _LIBCPP_HIDE_FROM_ABI static _Res __lower_bound(_Self&& __self, _Kp& __x) { - auto __key_iter = ranges::lower_bound(__self.__containers_.keys, __x, __self.__compare_); - auto __mapped_iter = __corresponding_mapped_it(__self, __key_iter); - return _Res(std::move(__key_iter), std::move(__mapped_iter)); - } - - template - _LIBCPP_HIDE_FROM_ABI static _Res __upper_bound(_Self&& __self, _Kp& __x) { - auto __key_iter = ranges::upper_bound(__self.__containers_.keys, __x, __self.__compare_); - auto __mapped_iter = __corresponding_mapped_it(__self, __key_iter); - return _Res(std::move(__key_iter), std::move(__mapped_iter)); - } - - _LIBCPP_HIDE_FROM_ABI void __reserve(size_t __size) { - if constexpr (requires { __containers_.keys.reserve(__size); }) { - __containers_.keys.reserve(__size); - } - - if constexpr (requires { __containers_.values.reserve(__size); }) { - __containers_.values.reserve(__size); - } - } - - template - _LIBCPP_HIDE_FROM_ABI iterator __erase(_KIter __key_iter_to_remove, _MIter __mapped_iter_to_remove) { - auto __on_failure = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; }); - auto __key_iter = __containers_.keys.erase(__key_iter_to_remove); - auto __mapped_iter = __containers_.values.erase(__mapped_iter_to_remove); - __on_failure.__complete(); - return iterator(std::move(__key_iter), std::move(__mapped_iter)); - } - - template - friend typename flat_multiset<_Key2, _Tp2, _Compare2, _KeyContainer2, _MappedContainer2>::size_type - erase_if(flat_multiset<_Key2, _Tp2, _Compare2, _KeyContainer2, _MappedContainer2>&, _Predicate); - - friend __flat_map_utils; + template + friend typename flat_multiset<_Key2, _Compare2, _KeyContainer2>::size_type + erase_if(flat_multiset<_Key2, _Compare2, _KeyContainer2>&, _Predicate); _KeyContainer __keys_; _LIBCPP_NO_UNIQUE_ADDRESS key_compare __compare_; @@ -713,141 +698,97 @@ class flat_multiset { }; }; -template > +template > requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value && - !__is_allocator<_MappedContainer>::value && is_invocable_v) -flat_multiset(_KeyContainer, _MappedContainer, _Compare = _Compare()) - -> flat_multiset; - -template - requires(uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator> && - !__is_allocator<_KeyContainer>::value && !__is_allocator<_MappedContainer>::value) -flat_multiset(_KeyContainer, _MappedContainer, _Allocator) - -> flat_multiset, - _KeyContainer, - _MappedContainer>; - -template +flat_multiset(_KeyContainer, _Compare = _Compare()) + -> flat_multiset; + +template + requires(uses_allocator_v<_KeyContainer, _Allocator> && !__is_allocator<_KeyContainer>::value) +flat_multiset(_KeyContainer, _Allocator) + -> flat_multiset, _KeyContainer>; + +template requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value && - !__is_allocator<_MappedContainer>::value && uses_allocator_v<_KeyContainer, _Allocator> && - uses_allocator_v<_MappedContainer, _Allocator> && + uses_allocator_v<_KeyContainer, _Allocator> && is_invocable_v) -flat_multiset(_KeyContainer, _MappedContainer, _Compare, _Allocator) - -> flat_multiset; - -template > +flat_multiset(_KeyContainer, _Compare, _Allocator) + -> flat_multiset; + +template > requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value && - !__is_allocator<_MappedContainer>::value && is_invocable_v) -flat_multiset(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Compare = _Compare()) - -> flat_multiset; - -template - requires(uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator> && - !__is_allocator<_KeyContainer>::value && !__is_allocator<_MappedContainer>::value) -flat_multiset(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Allocator) - -> flat_multiset, - _KeyContainer, - _MappedContainer>; - -template +flat_multiset(sorted_equivalent_t, _KeyContainer, _Compare = _Compare()) + -> flat_multiset; + +template + requires(uses_allocator_v<_KeyContainer, _Allocator> && !__is_allocator<_KeyContainer>::value) +flat_multiset(sorted_equivalent_t, _KeyContainer, _Allocator) + -> flat_multiset, _KeyContainer>; + +template requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value && - !__is_allocator<_MappedContainer>::value && uses_allocator_v<_KeyContainer, _Allocator> && - uses_allocator_v<_MappedContainer, _Allocator> && + uses_allocator_v<_KeyContainer, _Allocator> && is_invocable_v) -flat_multiset(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Compare, _Allocator) - -> flat_multiset; - -template >> +flat_multiset(sorted_equivalent_t, _KeyContainer, _Compare, _Allocator) + -> flat_multiset; + +template >> requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator<_Compare>::value) flat_multiset(_InputIterator, _InputIterator, _Compare = _Compare()) - -> flat_multiset<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare>; + -> flat_multiset<__iter_value_type<_InputIterator>, _Compare>; -template >> +template >> requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator<_Compare>::value) flat_multiset(sorted_equivalent_t, _InputIterator, _InputIterator, _Compare = _Compare()) - -> flat_multiset<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare>; + -> flat_multiset<__iter_value_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare>; template >, + class _Compare = less<__iter_value_type<_Range>>, class _Allocator = allocator, class = __enable_if_t::value && __is_allocator<_Allocator>::value>> flat_multiset(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator()) -> flat_multiset< - __range_key_type<_Range>, - __range_mapped_type<_Range>, + ranges::range_value_t<_Range>, _Compare, - vector<__range_key_type<_Range>, __allocator_traits_rebind_t<_Allocator, __range_key_type<_Range>>>, - vector<__range_mapped_type<_Range>, __allocator_traits_rebind_t<_Allocator, __range_mapped_type<_Range>>>>; + vector, __allocator_traits_rebind_t<_Allocator, __range_key_type<_Range>>>>; template ::value>> flat_multiset(from_range_t, _Range&&, _Allocator) -> flat_multiset< - __range_key_type<_Range>, - __range_mapped_type<_Range>, - less<__range_key_type<_Range>>, - vector<__range_key_type<_Range>, __allocator_traits_rebind_t<_Allocator, __range_key_type<_Range>>>, - vector<__range_mapped_type<_Range>, __allocator_traits_rebind_t<_Allocator, __range_mapped_type<_Range>>>>; + ranges::range_value_t<_Range>, + less>, + vector, __allocator_traits_rebind_t<_Allocator, ranges::range_value_t<_Range>>>>; -template > +template > requires(!__is_allocator<_Compare>::value) -flat_multiset(initializer_list>, _Compare = _Compare()) -> flat_multiset<_Key, _Tp, _Compare>; +flat_multiset(initializer_list<_Key>, _Compare = _Compare()) -> flat_multiset<_Key, _Compare>; -template > +template > requires(!__is_allocator<_Compare>::value) -flat_multiset(sorted_equivalent_t, initializer_list>, _Compare = _Compare()) - -> flat_multiset<_Key, _Tp, _Compare>; - -template -struct uses_allocator, _Allocator> - : bool_constant && uses_allocator_v<_MappedContainer, _Allocator>> {}; - -template -_LIBCPP_HIDE_FROM_ABI typename flat_multiset<_Key, _Tp, _Compare, _KeyContainer, _MappedContainer>::size_type -erase_if(flat_multiset<_Key, _Tp, _Compare, _KeyContainer, _MappedContainer>& __flat_multiset, _Predicate __pred) { - auto __zv = ranges::views::zip(__flat_multiset.__containers_.keys, __flat_multiset.__containers_.values); - auto __first = __zv.begin(); - auto __last = __zv.end(); - auto __guard = std::__make_exception_guard([&] { __flat_multiset.clear(); }); - auto __it = std::remove_if(__first, __last, [&](auto&& __zipped) -> bool { - using _Ref = typename flat_multiset<_Key, _Tp, _Compare, _KeyContainer, _MappedContainer>::const_reference; - return __pred(_Ref(std::get<0>(__zipped), std::get<1>(__zipped))); - }); - auto __res = __last - __it; - auto __offset = __it - __first; - - const auto __erase_container = [&](auto& __cont) { __cont.erase(__cont.begin() + __offset, __cont.end()); }; - - __erase_container(__flat_multiset.__containers_.keys); - __erase_container(__flat_multiset.__containers_.values); - +flat_multiset(sorted_equivalent_t, initializer_list<_Key>, _Compare = _Compare()) -> flat_multiset<_Key, _Compare>; + +template +struct uses_allocator, _Allocator> + : bool_constant > {}; + +template +_LIBCPP_HIDE_FROM_ABI typename flat_multiset<_Key, _Compare, _KeyContainer>::size_type +erase_if(flat_multiset<_Key, _Compare, _KeyContainer>& __flat_multiset, _Predicate __pred) { + auto __guard = std::__make_exception_guard([&] { __flat_multiset.clear(); }); + auto __it = + std::remove_if(__flat_multiset.__keys_.begin(), __flat_multiset.__keys_.end(), [&](const auto& __e) -> bool { + return static_cast(__pred(__e)); + }); + auto __res = __flat_multiset.__keys_.end() - __it; + __flat_multiset.__keys_.erase(__it, __flat_multiset.__keys_.end()); __guard.__complete(); return __res; } From 261ad67aeebf923e09abf271af03b7165373d3f6 Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Sun, 9 Mar 2025 18:25:12 +0000 Subject: [PATCH 08/23] update --- libcxx/include/__flat_set/flat_multiset.h | 14 +- .../flat.multiset.cons/alloc.pass.cpp | 63 ++++ .../assign_initializer_list.pass.cpp | 60 ++++ .../flat.multiset.cons/compare.pass.cpp | 85 +++++ .../flat.multiset.cons/containers.pass.cpp | 162 +++++++++ .../flat.multiset.cons/copy.pass.cpp | 70 ++++ .../flat.multiset.cons/copy_alloc.pass.cpp | 65 ++++ .../flat.multiset.cons/copy_assign.pass.cpp | 101 ++++++ .../deduct.compile.pass.cpp | 43 +++ .../flat.multiset.cons/deduct.pass.cpp | 317 +++++++++++++++++ .../flat.multiset.cons/deduct_pmr.pass.cpp | 94 +++++ .../flat.multiset.cons/default.pass.cpp | 96 ++++++ .../flat.multiset.cons/dtor_noexcept.pass.cpp | 61 ++++ .../initializer_list.pass.cpp | 155 +++++++++ .../flat.multiset.cons/iter_iter.pass.cpp | 140 ++++++++ .../flat.multiset.cons/move.pass.cpp | 188 ++++++++++ .../flat.multiset.cons/move_alloc.pass.cpp | 79 +++++ .../flat.multiset.cons/move_assign.pass.cpp | 241 +++++++++++++ .../flat.multiset.cons/pmr.pass.cpp | 326 ++++++++++++++++++ .../flat.multiset.cons/range.pass.cpp | 177 ++++++++++ .../sorted_container.pass.cpp | 147 ++++++++ .../sorted_initializer_list.pass.cpp | 154 +++++++++ .../sorted_iter_iter.pass.cpp | 160 +++++++++ 23 files changed, 2994 insertions(+), 4 deletions(-) create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/alloc.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/assign_initializer_list.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/compare.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/containers.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/copy.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/copy_alloc.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/copy_assign.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct.compile.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct_pmr.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/default.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/dtor_noexcept.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/initializer_list.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/iter_iter.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_alloc.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_assign.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/pmr.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/range.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_container.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_initializer_list.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_iter_iter.pass.cpp diff --git a/libcxx/include/__flat_set/flat_multiset.h b/libcxx/include/__flat_set/flat_multiset.h index 6ad62a75da464..9a95347329368 100644 --- a/libcxx/include/__flat_set/flat_multiset.h +++ b/libcxx/include/__flat_set/flat_multiset.h @@ -682,6 +682,12 @@ class flat_multiset { return std::make_pair(__iter(__key_first), __iter(__key_last)); } + _LIBCPP_HIDE_FROM_ABI void __reserve(size_t __size) { + if constexpr (requires { __keys_.reserve(__size); }) { + __keys_.reserve(__size); + } + } + template friend typename flat_multiset<_Key2, _Compare2, _KeyContainer2>::size_type erase_if(flat_multiset<_Key2, _Compare2, _KeyContainer2>&, _Predicate); @@ -750,16 +756,16 @@ flat_multiset(_InputIterator, _InputIterator, _Compare = _Compare()) template >> requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator<_Compare>::value) flat_multiset(sorted_equivalent_t, _InputIterator, _InputIterator, _Compare = _Compare()) - -> flat_multiset<__iter_value_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare>; + -> flat_multiset<__iter_value_type<_InputIterator>, _Compare>; template >, - class _Allocator = allocator, + class _Compare = less>, + class _Allocator = allocator>, class = __enable_if_t::value && __is_allocator<_Allocator>::value>> flat_multiset(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator()) -> flat_multiset< ranges::range_value_t<_Range>, _Compare, - vector, __allocator_traits_rebind_t<_Allocator, __range_key_type<_Range>>>>; + vector, __allocator_traits_rebind_t<_Allocator, ranges::range_value_t<_Range>>>>; template ::value>> flat_multiset(from_range_t, _Range&&, _Allocator) -> flat_multiset< diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/alloc.pass.cpp new file mode 100644 index 0000000000000..4fffcb304d20a --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/alloc.pass.cpp @@ -0,0 +1,63 @@ +//===----------------------------------------------------------------------===// +// +// 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_multiset(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_multiset; + using M2 = std::flat_multiset; + 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_multiset, std::vector>>; + + static_assert(std::is_constructible_v>); + static_assert(!std::is_convertible_v, M>); + } + { + using A = test_allocator; + using M = std::flat_multiset, std::vector>>; + M m(A(0, 5)); + assert(m.empty()); + assert(m.begin() == m.end()); + assert(std::move(m).extract().get_allocator().get_id() == 5); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/assign_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/assign_initializer_list.pass.cpp new file mode 100644 index 0000000000000..071b0be5d15d7 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/assign_initializer_list.pass.cpp @@ -0,0 +1,60 @@ +//===----------------------------------------------------------------------===// +// +// 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_multiset& operator=(initializer_list il); + +#include +#include +#include +#include +#include +#include +#include + +#include "MinSequenceContainer.h" +#include "test_macros.h" +#include "min_allocator.h" +#include "test_allocator.h" + +template +void test() { + using Key = typename KeyContainer::value_type; + using M = std::flat_multiset, KeyContainer>; + { + M m = {8, 10}; + assert(m.size() == 2); + m = {3, 1, 2, 2, 3, 4, 3, 5, 6, 5}; + int expected[] = {1, 2, 2, 3, 3, 3, 4, 5, 5, 6}; + assert(std::ranges::equal(m, expected)); + } + { + M m = {10, 8}; + assert(m.size() == 2); + m = {3}; + double expected[] = {3}; + assert(std::ranges::equal(m, expected)); + } +} + +void test() { + test>(); + test>(); + test>(); + test>(); + test>>(); +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/compare.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/compare.pass.cpp new file mode 100644 index 0000000000000..6b68589e6814f --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/compare.pass.cpp @@ -0,0 +1,85 @@ +//===----------------------------------------------------------------------===// +// +// 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_multiset(const key_compare& comp); +// template +// flat_multiset(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_multiset; + using M2 = std::flat_multiset; + 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_multiset(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_multiset>); + } + { + using C = test_less; + using A1 = test_allocator; + auto m = std::flat_multiset>(C(4), A1(5)); + assert(m.empty()); + assert(m.begin() == m.end()); + assert(m.key_comp() == C(4)); + assert(std::move(m).extract().get_allocator() == A1(5)); + } + { + // explicit(false) + using C = test_less; + using A1 = test_allocator; + std::flat_multiset> m = {C(4), A1(5)}; + assert(m.empty()); + assert(m.begin() == m.end()); + assert(m.key_comp() == C(4)); + 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.multiset/flat.multiset.cons/containers.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/containers.pass.cpp new file mode 100644 index 0000000000000..78eac420a8f22 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/containers.pass.cpp @@ -0,0 +1,162 @@ +//===----------------------------------------------------------------------===// +// +// 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_multiset(container_type key_cont, const key_compare& comp = key_compare()); +// template +// flat_multiset(const container_type& key_cont, const Allocator& a); +// template +// flat_multiset(const container_type& key_cont, const key_compare& comp, const Alloc& a); + +#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_multiset; + using M2 = std::flat_multiset; + 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_multiset(container_type) + using M = std::flat_multiset; + std::vector ks = {1, 1, 1, 2, 2, 3, 2, 3, 3}; + auto m = M(ks); + int expected[] = {1, 1, 1, 2, 2, 2, 3, 3, 3}; + assert(std::ranges::equal(m, expected)); + + // explicit(false) + static_assert(std::is_constructible_v&>); + static_assert(!ImplicitlyConstructible&>); + + m = M(std::move(ks)); + assert(ks.empty()); // it was moved-from + assert(std::ranges::equal(m, expected)); + } + { + // flat_multiset(container_type) + // move-only + int expected[] = {3, 3, 2, 1}; + using Ks = std::deque>; + using M = std::flat_multiset, Ks>; + Ks ks; + ks.push_back(1); + ks.push_back(3); + 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, std::equal_to<>())); + } + { + // flat_multiset(container_type) + // container's allocators are used + using A = test_allocator; + using M = std::flat_multiset, 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, 1, 1, 2, 2, 2, 3, 3, 3})); + auto keys = std::move(m).extract(); + assert(keys.get_allocator() == A(5)); + } + { + // flat_multiset(container_type, key_compare) + using C = test_less; + using M = std::flat_multiset; + 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, 1, 1, 2, 2, 2, 3, 3, 3})); + assert(m.key_comp() == C(4)); + + // explicit + static_assert(std::is_constructible_v&, const C&>); + static_assert(!ImplicitlyConstructible&, const C&>); + } + { + // flat_multiset(container_type , const Allocator&) + using A = test_allocator; + using M = std::flat_multiset, 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, 1, 1, 2, 2, 2, 3, 3, 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_multiset(container_type , const Allocator&) + using C = test_less; + using A = test_allocator; + using M = std::flat_multiset>; + 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, 1, 1, 2, 2, 2, 3, 3, 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.multiset/flat.multiset.cons/copy.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/copy.pass.cpp new file mode 100644 index 0000000000000..b4f7220e1bac7 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/copy.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 + +// + +// flat_multiset(const flat_multiset& 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, 3, 1}, test_allocator(6)); + const int expected[] = {1, 1, 3, 3, 5}; + using M = std::flat_multiset; + auto mo = M(ks, C(5)); + auto m = mo; + + assert(m.key_comp() == C(5)); + assert(std::ranges::equal(m, expected)); + 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, expected)); + 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, 3, 1}, other_allocator(6)); + const int expected[] = {1, 1, 3, 3, 5}; + using M = std::flat_multiset; + auto mo = M(Ks(ks, other_allocator(6)), C(5)); + auto m = mo; + + assert(m.key_comp() == C(5)); + assert(std::ranges::equal(m, expected)); + 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, expected)); + 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.multiset/flat.multiset.cons/copy_alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/copy_alloc.pass.cpp new file mode 100644 index 0000000000000..0267c9c0a4f52 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/copy_alloc.pass.cpp @@ -0,0 +1,65 @@ +//===----------------------------------------------------------------------===// +// +// 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_multiset(const flat_multiset&, const allocator_type&); + +#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_multiset; + using M2 = std::flat_multiset; + 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, 5}, test_allocator(6)); + using M = std::flat_multiset; + 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.multiset/flat.multiset.cons/copy_assign.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/copy_assign.pass.cpp new file mode 100644 index 0000000000000..35e1945f27b18 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/copy_assign.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 + +// + +// flat_multiset& operator=(const flat_multiset& 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, 5}, test_allocator(6)); + using M = std::flat_multiset; + auto mo = M(ks, C(5)); + auto m = M({{3, 4, 5, 4}}, 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, 3}, other_allocator(6)); + const int expected[] = {1, 3, 3, 5}; + using M = std::flat_multiset; + 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, expected)); + 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, expected)); + auto keys2 = std::move(mo).extract(); + assert(keys2.get_allocator() == other_allocator(6)); + } + { + // comparator is copied and invariant is preserved + using M = std::flat_multiset>; + 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_multiset; + 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_multiset so; + std::flat_multiset 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.multiset/flat.multiset.cons/deduct.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct.compile.pass.cpp new file mode 100644 index 0000000000000..90bdad29661dd --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset(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.multiset/flat.multiset.cons/deduct.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct.pass.cpp new file mode 100644 index 0000000000000..a2eec0be83ec5 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct.pass.cpp @@ -0,0 +1,317 @@ +//===----------------------------------------------------------------------===// +// +// 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_copy() { + { + std::flat_multiset source = {1, 2, 2}; + std::flat_multiset s(source); + ASSERT_SAME_TYPE(decltype(s), decltype(source)); + assert(s == source); + } + { + std::flat_multiset> source = {1, 2, 2}; + std::flat_multiset s{source}; // braces instead of parens + ASSERT_SAME_TYPE(decltype(s), decltype(source)); + assert(s == source); + } + { + std::flat_multiset> source = {1, 2, 2}; + std::flat_multiset s(source, std::allocator()); + ASSERT_SAME_TYPE(decltype(s), decltype(source)); + assert(s == source); + } +} +void test_containers() { + std::deque> ks({1, 2, 1, INT_MAX, 3}, test_allocator(0, 42)); + std::deque> sorted_ks({1, 1, 2, 3, INT_MAX}, test_allocator(0, 42)); + int expected[] = {1, 1, 2, 3, INT_MAX}; + { + std::flat_multiset s(ks); + + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 42); + } + { + std::flat_multiset s(std::sorted_equivalent, sorted_ks); + + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 42); + } + { + std::flat_multiset s(ks, test_allocator(0, 44)); + + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 44); + } + { + std::flat_multiset s(std::sorted_equivalent, sorted_ks, test_allocator(0, 44)); + + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 44); + } +} + +void test_containers_compare() { + std::deque> ks({1, 2, 1, INT_MAX, 3}, test_allocator(0, 42)); + std::deque> sorted_ks({INT_MAX, 3, 2, 1, 1}, test_allocator(0, 42)); + int expected[] = {INT_MAX, 3, 2, 1, 1}; + { + std::flat_multiset s(ks, std::greater()); + + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 42); + } + { + std::flat_multiset s(std::sorted_equivalent, sorted_ks, std::greater()); + + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 42); + } + { + std::flat_multiset s(ks, std::greater(), test_allocator(0, 44)); + + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 44); + } + { + std::flat_multiset s(std::sorted_equivalent, sorted_ks, std::greater(), test_allocator(0, 44)); + + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 44); + } +} + +void test_iter_iter() { + int arr[] = {1, 2, 1, INT_MAX, 3}; + int sorted_arr[] = {1, 1, 2, 3, INT_MAX}; + const int arrc[] = {1, 2, 1, INT_MAX, 3}; + const int sorted_arrc[] = {1, 1, 2, 3, INT_MAX}; + { + std::flat_multiset m(std::begin(arr), std::end(arr)); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + std::flat_multiset m(std::begin(arrc), std::end(arrc)); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + std::flat_multiset m(std::sorted_equivalent, std::begin(sorted_arr), std::end(sorted_arr)); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + std::flat_multiset m(std::sorted_equivalent, std::begin(sorted_arrc), std::end(sorted_arrc)); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + std::flat_multiset mo; + std::flat_multiset m(mo.begin(), mo.end()); + ASSERT_SAME_TYPE(decltype(m), decltype(mo)); + } + { + std::flat_multiset mo; + std::flat_multiset m(mo.cbegin(), mo.cend()); + ASSERT_SAME_TYPE(decltype(m), decltype(mo)); + } + { + int source[3] = {1, 2, 3}; + std::flat_multiset s(source, source + 3); + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset); + assert(s.size() == 3); + } + { + // This does not deduce to flat_multiset(InputIterator, InputIterator) + // But deduces to flat_multiset(initializer_list) + int source[3] = {1, 2, 3}; + std::flat_multiset s = {source, source + 3}; + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset); + assert(s.size() == 2); + } + { + int source[3] = {1, 2, 3}; + std::flat_multiset s{ + std::sorted_equivalent, source, source + 3}; // flat_multiset(sorted_equivalent_t, InputIterator, InputIterator) + static_assert(std::is_same_v>); + assert(s.size() == 3); + } +} + +void test_iter_iter_compare() { + int arr[] = {1, 2, 1, INT_MAX, 3}; + int sorted_arr[] = {INT_MAX, 3, 2, 1, 1}; + const int arrc[] = {1, 2, 1, INT_MAX, 3}; + const int sorted_arrc[] = {INT_MAX, 3, 2, 1, 1}; + using C = std::greater; + { + std::flat_multiset m(std::begin(arr), std::end(arr), C()); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + std::flat_multiset m(std::begin(arrc), std::end(arrc), C()); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + std::flat_multiset m(std::sorted_equivalent, std::begin(sorted_arr), std::end(sorted_arr), C()); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + std::flat_multiset m(std::sorted_equivalent, std::begin(sorted_arrc), std::end(sorted_arrc), C()); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + std::flat_multiset mo; + std::flat_multiset m(mo.begin(), mo.end(), C()); + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + } + { + std::flat_multiset mo; + std::flat_multiset m(mo.cbegin(), mo.cend(), C()); + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + } +} + +void test_initializer_list() { + const int sorted_arr[] = {1, 1, 2, 3, INT_MAX}; + { + std::flat_multiset m{1, 2, 1, INT_MAX, 3}; + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + std::flat_multiset m(std::sorted_equivalent, {1, 1, 2, 3, INT_MAX}); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + std::flat_multiset s = {1}; + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset); + assert(s.size() == 1); + } + { + using M = std::flat_multiset; + M m; + std::flat_multiset s{m, m}; // flat_multiset(initializer_list) + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset); + assert(s.size() == 2); + } +} + +void test_initializer_list_compare() { + const int sorted_arr[] = {INT_MAX, 3, 2, 1, 1}; + using C = std::greater; + { + std::flat_multiset m({1, 2, 1, INT_MAX, 3}, C()); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + std::flat_multiset m(std::sorted_equivalent, {INT_MAX, 3, 2, 1, 1}, C()); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } +} + +void test_from_range() { + std::list r = {1, 2, 1, INT_MAX, 3}; + const int expected[] = {1, 1, 2, 3, INT_MAX}; + { + std::flat_multiset s(std::from_range, r); + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset>); + assert(std::ranges::equal(s, expected)); + } + { + std::flat_multiset s(std::from_range, r, test_allocator(0, 42)); + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, std::vector>>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 42); + } +} + +void test_from_range_compare() { + std::list r = {1, 2, 1, INT_MAX, 3}; + const int expected[] = {INT_MAX, 3, 2, 1, 1}; + { + std::flat_multiset s(std::from_range, r, std::greater()); + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset>); + assert(std::ranges::equal(s, expected)); + } + { + std::flat_multiset s(std::from_range, r, std::greater(), test_allocator(0, 42)); + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, std::vector>>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 42); + } +} + +void test() { + // Each test function also tests the sorted_equivalent-prefixed and allocator-suffixed overloads. + test_copy(); + test_containers(); + test_containers_compare(); + test_iter_iter(); + test_iter_iter_compare(); + test_initializer_list(); + test_initializer_list_compare(); + test_from_range(); + test_from_range_compare(); + + AssociativeContainerDeductionGuidesSfinaeAway>(); +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct_pmr.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct_pmr.pass.cpp new file mode 100644 index 0000000000000..ed3649a7301f7 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct_pmr.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 +// 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; + +void test_containers() { + std::deque> ks({1, 2, 1, INT_MAX, 3}, test_allocator(0, 42)); + std::deque> sorted_ks({1, 1, 2, 3, INT_MAX}, test_allocator(0, 42)); + const int expected[] = {1, 1, 2, 3, INT_MAX}; + { + std::pmr::monotonic_buffer_resource mr; + std::pmr::monotonic_buffer_resource mr2; + std::pmr::deque pks(ks.begin(), ks.end(), &mr); + std::flat_multiset s(std::move(pks), &mr2); + + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, std::pmr::deque>); + assert(std::ranges::equal(s, expected)); + auto keys = std::move(s).extract(); + assert(keys.get_allocator().resource() == &mr2); + } + { + 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_multiset s(std::sorted_equivalent, std::move(pks), &mr2); + + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, std::pmr::deque>); + assert(std::ranges::equal(s, expected)); + auto keys = std::move(s).extract(); + assert(keys.get_allocator().resource() == &mr2); + } +} + +void test_containers_compare() { + std::deque> ks({1, 2, 1, INT_MAX, 3}, test_allocator(0, 42)); + std::deque> sorted_ks({INT_MAX, 3, 2, 1, 1}, test_allocator(0, 42)); + const int expected[] = {INT_MAX, 3, 2, 1, 1}; + { + std::pmr::monotonic_buffer_resource mr; + std::pmr::monotonic_buffer_resource mr2; + std::pmr::deque pks(ks.begin(), ks.end(), &mr); + std::flat_multiset s(std::move(pks), std::greater(), &mr2); + + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, std::pmr::deque>); + assert(std::ranges::equal(s, expected)); + auto keys = std::move(s).extract(); + assert(keys.get_allocator().resource() == &mr2); + } + { + 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_multiset s(std::sorted_equivalent, std::move(pks), std::greater(), &mr2); + + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, std::pmr::deque>); + assert(std::ranges::equal(s, expected)); + auto keys = std::move(s).extract(); + assert(keys.get_allocator().resource() == &mr2); + } +} + +int main(int, char**) { + test_containers(); + test_containers_compare(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/default.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/default.pass.cpp new file mode 100644 index 0000000000000..16f90322cd31a --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset(); + +#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_multiset m; + assert(m.empty()); + } + { + // explicit(false) + std::flat_multiset m = {}; + assert(m.empty()); + } + { + std::flat_multiset>> m; + assert(m.empty()); + assert(m.begin() == m.end()); + assert(m.key_comp().default_constructed_); + } + { + using A1 = explicit_allocator; + { + std::flat_multiset> m; + assert(m.empty()); + assert(m.key_comp().default_constructed_); + } + { + A1 a1; + std::flat_multiset> m(a1); + assert(m.empty()); + assert(m.key_comp().default_constructed_); + } + } +#if defined(_LIBCPP_VERSION) + { + using C = std::flat_multiset; + static_assert(std::is_nothrow_default_constructible_v); + C c; + } + { + using C = std::flat_multiset, std::vector>>; + static_assert(std::is_nothrow_default_constructible_v); + C c; + } +#endif // _LIBCPP_VERSION + { + using C = std::flat_multiset, std::vector>>; + static_assert(!std::is_nothrow_default_constructible_v); + C c; + } + { + using C = std::flat_multiset; + 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.multiset/flat.multiset.cons/dtor_noexcept.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/dtor_noexcept.pass.cpp new file mode 100644 index 0000000000000..f852f2f85572c --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset(); + +#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_multiset; + static_assert(std::is_nothrow_destructible_v); + C c; + } + { + using V = std::vector>; + using C = std::flat_multiset, V>; + static_assert(std::is_nothrow_destructible_v); + C c; + } + { + using V = std::deque>; + using C = std::flat_multiset, V>; + static_assert(std::is_nothrow_destructible_v); + C c; + } +#if defined(_LIBCPP_VERSION) + { + using C = std::flat_multiset; + 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.multiset/flat.multiset.cons/initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/initializer_list.pass.cpp new file mode 100644 index 0000000000000..7a852443512e6 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset(initializer_list il, const key_compare& comp = key_compare()); +// template +// flat_multiset(initializer_list il, const Alloc& a); +// template +// flat_multiset(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_multiset; + using M2 = std::flat_multiset; + 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_multiset; + 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_multiset(initializer_list); + using M = std::flat_multiset; + std::initializer_list il = {5, 2, 2, 3, 1, 3}; + M m(il); + assert(std::equal(m.begin(), m.end(), expected, expected + 4)); + } + { + // flat_multiset(initializer_list); + // explicit(false) + using M = std::flat_multiset; + M m = {5, 2, 2, 3, 1, 3}; + assert(std::equal(m.begin(), m.end(), expected, expected + 4)); + } + { + // flat_multiset(initializer_list); + using M = std::flat_multiset, 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_multiset(initializer_list); + // different comparator + using M = std::flat_multiset>; + M m = {1, 2, 3}; + assert(m.size() == 1); + LIBCPP_ASSERT(*m.begin() == 1); + assert(m.key_comp().default_constructed_); + } + { + // flat_multiset(initializer_list, const Allocator&); + using M = std::flat_multiset, std::deque>; + A a; + M m({5, 2, 2, 3, 1, 3}, a); + assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4)); + } + } + { + // flat_multiset(initializer_list, const key_compare&); + using C = test_less; + using M = std::flat_multiset; + 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_multiset(initializer_list, const key_compare&); + // Sorting uses the comparator that was passed in + using M = std::flat_multiset, 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_multiset(initializer_list il, const key_compare& comp, const Alloc& a); + using A = explicit_allocator; + using M = std::flat_multiset, 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.multiset/flat.multiset.cons/iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/iter_iter.pass.cpp new file mode 100644 index 0000000000000..c4ed12ea1f84e --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset(InputIterator first, InputIterator last, const key_compare& comp = key_compare()); +// template +// flat_multiset(InputIterator first, InputIterator last, const Allocator& a); +// template +// flat_multiset(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_multiset; + using M2 = std::flat_multiset; + 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_multiset(InputIterator , InputIterator) + // cpp17_input_iterator + using M = std::flat_multiset; + 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_multiset(InputIterator , InputIterator) + // greater + using M = std::flat_multiset, 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_multiset(InputIterator , InputIterator) + // Test when the operands are of array type (also contiguous iterator type) + using M = std::flat_multiset, std::vector>>; + auto m = M(ar, ar); + assert(m.empty()); + } + { + // flat_multiset(InputIterator , InputIterator, const key_compare&) + using C = test_less; + using M = std::flat_multiset>; + 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_multiset(InputIterator , InputIterator, const Allocator&) + using A1 = test_allocator; + using M = std::flat_multiset, 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_multiset(InputIterator , InputIterator, const Allocator&) + // explicit(false) + using A1 = test_allocator; + using M = std::flat_multiset, 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_multiset(InputIterator , InputIterator, const key_compare&, const Allocator&) + using C = test_less; + using A1 = test_allocator; + using M = std::flat_multiset>; + 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_multiset(InputIterator , InputIterator, const key_compare&, const Allocator&) + // explicit(false) + using A1 = test_allocator; + using M = std::flat_multiset, 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.multiset/flat.multiset.cons/move.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move.pass.cpp new file mode 100644 index 0000000000000..32387054ab0e9 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset(flat_multiset&&); + +#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_multiset>; + 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_multiset>; + 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_multiset maintains its class invariant in the presence of moved-from comparators. + using M = std::flat_multiset>; + 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_multiset, 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_multiset; + LIBCPP_STATIC_ASSERT(std::is_nothrow_move_constructible_v); + C c; + C d = std::move(c); + } + { + using C = std::flat_multiset, 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_multiset, 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_multiset; + 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_multiset, 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_multiset 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 // !defined(TEST_HAS_NO_EXCEPTIONS) + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_alloc.pass.cpp new file mode 100644 index 0000000000000..abb7f39687c9b --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset(flat_multiset&&, 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_multiset; + using M2 = std::flat_multiset; + 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_multiset>; + 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_multiset 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_multiset, 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.multiset/flat.multiset.cons/move_assign.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_assign.pass.cpp new file mode 100644 index 0000000000000..58c3338f9b99e --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset& operator=(flat_multiset&&); + +#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_multiset. + { + const int expected[] = {1, 2, 3, 4, 5, 6, 7, 8}; + using M = std::flat_multiset>; + 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_multiset>; + 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_multiset, 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_multiset, 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_multiset; + LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable_v); + } + { + using C = std::flat_multiset, std::vector>>; + static_assert(!std::is_nothrow_move_assignable_v); + } + { + using C = std::flat_multiset, std::vector>>; + static_assert(!std::is_nothrow_move_assignable_v); + } + { + using C = std::flat_multiset, std::vector>>; + LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable_v); + } + { + using C = std::flat_multiset, std::vector>>; + LIBCPP_STATIC_ASSERT(std::is_nothrow_move_assignable_v); + } + { + // Test with a comparator that throws on move-assignment. + using C = std::flat_multiset; + LIBCPP_STATIC_ASSERT(!std::is_nothrow_move_assignable_v); + } + { + // Test with a container that throws on move-assignment. + using C = std::flat_multiset, 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_multiset>; + 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_multiset>; + 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_multiset, 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.multiset/flat.multiset.cons/pmr.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/pmr.pass.cpp new file mode 100644 index 0000000000000..6dcb491fd1d8c --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset(const Allocator& a); + using M = std::flat_multiset, 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_multiset(const key_compare& comp, const Alloc& a); + using M = std::flat_multiset, 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_multiset(const key_container_type& key_cont, const mapped_container_type& mapped_cont, + // const Allocator& a); + using M = std::flat_multiset, 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_multiset(const flat_multiset&, const allocator_type&); + using C = test_less; + using M = std::flat_multiset>; + 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_multiset(const flat_multiset&, const allocator_type&); + using M = std::flat_multiset, std::pmr::vector>; + std::pmr::vector vs; + M m = {1, 2, 3}; + vs.push_back(m); + assert(vs[0] == m); + } + { + // flat_multiset& operator=(const flat_multiset& m); + // pmr allocator is not propagated + using M = std::flat_multiset, 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_multiset(const flat_multiset& m); + using C = test_less; + std::pmr::monotonic_buffer_resource mr; + using M = std::flat_multiset>; + 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_multiset(initializer_list il, const Alloc& a); + using M = std::flat_multiset, 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_multiset(initializer_list il, const key_compare& comp, const Alloc& a); + using C = test_less; + using M = std::flat_multiset>; + 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_multiset(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_multiset, 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_multiset, 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_multiset(flat_multiset&&, const allocator_type&); + int expected[] = {1, 2, 3}; + using C = test_less; + using M = std::flat_multiset>; + 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_multiset 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_multiset(flat_multiset&&, const allocator_type&); + using M = std::flat_multiset, 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_multiset& operator=(flat_multiset&&); + using M = std::flat_multiset, 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_multiset(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_multiset, 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_multiset, 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_multiset(sorted_equivalent_t, const container_type& key_cont, const Alloc& a); + using M = std::flat_multiset, 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_equivalent, 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_multiset(sorted_equivalent_t, const container_type& key_cont,const Alloc& a); + using M = std::flat_multiset, 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_equivalent, ks); + assert((vm[0] == M{1, 2, 4, 10})); + assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); + } + { + // flat_multiset(sorted_equivalent_t, initializer_list il, const Alloc& a); + // cpp_17 + using C = test_less; + using M = std::flat_multiset>; + std::pmr::monotonic_buffer_resource mr; + std::pmr::vector vm(&mr); + int ar[] = {1, 2, 4, 5}; + vm.emplace_back( + std::sorted_equivalent, 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_multiset(sorted_equivalent_t, initializer_list il, const Alloc& a); + using C = test_less; + using M = std::flat_multiset>; + std::pmr::monotonic_buffer_resource mr; + std::pmr::vector vm(&mr); + int ar[1] = {42}; + vm.emplace_back(std::sorted_equivalent, 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_multiset(InputIterator first, InputIterator last, const Alloc& a); + // cpp_17 + using C = test_less; + using M = std::flat_multiset>; + std::pmr::monotonic_buffer_resource mr; + std::pmr::vector vm(&mr); + int ar[] = {1, 2, 4, 5}; + vm.emplace_back( + std::sorted_equivalent, 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_multiset(InputIterator first, InputIterator last, const Alloc& a); + using C = test_less; + using M = std::flat_multiset>; + std::pmr::monotonic_buffer_resource mr; + std::pmr::vector vm(&mr); + int ar[1] = {42}; + vm.emplace_back(std::sorted_equivalent, 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.multiset/flat.multiset.cons/range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/range.pass.cpp new file mode 100644 index 0000000000000..11c981fdecdd1 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset(from_range_t, R&&) +// template R> +// flat_multiset(from_range_t, R&&, const key_compare&) +// template R, class Alloc> +// flat_multiset(from_range_t, R&&, const Alloc&); +// template R, class Alloc> +// flat_multiset(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_multiset; + +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_multiset; + using M2 = std::flat_multiset; + 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_multiset(from_range_t, R&&) + // input_range && !common + using M = std::flat_multiset; + 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_multiset(from_range_t, R&&) + // greater + using M = std::flat_multiset, 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_multiset(from_range_t, R&&) + // contiguous range + using M = std::flat_multiset; + using R = std::ranges::subrange; + auto m = M(std::from_range, R(ar, ar + 9)); + assert(std::ranges::equal(m, expected)); + } + { + // flat_multiset(from_range_t, R&&, const key_compare&) + using C = test_less; + using M = std::flat_multiset>; + 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_multiset(from_range_t, R&&, const Allocator&) + using A1 = test_allocator; + using M = std::flat_multiset, 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_multiset(from_range_t, R&&, const Allocator&) + // explicit(false) + using A1 = test_allocator; + using M = std::flat_multiset, 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_multiset(from_range_t, R&&, const key_compare&, const Allocator&) + using C = test_less; + using A1 = test_allocator; + using M = std::flat_multiset>; + 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_multiset(from_range_t, R&&, const key_compare&, const Allocator&) + // explicit(false) + using A1 = test_allocator; + using M = std::flat_multiset, 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.multiset/flat.multiset.cons/sorted_container.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_container.pass.cpp new file mode 100644 index 0000000000000..43595265884e7 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset(sorted_equivalent_t, container_type key_cont, const key_compare& comp = key_compare()); +// +// template +// flat_multiset(sorted_equivalent_t, const container_type& key_cont, const Alloc& a); +// template +// flat_multiset(sorted_equivalent_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_multiset; + using M2 = std::flat_multiset; + 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_multiset(sorted_equivalent_t, container_type) + using M = std::flat_multiset; + std::vector ks = {1, 2, 4, 10}; + auto ks2 = ks; + + auto m = M(std::sorted_equivalent, ks); + assert((m == M{1, 2, 4, 10})); + m = M(std::sorted_equivalent, std::move(ks)); + assert(ks.empty()); // it was moved-from + assert((m == M{1, 2, 4, 10})); + + // explicit(false) + M m2 = {std::sorted_equivalent, std::move(ks2)}; + assert(m == m2); + } + { + // flat_multiset(sorted_equivalent_t, container_type) + // non-default container, comparator and allocator type + using Ks = std::deque>; + using M = std::flat_multiset, Ks>; + Ks ks = {10, 4, 2, 1}; + auto m = M(std::sorted_equivalent, ks); + assert((m == M{1, 2, 4, 10})); + m = M(std::sorted_equivalent, std::move(ks)); + assert(ks.empty()); // it was moved-from + assert((m == M{1, 2, 4, 10})); + } + { + // flat_multiset(sorted_equivalent_t, container_type) + // allocator copied into the containers + using A = test_allocator; + using M = std::flat_multiset, std::deque>; + auto ks = std::deque({1, 2, 4, 10}, A(4)); + auto m = M(std::sorted_equivalent, 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_multiset(sorted_equivalent_t, container_type , key_compare) + using C = test_less; + using M = std::flat_multiset; + std::vector ks = {1, 2, 4, 10}; + + auto m = M(std::sorted_equivalent, ks, C(4)); + assert((m == M{1, 2, 4, 10})); + assert(m.key_comp() == C(4)); + + // explicit(false) + M m2 = {std::sorted_equivalent, ks, C(4)}; + assert(m2 == m); + assert(m2.key_comp() == C(4)); + } + { + // flat_multiset(sorted_equivalent_t, container_type , key_compare, const Allocator&) + using C = test_less; + using A = test_allocator; + using M = std::flat_multiset>; + std::vector ks = {1, 2, 4, 10}; + auto m = M(std::sorted_equivalent, 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_multiset(sorted_equivalent_t, container_type , const Allocator&) + using A = test_allocator; + using M = std::flat_multiset, std::deque>; + auto ks = std::deque({1, 2, 4, 10}, A(4)); + auto m = M(std::sorted_equivalent, 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_equivalent, 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.multiset/flat.multiset.cons/sorted_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_initializer_list.pass.cpp new file mode 100644 index 0000000000000..15adf6214a1f2 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset(sorted_equivalent_t s, initializer_list il, +// const key_compare& comp = key_compare()) +// template +// flat_multiset(sorted_equivalent_t, initializer_list il, const Alloc& a); +// template +// flat_multiset(sorted_equivalent_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_multiset; + using M2 = std::flat_multiset; + 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_multiset; + 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_multiset(sorted_equivalent_t, initializer_list); + using M = std::flat_multiset; + auto m = M(std::sorted_equivalent, il1); + auto expected = M{1, 2, 4, 5}; + assert(m == expected); + + // explicit(false) + M m2 = {std::sorted_equivalent, il1}; + assert(m2 == m); + } + { + // flat_multiset(sorted_equivalent_t, initializer_list, const key_compare&); + using M = std::flat_multiset>; + auto m = M(std::sorted_equivalent, 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_equivalent, il1, std::less()}; + assert(m2 == m); + } + { + // flat_multiset(sorted_equivalent_t, initializer_list, const key_compare&); + // greater + using M = std::flat_multiset, std::deque>>; + std::initializer_list il4{5, 4, 2, 1}; + auto m = M(std::sorted_equivalent, il4, std::greater()); + assert((m == M{5, 4, 2, 1})); + } + { + // flat_multiset(sorted_equivalent_t, initializer_list, const Allocator&) + using A1 = test_allocator; + using M = std::flat_multiset, std::deque>; + auto m = M(std::sorted_equivalent, 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_equivalent, il2, A1(5)}; + assert(m2 == m); + assert(std::move(m2).extract().get_allocator() == A1(5)); + } + { + // flat_multiset(sorted_equivalent_t, initializer_list, const key_compare&, const Allocator&); + using C = test_less; + using A1 = test_allocator; + using M = std::flat_multiset>; + auto m = M(std::sorted_equivalent, 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_multiset(sorted_equivalent_t, initializer_list, const key_compare&, const Allocator&); + // explicit(false) + using A1 = test_allocator; + using M = std::flat_multiset, std::deque>; + M m = {std::sorted_equivalent, 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.multiset/flat.multiset.cons/sorted_iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_iter_iter.pass.cpp new file mode 100644 index 0000000000000..a73080d5a7869 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset(sorted_equivalent_t, InputIterator first, InputIterator last, const key_compare& comp = key_compare()); +// template +// flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last, const Alloc& a); +// template +// flat_multiset(sorted_equivalent_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_multiset; + using M2 = std::flat_multiset; + 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_multiset(sorted_equivalent_t, InputIterator, InputIterator); + // cpp17_input_iterator + using M = std::flat_multiset; + int ar[] = {1, 2, 4, 5}; + auto m = M(std::sorted_equivalent, 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_equivalent, cpp17_input_iterator(ar), cpp17_input_iterator(ar + 4)}; + assert(m2 == m); + } + { + // flat_multiset(sorted_equivalent_t, InputIterator, InputIterator); + // contiguous iterator + using C = test_less; + using M = std::flat_multiset>>; + int ar[] = {1, 2, 4, 5}; + auto m = M(std::sorted_equivalent, ar, ar + 4); + auto expected = M{1, 2, 4, 5}; + assert(m == expected); + } + { + // flat_multiset(sorted_equivalent_t, InputIterator, InputIterator, const key_compare&); + // cpp_17_input_iterator + using M = std::flat_multiset>; + int ar[] = {1, 2, 4, 5}; + auto m = M(std::sorted_equivalent, + 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_equivalent, + cpp17_input_iterator(ar), + cpp17_input_iterator(ar + 4), + std::less()}; + assert(m2 == m); + } + { + // flat_multiset(sorted_equivalent_t, InputIterator, InputIterator, const key_compare&); + // greater + using M = std::flat_multiset, std::deque>>; + int ar[] = {5, 4, 2, 1}; + auto m = M(std::sorted_equivalent, + cpp17_input_iterator(ar), + cpp17_input_iterator(ar + 4), + std::greater()); + assert((m == M{5, 4, 2, 1})); + } + { + // flat_multiset(sorted_equivalent_t, InputIterator, InputIterator, const key_compare&); + // contiguous iterator + using C = test_less; + using M = std::flat_multiset>>; + int ar[1] = {42}; + auto m = M(std::sorted_equivalent, ar, ar, C(5)); + assert(m.empty()); + assert(m.key_comp() == C(5)); + } + { + // flat_multiset(sorted_equivalent_t, InputIterator , InputIterator, const Allocator&) + using A1 = test_allocator; + using M = std::flat_multiset, std::vector>; + int ar[] = {1, 2, 4, 5}; + auto m = M(std::sorted_equivalent, 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_equivalent, ar, ar + 4, A1(5)}; + assert(m2 == m); + assert(std::move(m2).extract().get_allocator() == A1(5)); + } + { + // flat_multiset(sorted_equivalent_t, InputIterator, InputIterator, const key_compare&, const Allocator&); + using C = test_less; + using A1 = test_allocator; + using M = std::flat_multiset>; + int ar[] = {1, 2, 4, 5}; + auto m = M(std::sorted_equivalent, 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_multiset(sorted_equivalent_t, InputIterator, InputIterator, const key_compare&, const Allocator&); + // explicit(false) + using A1 = test_allocator; + using M = std::flat_multiset, std::deque>; + int ar[] = {1, 2, 4, 5}; + M m = {std::sorted_equivalent, 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; +} From cdeb186bfd8cf70ab1308bfba97aa05cb79aee35 Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Sat, 15 Mar 2025 16:23:38 +0000 Subject: [PATCH 09/23] more tests --- .../initializer_list.pass.cpp | 21 ++++++++++--------- .../flat.multiset.cons/iter_iter.pass.cpp | 5 +++-- .../flat.multiset.cons/move_alloc.pass.cpp | 12 +++++------ 3 files changed, 20 insertions(+), 18 deletions(-) diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/initializer_list.pass.cpp index 7a852443512e6..b33994357ca3b 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/initializer_list.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/initializer_list.pass.cpp @@ -22,6 +22,7 @@ #include #include #include +#include #include "test_macros.h" #include "min_allocator.h" @@ -77,26 +78,26 @@ void test() { static_assert(!std::is_constructible_v, std::allocator>); } - int expected[] = {1, 2, 3, 5}; + int expected[] = {1, 2, 2, 3, 3, 5}; { // flat_multiset(initializer_list); using M = std::flat_multiset; std::initializer_list il = {5, 2, 2, 3, 1, 3}; M m(il); - assert(std::equal(m.begin(), m.end(), expected, expected + 4)); + assert(std::ranges::equal(m, expected)); } { // flat_multiset(initializer_list); // explicit(false) using M = std::flat_multiset; M m = {5, 2, 2, 3, 1, 3}; - assert(std::equal(m.begin(), m.end(), expected, expected + 4)); + assert(std::ranges::equal(m, expected)); } { // flat_multiset(initializer_list); using M = std::flat_multiset, std::deque>>; M m = {5, 2, 2, 3, 1, 3}; - assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4)); + assert(std::ranges::equal(m, expected | std::views::reverse)); } { using A = explicit_allocator; @@ -105,7 +106,7 @@ void test() { // different comparator using M = std::flat_multiset>; M m = {1, 2, 3}; - assert(m.size() == 1); + assert(m.size() == 3); LIBCPP_ASSERT(*m.begin() == 1); assert(m.key_comp().default_constructed_); } @@ -114,7 +115,7 @@ void test() { using M = std::flat_multiset, std::deque>; A a; M m({5, 2, 2, 3, 1, 3}, a); - assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4)); + assert(std::ranges::equal(m, expected | std::views::reverse)); } } { @@ -122,7 +123,7 @@ void test() { using C = test_less; using M = std::flat_multiset; auto m = M({5, 2, 2, 3, 1, 3}, C(10)); - assert(std::equal(m.begin(), m.end(), expected, expected + 4)); + assert(std::ranges::equal(m, expected)); assert(m.key_comp() == C(10)); // explicit(false) @@ -134,8 +135,8 @@ void test() { // flat_multiset(initializer_list, const key_compare&); // Sorting uses the comparator that was passed in using M = std::flat_multiset, std::deque>>; - auto m = M({5, 2, 2, 1, 3, 1}, std::greater()); - assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4)); + auto m = M({5, 2, 2, 1, 3, 3}, std::greater()); + assert(std::ranges::equal(m, expected | std::views::reverse)); assert(m.key_comp()(2, 1) == true); } { @@ -144,7 +145,7 @@ void test() { using M = std::flat_multiset, std::deque>; A a; M m({5, 2, 2, 3, 1, 3}, {}, a); - assert(std::equal(m.rbegin(), m.rend(), expected, expected + 4)); + assert(std::ranges::equal(m, expected | std::views::reverse)); } } diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/iter_iter.pass.cpp index c4ed12ea1f84e..7a07b5283fe1b 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/iter_iter.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/iter_iter.pass.cpp @@ -21,6 +21,7 @@ #include #include #include +#include #include #include "min_allocator.h" @@ -55,7 +56,7 @@ void test() { } int ar[] = {1, 1, 1, 2, 2, 3, 2, 3, 3}; - int expected[] = {1, 2, 3}; + int expected[] = {1, 1,1,2,2,2,3,3,3}; { // flat_multiset(InputIterator , InputIterator) // cpp17_input_iterator @@ -72,7 +73,7 @@ void test() { // greater using M = std::flat_multiset, std::deque>>; auto m = M(cpp17_input_iterator(ar), cpp17_input_iterator(ar + 9)); - assert(std::ranges::equal(m, std::deque>{3, 2, 1})); + assert(std::ranges::equal(m, expected | std::views::reverse)); } { // flat_multiset(InputIterator , InputIterator) diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_alloc.pass.cpp index abb7f39687c9b..ee8258e5ac846 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_alloc.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_alloc.pass.cpp @@ -42,15 +42,15 @@ void test() { static_assert(!std::is_constructible_v); } { - int expected[] = {1, 2, 3}; + int expected[] = {1, 1, 2, 2, 3}; using C = test_less; using A = test_allocator; using M = std::flat_multiset>; - auto mo = M(expected, expected + 3, C(5), A(7)); + auto mo = M(expected, expected + 5, C(5), A(7)); auto m = M(std::move(mo), A(3)); assert(m.key_comp() == C(5)); - assert(m.size() == 3); + assert(m.size() == 5); auto keys = std::move(m).extract(); assert(keys.get_allocator() == A(3)); assert(std::ranges::equal(keys, expected)); @@ -64,10 +64,10 @@ void test() { { // moved-from object maintains invariant if one of underlying container does not clear after move using M = std::flat_multiset, CopyOnlyVector>; - M m1 = M({1, 2, 3}); + M m1 = M({1, 2, 2, 1, 3}); M m2(std::move(m1), std::allocator{}); - assert(m2.size() == 3); - check_invariant(m1); + assert(m2.size() == 5); + assert(std::ranges::is_sorted(m1)); LIBCPP_ASSERT(m1.empty()); } } From fe0aa08bf0eac1c2edce2f0167c602b1086526a0 Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Sun, 23 Mar 2025 14:45:49 +0000 Subject: [PATCH 10/23] testing --- .../assign_initializer_list.pass.cpp | 8 + .../flat.multiset.cons/copy_assign.pass.cpp | 11 +- .../deduct.compile.pass.cpp | 14 +- .../flat.multiset.cons/deduct.pass.cpp | 615 ++++++++++-------- .../flat.multiset.cons/deduct_pmr.pass.cpp | 112 ++-- .../flat.multiset.cons/iter_iter.pass.cpp | 2 +- .../flat.multiset/helpers.h | 307 +++++++++ 7 files changed, 748 insertions(+), 321 deletions(-) create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/helpers.h diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/assign_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/assign_initializer_list.pass.cpp index 071b0be5d15d7..ae81ab044932d 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/assign_initializer_list.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/assign_initializer_list.pass.cpp @@ -43,6 +43,14 @@ void test() { double expected[] = {3}; assert(std::ranges::equal(m, expected)); } + { + // was empty + M m; + assert(m.size() == 0); + m = {3, 1, 2, 2, 3, 4, 3, 5, 6, 5}; + int expected[] = {1, 2, 2, 3, 3, 3, 4, 5, 5, 6}; + assert(std::ranges::equal(m, expected)); + } } void test() { diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/copy_assign.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/copy_assign.pass.cpp index 35e1945f27b18..2b6176ac915a7 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/copy_assign.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/copy_assign.pass.cpp @@ -80,9 +80,18 @@ void test() { // self-assignment using M = std::flat_multiset; M m = {{1, 2}}; - m = static_cast(m); + m = std::as_const(m); assert((m == M{{1, 2}})); } + { + // was empty + using M = std::flat_multiset; + M m; + assert(m.size() == 0); + m = {3, 1, 2, 2, 3, 4, 3, 5, 6, 5}; + int expected[] = {1, 2, 2, 3, 3, 3, 4, 5, 5, 6}; + assert(std::ranges::equal(m, expected)); + } { // Validate whether the container can be copy-assigned (move-assigned, swapped) // with an ADL-hijacking operator& diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct.compile.pass.cpp index 90bdad29661dd..f26c90bacdda7 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct.compile.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct.compile.pass.cpp @@ -23,21 +23,21 @@ struct NotAnAllocator { }; template -concept CanDeductFlatSet = requires { std::flat_multiset(std::declval()...); }; +concept CanDeductFlatMultiSet = requires { std::flat_multiset(std::declval()...); }; -static_assert(CanDeductFlatSet>); +static_assert(CanDeductFlatMultiSet>); // cannot deduce Key and T from nothing -static_assert(!CanDeductFlatSet<>); +static_assert(!CanDeductFlatMultiSet<>); // cannot deduce Key and T from just (Compare) -static_assert(!CanDeductFlatSet>); +static_assert(!CanDeductFlatMultiSet>); // cannot deduce Key and T from just (Compare, Allocator) -static_assert(!CanDeductFlatSet, std::allocator>); +static_assert(!CanDeductFlatMultiSet, std::allocator>); // cannot deduce Key and T from just (Allocator) -static_assert(!CanDeductFlatSet>); +static_assert(!CanDeductFlatMultiSet>); // cannot convert from some arbitrary unrelated type -static_assert(!CanDeductFlatSet); +static_assert(!CanDeductFlatMultiSet); diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct.pass.cpp index a2eec0be83ec5..7f611776e85c3 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct.pass.cpp @@ -26,286 +26,379 @@ #include "deduction_guides_sfinae_checks.h" #include "test_allocator.h" -void test_copy() { +void test() { { + // Deduction guide generated from + // flat_multiset(const flat_multiset&) std::flat_multiset source = {1, 2, 2}; std::flat_multiset s(source); ASSERT_SAME_TYPE(decltype(s), decltype(source)); assert(s == source); } { + // Deduction guide generated from + // flat_multiset(const flat_multiset&) + // braces instead of parens std::flat_multiset> source = {1, 2, 2}; - std::flat_multiset s{source}; // braces instead of parens + std::flat_multiset s{source}; ASSERT_SAME_TYPE(decltype(s), decltype(source)); assert(s == source); } { + // Deduction guide generated from + // flat_set(const flat_set&, const Allocator&) std::flat_multiset> source = {1, 2, 2}; std::flat_multiset s(source, std::allocator()); ASSERT_SAME_TYPE(decltype(s), decltype(source)); assert(s == source); } -} -void test_containers() { - std::deque> ks({1, 2, 1, INT_MAX, 3}, test_allocator(0, 42)); - std::deque> sorted_ks({1, 1, 2, 3, INT_MAX}, test_allocator(0, 42)); - int expected[] = {1, 1, 2, 3, INT_MAX}; - { - std::flat_multiset s(ks); - - ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); - assert(std::ranges::equal(s, expected)); - assert(std::move(s).extract().get_allocator().get_id() == 42); - } - { - std::flat_multiset s(std::sorted_equivalent, sorted_ks); - - ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); - assert(std::ranges::equal(s, expected)); - assert(std::move(s).extract().get_allocator().get_id() == 42); - } - { - std::flat_multiset s(ks, test_allocator(0, 44)); - - ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); - assert(std::ranges::equal(s, expected)); - assert(std::move(s).extract().get_allocator().get_id() == 44); - } - { - std::flat_multiset s(std::sorted_equivalent, sorted_ks, test_allocator(0, 44)); - - ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); - assert(std::ranges::equal(s, expected)); - assert(std::move(s).extract().get_allocator().get_id() == 44); - } -} - -void test_containers_compare() { - std::deque> ks({1, 2, 1, INT_MAX, 3}, test_allocator(0, 42)); - std::deque> sorted_ks({INT_MAX, 3, 2, 1, 1}, test_allocator(0, 42)); - int expected[] = {INT_MAX, 3, 2, 1, 1}; - { - std::flat_multiset s(ks, std::greater()); - - ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); - assert(std::ranges::equal(s, expected)); - assert(std::move(s).extract().get_allocator().get_id() == 42); - } - { - std::flat_multiset s(std::sorted_equivalent, sorted_ks, std::greater()); - - ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); - assert(std::ranges::equal(s, expected)); - assert(std::move(s).extract().get_allocator().get_id() == 42); - } - { - std::flat_multiset s(ks, std::greater(), test_allocator(0, 44)); - - ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); - assert(std::ranges::equal(s, expected)); - assert(std::move(s).extract().get_allocator().get_id() == 44); - } - { - std::flat_multiset s(std::sorted_equivalent, sorted_ks, std::greater(), test_allocator(0, 44)); - - ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); - assert(std::ranges::equal(s, expected)); - assert(std::move(s).extract().get_allocator().get_id() == 44); - } -} - -void test_iter_iter() { - int arr[] = {1, 2, 1, INT_MAX, 3}; - int sorted_arr[] = {1, 1, 2, 3, INT_MAX}; - const int arrc[] = {1, 2, 1, INT_MAX, 3}; - const int sorted_arrc[] = {1, 1, 2, 3, INT_MAX}; - { - std::flat_multiset m(std::begin(arr), std::end(arr)); - - ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); - assert(std::ranges::equal(m, sorted_arr)); - } - { - std::flat_multiset m(std::begin(arrc), std::end(arrc)); - - ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); - assert(std::ranges::equal(m, sorted_arr)); - } - { - std::flat_multiset m(std::sorted_equivalent, std::begin(sorted_arr), std::end(sorted_arr)); - - ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); - assert(std::ranges::equal(m, sorted_arr)); - } { - std::flat_multiset m(std::sorted_equivalent, std::begin(sorted_arrc), std::end(sorted_arrc)); - - ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); - assert(std::ranges::equal(m, sorted_arr)); - } - { - std::flat_multiset mo; - std::flat_multiset m(mo.begin(), mo.end()); - ASSERT_SAME_TYPE(decltype(m), decltype(mo)); - } - { - std::flat_multiset mo; - std::flat_multiset m(mo.cbegin(), mo.cend()); - ASSERT_SAME_TYPE(decltype(m), decltype(mo)); - } - { - int source[3] = {1, 2, 3}; - std::flat_multiset s(source, source + 3); - ASSERT_SAME_TYPE(decltype(s), std::flat_multiset); - assert(s.size() == 3); + std::deque> ks({1, 2, 1, INT_MAX, 3}, test_allocator(0, 42)); + std::deque> sorted_ks({1, 1, 2, 3, INT_MAX}, test_allocator(0, 42)); + int expected[] = {1, 1, 2, 3, INT_MAX}; + { + // template> + // flat_multiset(KeyContainer, Compare = Compare()) + // -> flat_multiset; + std::flat_multiset s(ks); + + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 42); + } + { + // template> + // flat_multiset(sorted_equivalent_t, KeyContainer, Compare = Compare()) + // -> flat_multiset; + std::flat_multiset s(std::sorted_equivalent, sorted_ks); + + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 42); + } + { + // template + // flat_multiset(KeyContainer, Allocator) + // -> flat_multiset, KeyContainer>; + std::flat_multiset s(ks, test_allocator(0, 44)); + + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 44); + } + { + // template + // flat_multiset(sorted_equivalent_t, KeyContainer, Allocator) + // -> flat_multiset, KeyContainer>; + std::flat_multiset s(std::sorted_equivalent, sorted_ks, test_allocator(0, 44)); + + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 44); + } + } + { + std::deque> ks({1, 2, 1, INT_MAX, 3}, test_allocator(0, 42)); + std::deque> sorted_ks({INT_MAX, 3, 2, 1, 1}, test_allocator(0, 42)); + int expected[] = {INT_MAX, 3, 2, 1, 1}; + { + // template> + // flat_multiset(KeyContainer, Compare = Compare()) + // -> flat_multiset; + std::flat_multiset s(ks, std::greater()); + + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 42); + } + { + // template> + // flat_multiset(sorted_equivalent_t, KeyContainer, Compare = Compare()) + // -> flat_multiset; + + std::flat_multiset s(std::sorted_equivalent, sorted_ks, std::greater()); + + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 42); + } + { + // template + // flat_multiset(KeyContainer, Compare, Allocator) + // -> flat_multiset; + std::flat_multiset s(ks, std::greater(), test_allocator(0, 44)); + + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 44); + } + { + // template + // flat_multiset(sorted_equivalent_t, KeyContainer, Compare, Allocator) + // -> flat_multiset; + std::flat_multiset s(std::sorted_equivalent, sorted_ks, std::greater(), test_allocator(0, 44)); + + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, decltype(ks)>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 44); + } + } + + { + int arr[] = {1, 2, 1, INT_MAX, 3}; + int sorted_arr[] = {1, 1, 2, 3, INT_MAX}; + const int arrc[] = {1, 2, 1, INT_MAX, 3}; + const int sorted_arrc[] = {1, 1, 2, 3, INT_MAX}; + { + // template>> + // flat_multiset(InputIterator, InputIterator, Compare = Compare()) + // -> flat_multiset, Compare>; + std::flat_multiset m(std::begin(arr), std::end(arr)); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // template>> + // flat_multiset(InputIterator, InputIterator, Compare = Compare()) + // -> flat_multiset, Compare>; + // const + std::flat_multiset m(std::begin(arrc), std::end(arrc)); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // template>> + // flat_multiset(sorted_equivalent_t, InputIterator, InputIterator, Compare = Compare()) + // -> flat_multiset, Compare>; + std::flat_multiset m(std::sorted_equivalent, std::begin(sorted_arr), std::end(sorted_arr)); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // template>> + // flat_multiset(sorted_equivalent_t, InputIterator, InputIterator, Compare = Compare()) + // -> flat_multiset, Compare>; + // const + std::flat_multiset m(std::sorted_equivalent, std::begin(sorted_arrc), std::end(sorted_arrc)); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // template>> + // flat_multiset(InputIterator, InputIterator, Compare = Compare()) + // -> flat_multiset, Compare>; + // flat_multiset iterator + std::flat_multiset mo; + std::flat_multiset m(mo.begin(), mo.end()); + ASSERT_SAME_TYPE(decltype(m), decltype(mo)); + } + { + // template>> + // flat_multiset(InputIterator, InputIterator, Compare = Compare()) + // -> flat_multiset, Compare>; + // flat_multiset const_iterator + std::flat_multiset mo; + std::flat_multiset m(mo.cbegin(), mo.cend()); + ASSERT_SAME_TYPE(decltype(m), decltype(mo)); + } + { + // This does not deduce to flat_multiset(InputIterator, InputIterator) + // But deduces to flat_multiset(initializer_list) + int source[3] = {1, 2, 3}; + std::flat_multiset s = {source, source + 3}; + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset); + assert(s.size() == 2); + } + { + // flat_multiset(sorted_equivalent_t, InputIterator, InputIterator) + // braces + int source[3] = {1, 2, 3}; + std::flat_multiset s{std::sorted_equivalent, source, source + 3}; + static_assert(std::is_same_v>); + assert(s.size() == 3); + } + } + + { + int arr[] = {1, 2, 1, INT_MAX, 3}; + int sorted_arr[] = {INT_MAX, 3, 2, 1, 1}; + const int arrc[] = {1, 2, 1, INT_MAX, 3}; + const int sorted_arrc[] = {INT_MAX, 3, 2, 1, 1}; + using C = std::greater; + { + // template>> + // flat_multiset(InputIterator, InputIterator, Compare = Compare()) + // -> flat_multiset, Compare>; + std::flat_multiset m(std::begin(arr), std::end(arr), C()); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // template>> + // flat_multiset(InputIterator, InputIterator, Compare = Compare()) + // -> flat_multiset, Compare>; + // const + std::flat_multiset m(std::begin(arrc), std::end(arrc), C()); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // template>> + // flat_multiset(sorted_equivalent_t, InputIterator, InputIterator, Compare = Compare()) + // -> flat_multiset, Compare>; + std::flat_multiset m(std::sorted_equivalent, std::begin(sorted_arr), std::end(sorted_arr), C()); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // template>> + // flat_multiset(sorted_equivalent_t, InputIterator, InputIterator, Compare = Compare()) + // -> flat_multiset, Compare>; + // const + std::flat_multiset m(std::sorted_equivalent, std::begin(sorted_arrc), std::end(sorted_arrc), C()); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // template>> + // flat_multiset(InputIterator, InputIterator, Compare = Compare()) + // -> flat_multiset, Compare>; + // flat_multiset iterator + std::flat_multiset mo; + std::flat_multiset m(mo.begin(), mo.end(), C()); + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + } + { + // template>> + // flat_multiset(InputIterator, InputIterator, Compare = Compare()) + // -> flat_multiset, Compare>; + // flat_multiset const_iterator + std::flat_multiset mo; + std::flat_multiset m(mo.cbegin(), mo.cend(), C()); + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + } + } + { + const int sorted_arr[] = {1, 1, 2, 3, INT_MAX}; + { + // template> + // flat_multiset(initializer_list, Compare = Compare()) + // -> flat_multiset; + std::flat_multiset m{1, 2, 1, INT_MAX, 3}; + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // template> + // flat_multiset(sorted_equivalent_t, initializer_list, Compare = Compare()) + // -> flat_multiset; + std::flat_multiset m(std::sorted_equivalent, {1, 1, 2, 3, INT_MAX}); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // One element with brace was treated as initializer_list + std::flat_multiset s = {1}; + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset); + assert(s.size() == 1); + } + { + // Two elements with brace was treated as initializer_list + using M = std::flat_multiset; + M m; + std::flat_multiset s{m, m}; // flat_multiset(initializer_list) + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset); + assert(s.size() == 2); + } + } + { + const int sorted_arr[] = {INT_MAX, 3, 2, 1, 1}; + using C = std::greater; + { + // template> + // flat_multiset(initializer_list, Compare = Compare()) + // -> flat_multiset; + std::flat_multiset m({1, 2, 1, INT_MAX, 3}, C()); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + { + // template> + // flat_multiset(sorted_equivalent_t, initializer_list, Compare = Compare()) + // -> flat_multiset; + std::flat_multiset m(std::sorted_equivalent, {INT_MAX, 3, 2, 1, 1}, C()); + + ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); + assert(std::ranges::equal(m, sorted_arr)); + } + } + { + std::list r = {1, 2, 1, INT_MAX, 3}; + const int expected[] = {1, 1, 2, 3, INT_MAX}; + { + // template>, + // class Allocator = allocator>> + // flat_multiset(from_range_t, R&&, Compare = Compare(), Allocator = Allocator()) + // -> flat_multiset, Compare, + // vector, + // alloc-rebind>>>; + std::flat_multiset s(std::from_range, r); + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset>); + assert(std::ranges::equal(s, expected)); + } + { + // template + // flat_multiset(from_range_t, R&&, Allocator) + // -> flat_multiset, less>, + // vector, + // alloc-rebind>>>; + std::flat_multiset s(std::from_range, r, test_allocator(0, 42)); + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, std::vector>>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 42); + } + } + + { + // with comparator + std::list r = {1, 2, 1, INT_MAX, 3}; + const int expected[] = {INT_MAX, 3, 2, 1, 1}; + { + // template>, + // class Allocator = allocator>> + // flat_multiset(from_range_t, R&&, Compare = Compare(), Allocator = Allocator()) + // -> flat_multiset, Compare, + // vector, + // alloc-rebind>>>; + std::flat_multiset s(std::from_range, r, std::greater()); + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset>); + assert(std::ranges::equal(s, expected)); + } + { + // template + // flat_multiset(from_range_t, R&&, Allocator) + // -> flat_multiset, less>, + // vector, + // alloc-rebind>>>; + std::flat_multiset s(std::from_range, r, std::greater(), test_allocator(0, 42)); + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, std::vector>>); + assert(std::ranges::equal(s, expected)); + assert(std::move(s).extract().get_allocator().get_id() == 42); + } } - { - // This does not deduce to flat_multiset(InputIterator, InputIterator) - // But deduces to flat_multiset(initializer_list) - int source[3] = {1, 2, 3}; - std::flat_multiset s = {source, source + 3}; - ASSERT_SAME_TYPE(decltype(s), std::flat_multiset); - assert(s.size() == 2); - } - { - int source[3] = {1, 2, 3}; - std::flat_multiset s{ - std::sorted_equivalent, source, source + 3}; // flat_multiset(sorted_equivalent_t, InputIterator, InputIterator) - static_assert(std::is_same_v>); - assert(s.size() == 3); - } -} - -void test_iter_iter_compare() { - int arr[] = {1, 2, 1, INT_MAX, 3}; - int sorted_arr[] = {INT_MAX, 3, 2, 1, 1}; - const int arrc[] = {1, 2, 1, INT_MAX, 3}; - const int sorted_arrc[] = {INT_MAX, 3, 2, 1, 1}; - using C = std::greater; - { - std::flat_multiset m(std::begin(arr), std::end(arr), C()); - - ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); - assert(std::ranges::equal(m, sorted_arr)); - } - { - std::flat_multiset m(std::begin(arrc), std::end(arrc), C()); - - ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); - assert(std::ranges::equal(m, sorted_arr)); - } - { - std::flat_multiset m(std::sorted_equivalent, std::begin(sorted_arr), std::end(sorted_arr), C()); - - ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); - assert(std::ranges::equal(m, sorted_arr)); - } - { - std::flat_multiset m(std::sorted_equivalent, std::begin(sorted_arrc), std::end(sorted_arrc), C()); - - ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); - assert(std::ranges::equal(m, sorted_arr)); - } - { - std::flat_multiset mo; - std::flat_multiset m(mo.begin(), mo.end(), C()); - ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); - } - { - std::flat_multiset mo; - std::flat_multiset m(mo.cbegin(), mo.cend(), C()); - ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); - } -} - -void test_initializer_list() { - const int sorted_arr[] = {1, 1, 2, 3, INT_MAX}; - { - std::flat_multiset m{1, 2, 1, INT_MAX, 3}; - - ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); - assert(std::ranges::equal(m, sorted_arr)); - } - { - std::flat_multiset m(std::sorted_equivalent, {1, 1, 2, 3, INT_MAX}); - - ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); - assert(std::ranges::equal(m, sorted_arr)); - } - { - std::flat_multiset s = {1}; - ASSERT_SAME_TYPE(decltype(s), std::flat_multiset); - assert(s.size() == 1); - } - { - using M = std::flat_multiset; - M m; - std::flat_multiset s{m, m}; // flat_multiset(initializer_list) - ASSERT_SAME_TYPE(decltype(s), std::flat_multiset); - assert(s.size() == 2); - } -} - -void test_initializer_list_compare() { - const int sorted_arr[] = {INT_MAX, 3, 2, 1, 1}; - using C = std::greater; - { - std::flat_multiset m({1, 2, 1, INT_MAX, 3}, C()); - - ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); - assert(std::ranges::equal(m, sorted_arr)); - } - { - std::flat_multiset m(std::sorted_equivalent, {INT_MAX, 3, 2, 1, 1}, C()); - - ASSERT_SAME_TYPE(decltype(m), std::flat_multiset); - assert(std::ranges::equal(m, sorted_arr)); - } -} - -void test_from_range() { - std::list r = {1, 2, 1, INT_MAX, 3}; - const int expected[] = {1, 1, 2, 3, INT_MAX}; - { - std::flat_multiset s(std::from_range, r); - ASSERT_SAME_TYPE(decltype(s), std::flat_multiset>); - assert(std::ranges::equal(s, expected)); - } - { - std::flat_multiset s(std::from_range, r, test_allocator(0, 42)); - ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, std::vector>>); - assert(std::ranges::equal(s, expected)); - assert(std::move(s).extract().get_allocator().get_id() == 42); - } -} - -void test_from_range_compare() { - std::list r = {1, 2, 1, INT_MAX, 3}; - const int expected[] = {INT_MAX, 3, 2, 1, 1}; - { - std::flat_multiset s(std::from_range, r, std::greater()); - ASSERT_SAME_TYPE(decltype(s), std::flat_multiset>); - assert(std::ranges::equal(s, expected)); - } - { - std::flat_multiset s(std::from_range, r, std::greater(), test_allocator(0, 42)); - ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, std::vector>>); - assert(std::ranges::equal(s, expected)); - assert(std::move(s).extract().get_allocator().get_id() == 42); - } -} - -void test() { - // Each test function also tests the sorted_equivalent-prefixed and allocator-suffixed overloads. - test_copy(); - test_containers(); - test_containers_compare(); - test_iter_iter(); - test_iter_iter_compare(); - test_initializer_list(); - test_initializer_list_compare(); - test_from_range(); - test_from_range_compare(); AssociativeContainerDeductionGuidesSfinaeAway>(); } diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct_pmr.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct_pmr.pass.cpp index ed3649a7301f7..367dc55e34410 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct_pmr.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/deduct_pmr.pass.cpp @@ -30,65 +30,75 @@ using P = std::pair; using PC = std::pair; -void test_containers() { - std::deque> ks({1, 2, 1, INT_MAX, 3}, test_allocator(0, 42)); - std::deque> sorted_ks({1, 1, 2, 3, INT_MAX}, test_allocator(0, 42)); - const int expected[] = {1, 1, 2, 3, INT_MAX}; +int main(int, char**) { { - std::pmr::monotonic_buffer_resource mr; - std::pmr::monotonic_buffer_resource mr2; - std::pmr::deque pks(ks.begin(), ks.end(), &mr); - std::flat_multiset s(std::move(pks), &mr2); + std::deque> ks({1, 2, 1, INT_MAX, 3}, test_allocator(0, 42)); + std::deque> sorted_ks({1, 1, 2, 3, INT_MAX}, test_allocator(0, 42)); + const int expected[] = {1, 1, 2, 3, INT_MAX}; + { + // template + // flat_multiset(KeyContainer, Allocator) + // -> flat_multiset, KeyContainer>; + std::pmr::monotonic_buffer_resource mr; + std::pmr::monotonic_buffer_resource mr2; + std::pmr::deque pks(ks.begin(), ks.end(), &mr); + std::flat_multiset s(std::move(pks), &mr2); - ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, std::pmr::deque>); - assert(std::ranges::equal(s, expected)); - auto keys = std::move(s).extract(); - assert(keys.get_allocator().resource() == &mr2); - } - { - 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_multiset s(std::sorted_equivalent, std::move(pks), &mr2); + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, std::pmr::deque>); + assert(std::ranges::equal(s, expected)); + auto keys = std::move(s).extract(); + assert(keys.get_allocator().resource() == &mr2); + } + { + // template + // flat_multiset(sorted_equivalent_t, KeyContainer, Allocator) + // -> flat_multiset, 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_multiset s(std::sorted_equivalent, std::move(pks), &mr2); - ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, std::pmr::deque>); - assert(std::ranges::equal(s, expected)); - auto keys = std::move(s).extract(); - assert(keys.get_allocator().resource() == &mr2); + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, std::pmr::deque>); + assert(std::ranges::equal(s, expected)); + auto keys = std::move(s).extract(); + assert(keys.get_allocator().resource() == &mr2); + } } -} - -void test_containers_compare() { - std::deque> ks({1, 2, 1, INT_MAX, 3}, test_allocator(0, 42)); - std::deque> sorted_ks({INT_MAX, 3, 2, 1, 1}, test_allocator(0, 42)); - const int expected[] = {INT_MAX, 3, 2, 1, 1}; { - std::pmr::monotonic_buffer_resource mr; - std::pmr::monotonic_buffer_resource mr2; - std::pmr::deque pks(ks.begin(), ks.end(), &mr); - std::flat_multiset s(std::move(pks), std::greater(), &mr2); + std::deque> ks({1, 2, 1, INT_MAX, 3}, test_allocator(0, 42)); + std::deque> sorted_ks({INT_MAX, 3, 2, 1, 1}, test_allocator(0, 42)); + const int expected[] = {INT_MAX, 3, 2, 1, 1}; + { + // template + // flat_multiset(KeyContainer, Compare, Allocator) + // -> flat_multiset; + std::pmr::monotonic_buffer_resource mr; + std::pmr::monotonic_buffer_resource mr2; + std::pmr::deque pks(ks.begin(), ks.end(), &mr); + std::flat_multiset s(std::move(pks), std::greater(), &mr2); - ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, std::pmr::deque>); - assert(std::ranges::equal(s, expected)); - auto keys = std::move(s).extract(); - assert(keys.get_allocator().resource() == &mr2); - } - { - 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_multiset s(std::sorted_equivalent, std::move(pks), std::greater(), &mr2); + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, std::pmr::deque>); + assert(std::ranges::equal(s, expected)); + auto keys = std::move(s).extract(); + assert(keys.get_allocator().resource() == &mr2); + } + { + // template + // flat_multiset(sorted_equivalent_t, KeyContainer, Compare, Allocator) + // -> flat_multiset; + 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_multiset s(std::sorted_equivalent, std::move(pks), std::greater(), &mr2); - ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, std::pmr::deque>); - assert(std::ranges::equal(s, expected)); - auto keys = std::move(s).extract(); - assert(keys.get_allocator().resource() == &mr2); + ASSERT_SAME_TYPE(decltype(s), std::flat_multiset, std::pmr::deque>); + assert(std::ranges::equal(s, expected)); + auto keys = std::move(s).extract(); + assert(keys.get_allocator().resource() == &mr2); + } } -} - -int main(int, char**) { - test_containers(); - test_containers_compare(); return 0; } diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/iter_iter.pass.cpp index 7a07b5283fe1b..da9aef3dc36cd 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/iter_iter.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/iter_iter.pass.cpp @@ -56,7 +56,7 @@ void test() { } int ar[] = {1, 1, 1, 2, 2, 3, 2, 3, 3}; - int expected[] = {1, 1,1,2,2,2,3,3,3}; + int expected[] = {1, 1, 1, 2, 2, 2, 3, 3, 3}; { // flat_multiset(InputIterator , InputIterator) // cpp17_input_iterator diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/helpers.h b/libcxx/test/std/containers/container.adaptors/flat.multiset/helpers.h new file mode 100644 index 0000000000000..2ee8b021337a0 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/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 SUPPORT_FLAT_SET_HELPERS_H +#define SUPPORT_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 // SUPPORT_FLAT_SET_HELPERS_H From 5802e5267d077d5fd701029018a6707283268c2e Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Sun, 23 Mar 2025 18:44:45 +0000 Subject: [PATCH 11/23] rebase --- libcxx/include/CMakeLists.txt | 1 + libcxx/include/__flat_set/flat_multiset.h | 42 ++++------ libcxx/include/__flat_set/flat_set.h | 42 ++-------- libcxx/include/__flat_set/utils.h | 80 +++++++++++++++++++ libcxx/include/module.modulemap | 1 + .../flat.multiset.cons/move.pass.cpp | 18 ++--- .../flat.multiset.cons/move_assign.pass.cpp | 50 ++++++------ .../flat.multiset.cons/pmr.pass.cpp | 43 +++++----- .../flat.multiset.cons/range.pass.cpp | 5 +- .../sorted_container.pass.cpp | 30 +++---- .../sorted_initializer_list.pass.cpp | 28 ++++--- .../sorted_iter_iter.pass.cpp | 48 +++++------ .../flat.multiset/helpers.h | 36 ++++----- .../flat.set.erasure/erase_if.pass.cpp | 10 --- .../flat.set.modifiers/clear.pass.cpp | 9 --- .../flat.set.operations/contains.pass.cpp | 7 -- .../flat.set.operations/count.pass.cpp | 7 -- .../flat.set.operations/equal_range.pass.cpp | 7 -- .../flat.set.operations/find.pass.cpp | 7 -- .../flat.set.operations/lower_bound.pass.cpp | 7 -- .../flat.set.operations/upper_bound.pass.cpp | 7 -- 21 files changed, 233 insertions(+), 252 deletions(-) create mode 100644 libcxx/include/__flat_set/utils.h diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt index e70e27bcdcf9f..4f4b31f2dc3cd 100644 --- a/libcxx/include/CMakeLists.txt +++ b/libcxx/include/CMakeLists.txt @@ -372,6 +372,7 @@ set(files __flat_set/flat_multiset.h __flat_set/flat_set.h __flat_set/ra_iterator.h + __flat_set/utils.h __format/buffer.h __format/concepts.h __format/container_adaptor.h diff --git a/libcxx/include/__flat_set/flat_multiset.h b/libcxx/include/__flat_set/flat_multiset.h index 9a95347329368..d84a06e664ed3 100644 --- a/libcxx/include/__flat_set/flat_multiset.h +++ b/libcxx/include/__flat_set/flat_multiset.h @@ -10,6 +10,7 @@ #ifndef _LIBCPP___FLAT_MAP_FLAT_MULTISET_H #define _LIBCPP___FLAT_MAP_FLAT_MULTISET_H +#include "utils.h" #include <__algorithm/lexicographical_compare_three_way.h> #include <__algorithm/min.h> #include <__algorithm/ranges_equal.h> @@ -32,6 +33,7 @@ #include <__flat_map/key_value_iterator.h> #include <__flat_map/sorted_equivalent.h> #include <__flat_set/ra_iterator.h> +#include <__flat_set/utils.h> #include <__functional/invoke.h> #include <__functional/is_transparent.h> #include <__functional/operations.h> @@ -66,6 +68,7 @@ #include <__utility/pair.h> #include <__utility/scope_guard.h> #include <__vector/vector.h> +#include #include #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) @@ -84,6 +87,8 @@ class flat_multiset { template friend class flat_multiset; + friend __flat_set_utils; + static_assert(is_same_v<_Key, typename _KeyContainer::value_type>); static_assert(!is_same_v<_KeyContainer, std::vector>, "vector is not a sequence container"); @@ -356,9 +361,9 @@ class flat_multiset { requires is_constructible_v _LIBCPP_HIDE_FROM_ABI iterator emplace(_Args&&... __args) { if constexpr (sizeof...(__args) == 1 && (is_same_v, _Key> && ...)) { - return __try_emplace(std::forward<_Args>(__args)...); + return __emplace(std::forward<_Args>(__args)...); } else { - return __try_emplace(_Key(std::forward<_Args>(__args)...)); + return __emplace(_Key(std::forward<_Args>(__args)...)); } } @@ -448,7 +453,7 @@ class flat_multiset { __reserve(ranges::size(__range)); } - __append_sort_merge(ranges::begin(__range), ranges::end(__range)); + __append_sort_merge(std::forward<_Range>(__range)); } _LIBCPP_HIDE_FROM_ABI void insert(initializer_list __il) { insert(__il.begin(), __il.end()); } @@ -627,32 +632,11 @@ class flat_multiset { friend _LIBCPP_HIDE_FROM_ABI void swap(flat_multiset& __x, flat_multiset& __y) noexcept { __x.swap(__y); } private: - // todo: share with flat_set - 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(_Args&&... __args) { auto __on_failure = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; }); size_type __old_size = size(); - __append(std::forward<_Args>(__args)...); + __flat_set_utils::__append(*this, std::forward<_Args>(__args)...); if (size() != __old_size) { if constexpr (!_WasSorted) { ranges::sort(__keys_.begin() + __old_size, __keys_.end(), __compare_); @@ -665,11 +649,17 @@ class flat_multiset { __on_failure.__complete(); } + template + _LIBCPP_HIDE_FROM_ABI iterator __emplace(_Kp&& __key) { + auto __it = upper_bound(__key); + return __flat_set_utils::__emplace_exact_pos(*this, __it, std::forward<_Kp>(__key)); + } + 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->first)) { + if (__it == __last || __self.__compare_(__key, *__it)) { return __last; } return __it; diff --git a/libcxx/include/__flat_set/flat_set.h b/libcxx/include/__flat_set/flat_set.h index dca06c7236e73..26336e840d17c 100644 --- a/libcxx/include/__flat_set/flat_set.h +++ b/libcxx/include/__flat_set/flat_set.h @@ -10,6 +10,7 @@ #ifndef _LIBCPP___FLAT_SET_FLAT_SET_H #define _LIBCPP___FLAT_SET_FLAT_SET_H +#include "utils.h" #include <__algorithm/lexicographical_compare_three_way.h> #include <__algorithm/lower_bound.h> #include <__algorithm/min.h> @@ -28,6 +29,7 @@ #include <__cstddef/ptrdiff_t.h> #include <__flat_map/sorted_unique.h> #include <__flat_set/ra_iterator.h> +#include <__flat_set/utils.h> #include <__functional/invoke.h> #include <__functional/is_transparent.h> #include <__functional/operations.h> @@ -82,6 +84,8 @@ class flat_set { template friend class flat_set; + friend __flat_set_utils; + static_assert(is_same_v<_Key, typename _KeyContainer::value_type>); static_assert(!is_same_v<_KeyContainer, std::vector>, "vector is not a sequence container"); @@ -619,31 +623,11 @@ class flat_set { __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)...); + __flat_set_utils::__append(*this, std::forward<_Args>(__args)...); if (size() != __old_size) { if constexpr (!_WasSorted) { ranges::sort(__keys_.begin() + __old_size, __keys_.end(), __compare_); @@ -680,23 +664,11 @@ class flat_set { 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); + return pair(__flat_set_utils::__emplace_exact_pos(*this, __it, std::forward<_Kp>(__key)), true); } else { return pair(std::move(__it), false); } @@ -717,7 +689,7 @@ class flat_set { _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)); + return __flat_set_utils::__emplace_exact_pos(*this, __hint, std::forward<_Kp>(__key)); } else { // we already have an equal key return __hint; diff --git a/libcxx/include/__flat_set/utils.h b/libcxx/include/__flat_set/utils.h new file mode 100644 index 0000000000000..c39fc6b33c5c8 --- /dev/null +++ b/libcxx/include/__flat_set/utils.h @@ -0,0 +1,80 @@ +// -*- 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_UTILS_H +#define _LIBCPP___FLAT_SET_UTILS_H + +#include <__config> +#include <__ranges/access.h> +#include <__ranges/concepts.h> +#include <__type_traits/container_traits.h> +#include <__type_traits/decay.h> +#include <__utility/exception_guard.h> +#include <__utility/forward.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 + +// These utilities are defined in a class instead of a namespace so that this class can be befriended more easily. +struct __flat_set_utils { + // Emplace a key into a flat_{multi}set, at the exact position that + // __it point to, assuming that the key is not already present in the set. + // When an exception is thrown during the emplacement, the function will clear the set if the container does not + // have strong exception safety guarantee on emplacement. + template + _LIBCPP_HIDE_FROM_ABI static auto __emplace_exact_pos(_Set& __set, _Iter&& __iter, _KeyArg&& __key) { + using _KeyContainer = typename decay_t<_Set>::container_type; + auto __on_failure = std::__make_exception_guard([&]() noexcept { + if constexpr (!__container_traits<_KeyContainer>::__emplacement_has_strong_exception_safety_guarantee) { + __set.clear() /* noexcept */; + } + }); + auto __key_it = __set.__keys_.emplace(__iter.__base(), std::forward<_KeyArg>(__key)); + __on_failure.__complete(); + return typename decay_t<_Set>::iterator(std::move(__key_it)); + } + + // TODO: We could optimize this, see + // https://github.com/llvm/llvm-project/issues/108624 + template + _LIBCPP_HIDE_FROM_ABI static void __append(_Set& __set, _InputIterator __first, _InputIterator __last) { + __set.__keys_.insert(__set.__keys_.end(), std::move(__first), std::move(__last)); + } + + template + _LIBCPP_HIDE_FROM_ABI static void __append(_Set& __set, _Range&& __rng) { + if constexpr (requires { __set.__keys_.insert_range(__set.__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. + __set.__keys_.insert_range(__set.__keys_.end(), std::forward<_Range>(__rng)); + } else if constexpr (ranges::common_range<_Range>) { + __set.__keys_.insert(__set.__keys_.end(), ranges::begin(__rng), ranges::end(__rng)); + } else { + for (auto&& __x : __rng) { + __set.__keys_.insert(__set.__keys_.end(), std::forward(__x)); + } + } + } +}; +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP_STD_VER >= 23 + +_LIBCPP_POP_MACROS + +#endif // #define _LIBCPP___FLAT_SET_UTILS_H diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap index 8bcbf67eb6165..6997b0385c0b1 100644 --- a/libcxx/include/module.modulemap +++ b/libcxx/include/module.modulemap @@ -1308,6 +1308,7 @@ module std [system] { export std.vector.fwd } module ra_iterator { header "__flat_set/ra_iterator.h" } + module utils { header "__flat_set/utils.h" } header "flat_set" export std.flat_map.sorted_unique diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move.pass.cpp index 32387054ab0e9..825ad75cc8f4c 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move.pass.cpp @@ -30,9 +30,9 @@ void test() { using C = test_less; using A = test_allocator; using M = std::flat_multiset>; - M mo = M({1, 2, 3}, C(5), A(7)); + M mo = M({1, 2, 1, 3}, C(5), A(7)); M m = std::move(mo); - assert((m == M{1, 2, 3})); + assert((m == M{1, 1, 2, 3})); assert(m.key_comp() == C(5)); assert(std::move(m).extract().get_allocator() == A(7)); @@ -44,9 +44,9 @@ void test() { using C = test_less; using A = min_allocator; using M = std::flat_multiset>; - M mo = M({1, 2, 3}, C(5), A()); + M mo = M({1, 2, 1, 3}, C(5), A()); M m = std::move(mo); - assert((m == M{1, 2, 3})); + assert((m == M{1, 1, 2, 3})); assert(m.key_comp() == C(5)); assert(std::move(m).extract().get_allocator() == A()); @@ -57,24 +57,24 @@ void test() { { // A moved-from flat_multiset maintains its class invariant in the presence of moved-from comparators. using M = std::flat_multiset>; - M mo = M({1, 2, 3}, std::less()); + M mo = M({1, 2, 1, 3}, std::less()); M m = std::move(mo); - assert(m.size() == 3); + assert(m.size() == 4); 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 + mo.insert({1, 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_multiset, CopyOnlyVector>; - M m1 = M({1, 2, 3}); + M m1 = M({1, 2, 1, 3}); M m2 = std::move(m1); - assert(m2.size() == 3); + assert(m2.size() == 4); check_invariant(m1); LIBCPP_ASSERT(m1.empty()); LIBCPP_ASSERT(m1.size() == 0); diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_assign.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_assign.pass.cpp index 58c3338f9b99e..96e046e38668f 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_assign.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/move_assign.pass.cpp @@ -71,54 +71,52 @@ struct MoveAssignThrows : std::vector { void test_move_assign_clears() { // Preserves the class invariant for the moved-from flat_multiset. { - const int expected[] = {1, 2, 3, 4, 5, 6, 7, 8}; + const int expected[] = {1, 1, 2, 3, 4, 5, 6, 7, 8}; using M = std::flat_multiset>; - M m = M(expected, expected + 8); - M m2 = M(expected, expected + 3); + M m = M(expected, expected + 9); + M m2 = M(expected, expected + 4); m2 = std::move(m); - assert(std::equal(m2.begin(), m2.end(), expected, expected + 8)); + assert(std::equal(m2.begin(), m2.end(), expected, expected + 9)); 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 + check_invariant(m); 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}; + const int expected[] = {1, 1, 2, 3, 4, 5, 6, 7, 8}; using M = std::flat_multiset>; - M m = M(expected, expected + 8); - M m2 = M(expected, expected + 3); + M m = M(expected, expected + 9); + M m2 = M(expected, expected + 4); m2 = std::move(m); - assert(std::equal(m2.begin(), m2.end(), expected, expected + 8)); + assert(std::equal(m2.begin(), m2.end(), expected, expected + 9)); 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 + check_invariant(m); 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_multiset, std::vector>; - M m1 = M({1, 2, 3}); + // moved-from object maintains invariant if the underlying container does not clear after move + using M = std::flat_multiset, CopyOnlyVector>; + M m1 = M({1, 1, 2, 3}); M m2 = M({1, 2}); m2 = std::move(m1); - assert(m2.size() == 3); + assert(m2.size() == 4); check_invariant(m1); LIBCPP_ASSERT(m1.empty()); } #if !defined(TEST_HAS_NO_EXCEPTIONS) { using M = std::flat_multiset, MoveAssignThrows>; - M m1 = {1, 2, 3}; - M m2 = {1, 2}; + M m1 = {1, 1, 2, 3}; + M m2 = {1, 1, 2}; try { m2 = std::move(m1); assert(false); @@ -194,11 +192,11 @@ void test() { using C = test_less; using A1 = test_allocator; using M = std::flat_multiset>; - M mo = M({1, 2, 3}, C(5), A1(7)); + M mo = M({1, 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 == M{1, 1, 2, 3})); assert(m.key_comp() == C(5)); auto ks = std::move(m).extract(); assert(ks.get_allocator() == A1(7)); @@ -208,11 +206,11 @@ void test() { using C = test_less; using A1 = other_allocator; using M = std::flat_multiset>; - M mo = M({4, 5}, C(5), A1(7)); - M m = M({1, 2, 3, 4}, C(3), A1(7)); + M mo = M({4, 4, 5}, C(5), A1(7)); + M m = M({1, 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 == M{4, 4, 5})); assert(m.key_comp() == C(5)); auto ks = std::move(m).extract(); assert(ks.get_allocator() == A1(7)); @@ -221,11 +219,11 @@ void test() { { using A = min_allocator; using M = std::flat_multiset, std::vector>; - M mo = M({5, 4, 3}, A()); - M m = M({4, 3, 2, 1}, A()); + M mo = M({5, 3, 4, 3}, A()); + M m = M({4, 1, 3, 2, 1}, A()); std::same_as decltype(auto) r = m = std::move(mo); assert(&r == &m); - assert((m == M{5, 4, 3})); + assert((m == M{5, 4, 3, 3})); auto ks = std::move(m).extract(); assert(ks.get_allocator() == A()); assert(mo.empty()); diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/pmr.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/pmr.pass.cpp index 6dcb491fd1d8c..9f356cae961db 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/pmr.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/pmr.pass.cpp @@ -26,6 +26,7 @@ #include "test_iterators.h" #include "test_macros.h" #include "test_allocator.h" +#include "../helpers.h" #include "../../../test_compare.h" void test() { @@ -62,7 +63,7 @@ void test() { 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((vm[0] == M{1, 1, 1, 2, 2, 2, 3, 3, 3})); assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); } { @@ -135,7 +136,7 @@ void test() { 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((vm[0] == M{1, 1, 3, 4, 5})); assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); } { @@ -146,14 +147,14 @@ void test() { 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((vm[0] == M{1, 1, 3, 4, 5})); assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); assert(vm[0].key_comp() == C(5)); } { // flat_multiset(InputIterator first, InputIterator last, const Allocator& a); int ar[] = {1, 1, 1, 2, 2, 3, 2, 3, 3}; - int expected[] = {1, 2, 3}; + int expected[] = {1, 1, 1, 2, 2, 2, 3, 3, 3}; { // cpp17 iterator using M = std::flat_multiset, std::pmr::vector>; @@ -174,7 +175,7 @@ void test() { } { // flat_multiset(flat_multiset&&, const allocator_type&); - int expected[] = {1, 2, 3}; + int expected[] = {1, 1, 2, 3}; using C = test_less; using M = std::flat_multiset>; std::pmr::monotonic_buffer_resource mr1; @@ -183,8 +184,8 @@ void test() { 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(m.size() == 4); + assert(std::ranges::equal(m, expected)); assert(std::move(m).extract().get_allocator().resource() == &mr2); // The original flat_multiset is moved-from. @@ -198,7 +199,7 @@ void test() { 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})); + assert((std::move(vs[0]).extract() == std::pmr::deque{1, 1, 2, 3})); } { // flat_multiset& operator=(flat_multiset&&); @@ -211,17 +212,17 @@ void test() { 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())); + check_invariant(m); assert(m.begin()->get_allocator().resource() == &mr2); - assert(std::is_sorted(mo.begin(), mo.end(), mo.value_comp())); + check_invariant(mo); mo.insert("foo"); assert(mo.begin()->get_allocator().resource() == &mr1); } { // flat_multiset(from_range_t, R&&, const Alloc&); int ar[] = {1, 1, 1, 2, 2, 3, 2, 3, 3}; - int expected[] = {1, 2, 3}; + int expected[] = {1, 1, 1, 2, 2, 2, 3, 3, 3}; { // input_range using M = std::flat_multiset, std::pmr::vector>; @@ -249,10 +250,10 @@ void test() { using M = std::flat_multiset, std::pmr::vector>; std::pmr::monotonic_buffer_resource mr; std::pmr::vector vm(&mr); - std::pmr::vector ks = {1, 2, 4, 10}; + std::pmr::vector ks = {1, 1, 2, 4, 10}; vm.emplace_back(std::sorted_equivalent, ks); assert(!ks.empty()); // it was an lvalue above - assert((vm[0] == M{1, 2, 4, 10})); + assert((vm[0] == M{1, 1, 2, 4, 10})); assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); } { @@ -260,9 +261,9 @@ void test() { using M = std::flat_multiset, std::pmr::vector>; std::pmr::monotonic_buffer_resource mr; std::pmr::vector vm(&mr); - std::pmr::vector ks({1, 2, 4, 10}, &mr); + std::pmr::vector ks({1, 1, 2, 4, 10}, &mr); vm.emplace_back(std::sorted_equivalent, ks); - assert((vm[0] == M{1, 2, 4, 10})); + assert((vm[0] == M{1, 1, 2, 4, 10})); assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); } { @@ -272,10 +273,10 @@ void test() { using M = std::flat_multiset>; std::pmr::monotonic_buffer_resource mr; std::pmr::vector vm(&mr); - int ar[] = {1, 2, 4, 5}; + int ar[] = {1, 1, 2, 4, 5}; vm.emplace_back( - std::sorted_equivalent, cpp17_input_iterator(ar), cpp17_input_iterator(ar + 4), C(3)); - assert((vm[0] == M{1, 2, 4, 5})); + std::sorted_equivalent, cpp17_input_iterator(ar), cpp17_input_iterator(ar + 5), C(3)); + assert((vm[0] == M{1, 1, 2, 4, 5})); assert(vm[0].key_comp() == C(3)); assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); } @@ -298,10 +299,10 @@ void test() { using M = std::flat_multiset>; std::pmr::monotonic_buffer_resource mr; std::pmr::vector vm(&mr); - int ar[] = {1, 2, 4, 5}; + int ar[] = {1, 1, 2, 4, 5}; vm.emplace_back( - std::sorted_equivalent, cpp17_input_iterator(ar), cpp17_input_iterator(ar + 4), C(3)); - assert((vm[0] == M{1, 2, 4, 5})); + std::sorted_equivalent, cpp17_input_iterator(ar), cpp17_input_iterator(ar + 5), C(3)); + assert((vm[0] == M{1, 1, 2, 4, 5})); assert(vm[0].key_comp() == C(3)); assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); } diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/range.pass.cpp index 11c981fdecdd1..76485b47ec5ea 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/range.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/range.pass.cpp @@ -80,7 +80,7 @@ void test() { } int ar[] = {1, 1, 1, 2, 2, 3, 2, 3, 3}; - int expected[] = {1, 2, 3}; + int expected[] = {1, 1, 1, 2, 2, 2, 3, 3, 3}; { // flat_multiset(from_range_t, R&&) // input_range && !common @@ -90,7 +90,6 @@ void test() { 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)))}; @@ -104,7 +103,7 @@ void test() { 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})); + assert(std::ranges::equal(m, std::deque>{3, 3, 3, 2, 2, 2, 1, 1, 1})); } { // flat_multiset(from_range_t, R&&) diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_container.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_container.pass.cpp index 43595265884e7..76759be7da8e3 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_container.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_container.pass.cpp @@ -55,14 +55,14 @@ void test() { { // flat_multiset(sorted_equivalent_t, container_type) using M = std::flat_multiset; - std::vector ks = {1, 2, 4, 10}; + std::vector ks = {1, 2, 2, 4, 10}; auto ks2 = ks; auto m = M(std::sorted_equivalent, ks); - assert((m == M{1, 2, 4, 10})); + assert((m == M{1, 2, 2, 4, 10})); m = M(std::sorted_equivalent, std::move(ks)); assert(ks.empty()); // it was moved-from - assert((m == M{1, 2, 4, 10})); + assert((m == M{1, 2, 2, 4, 10})); // explicit(false) M m2 = {std::sorted_equivalent, std::move(ks2)}; @@ -73,32 +73,32 @@ void test() { // non-default container, comparator and allocator type using Ks = std::deque>; using M = std::flat_multiset, Ks>; - Ks ks = {10, 4, 2, 1}; + Ks ks = {10, 4, 4, 2, 1}; auto m = M(std::sorted_equivalent, ks); - assert((m == M{1, 2, 4, 10})); + assert((m == M{1, 2, 4, 4, 10})); m = M(std::sorted_equivalent, std::move(ks)); assert(ks.empty()); // it was moved-from - assert((m == M{1, 2, 4, 10})); + assert((m == M{1, 2, 4, 4, 10})); } { // flat_multiset(sorted_equivalent_t, container_type) // allocator copied into the containers using A = test_allocator; using M = std::flat_multiset, std::deque>; - auto ks = std::deque({1, 2, 4, 10}, A(4)); + auto ks = std::deque({1, 2, 2, 4, 10}, A(4)); auto m = M(std::sorted_equivalent, std::move(ks)); assert(ks.empty()); // it was moved-from - assert((m == M{1, 2, 4, 10})); + assert((m == M{1, 2, 2, 4, 10})); assert(std::move(m).extract().get_allocator() == A(4)); } { // flat_multiset(sorted_equivalent_t, container_type , key_compare) using C = test_less; using M = std::flat_multiset; - std::vector ks = {1, 2, 4, 10}; + std::vector ks = {1, 2, 2, 4, 10}; auto m = M(std::sorted_equivalent, ks, C(4)); - assert((m == M{1, 2, 4, 10})); + assert((m == M{1, 2, 2, 4, 10})); assert(m.key_comp() == C(4)); // explicit(false) @@ -111,9 +111,9 @@ void test() { using C = test_less; using A = test_allocator; using M = std::flat_multiset>; - std::vector ks = {1, 2, 4, 10}; + std::vector ks = {1, 2, 2, 4, 10}; auto m = M(std::sorted_equivalent, ks, C(4), A(5)); - assert((m == M{1, 2, 4, 10})); + assert((m == M{1, 2, 2, 4, 10})); assert(m.key_comp() == C(4)); assert(M(m).extract().get_allocator() == A(5)); @@ -127,10 +127,10 @@ void test() { // flat_multiset(sorted_equivalent_t, container_type , const Allocator&) using A = test_allocator; using M = std::flat_multiset, std::deque>; - auto ks = std::deque({1, 2, 4, 10}, A(4)); + auto ks = std::deque({1, 2, 2, 4, 10}, A(4)); auto m = M(std::sorted_equivalent, ks, A(6)); // replaces the allocators - assert(!ks.empty()); // it was an lvalue above - assert((m == M{1, 2, 4, 10})); + assert(!ks.empty()); // it was an lvalue above + assert((m == M{1, 2, 2, 4, 10})); assert(M(m).extract().get_allocator() == A(6)); // explicit(false) diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_initializer_list.pass.cpp index 15adf6214a1f2..955662dd233ef 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_initializer_list.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_initializer_list.pass.cpp @@ -31,7 +31,7 @@ #include "../../../test_compare.h" template -std::initializer_list il = {1, 2, 4, 5}; +std::initializer_list il = {1, 2, 4, 4, 5}; void test() { const auto il1 = il; @@ -66,18 +66,22 @@ void test() { 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, 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>); + !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>); + !std:: + is_constructible_v, C, std::allocator>); static_assert( !std::is_constructible_v, std::allocator>); } @@ -86,7 +90,7 @@ void test() { // flat_multiset(sorted_equivalent_t, initializer_list); using M = std::flat_multiset; auto m = M(std::sorted_equivalent, il1); - auto expected = M{1, 2, 4, 5}; + auto expected = M{1, 2, 4, 4, 5}; assert(m == expected); // explicit(false) @@ -97,7 +101,7 @@ void test() { // flat_multiset(sorted_equivalent_t, initializer_list, const key_compare&); using M = std::flat_multiset>; auto m = M(std::sorted_equivalent, il1, std::less()); - assert(m == M({1, 2, 4, 5}, std::less<>())); + assert(m == M({1, 2, 4, 4, 5}, std::less<>())); assert(m.key_comp()(1, 2) == true); // explicit(false) @@ -108,16 +112,16 @@ void test() { // flat_multiset(sorted_equivalent_t, initializer_list, const key_compare&); // greater using M = std::flat_multiset, std::deque>>; - std::initializer_list il4{5, 4, 2, 1}; + std::initializer_list il4{5, 4, 4, 2, 1}; auto m = M(std::sorted_equivalent, il4, std::greater()); - assert((m == M{5, 4, 2, 1})); + assert((m == M{5, 4, 4, 2, 1})); } { // flat_multiset(sorted_equivalent_t, initializer_list, const Allocator&) using A1 = test_allocator; using M = std::flat_multiset, std::deque>; auto m = M(std::sorted_equivalent, il2, A1(5)); - auto expected = M{1, 2, 4, 5}; + auto expected = M{1, 2, 4, 4, 5}; assert(m == expected); assert(M(m).extract().get_allocator() == A1(5)); @@ -132,7 +136,7 @@ void test() { using A1 = test_allocator; using M = std::flat_multiset>; auto m = M(std::sorted_equivalent, il2, C(3), A1(5)); - assert((m == M{1, 2, 4, 5})); + assert((m == M{1, 2, 4, 4, 5})); assert(m.key_comp() == C(3)); assert(std::move(m).extract().get_allocator() == A1(5)); } @@ -142,7 +146,7 @@ void test() { using A1 = test_allocator; using M = std::flat_multiset, std::deque>; M m = {std::sorted_equivalent, il2, {}, A1(5)}; // implicit ctor - assert((m == M{1, 2, 4, 5})); + assert((m == M{1, 2, 4, 4, 5})); assert(std::move(m).extract().get_allocator() == A1(5)); } } diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_iter_iter.pass.cpp index a73080d5a7869..9ebe45d71d667 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_iter_iter.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/sorted_iter_iter.pass.cpp @@ -56,13 +56,13 @@ void test() { // flat_multiset(sorted_equivalent_t, InputIterator, InputIterator); // cpp17_input_iterator using M = std::flat_multiset; - int ar[] = {1, 2, 4, 5}; - auto m = M(std::sorted_equivalent, cpp17_input_iterator(ar), cpp17_input_iterator(ar + 4)); - auto expected = M{1, 2, 4, 5}; + int ar[] = {1, 2, 2, 4, 5}; + auto m = M(std::sorted_equivalent, cpp17_input_iterator(ar), cpp17_input_iterator(ar + 5)); + auto expected = M{1, 2, 2, 4, 5}; assert(m == expected); // explicit(false) - M m2 = {std::sorted_equivalent, cpp17_input_iterator(ar), cpp17_input_iterator(ar + 4)}; + M m2 = {std::sorted_equivalent, cpp17_input_iterator(ar), cpp17_input_iterator(ar + 5)}; assert(m2 == m); } { @@ -70,27 +70,27 @@ void test() { // contiguous iterator using C = test_less; using M = std::flat_multiset>>; - int ar[] = {1, 2, 4, 5}; - auto m = M(std::sorted_equivalent, ar, ar + 4); - auto expected = M{1, 2, 4, 5}; + int ar[] = {1, 2, 4, 4, 5}; + auto m = M(std::sorted_equivalent, ar, ar + 5); + auto expected = M{1, 2, 4, 4, 5}; assert(m == expected); } { // flat_multiset(sorted_equivalent_t, InputIterator, InputIterator, const key_compare&); // cpp_17_input_iterator using M = std::flat_multiset>; - int ar[] = {1, 2, 4, 5}; + int ar[] = {1, 2, 4, 4, 5}; auto m = M(std::sorted_equivalent, cpp17_input_iterator(ar), - cpp17_input_iterator(ar + 4), + cpp17_input_iterator(ar + 5), std::less()); - assert(m == M({1, 2, 4, 5}, std::less<>())); + assert(m == M({1, 2, 4, 4, 5}, std::less<>())); assert(m.key_comp()(1, 2) == true); // explicit(false) M m2 = {std::sorted_equivalent, cpp17_input_iterator(ar), - cpp17_input_iterator(ar + 4), + cpp17_input_iterator(ar + 5), std::less()}; assert(m2 == m); } @@ -98,12 +98,12 @@ void test() { // flat_multiset(sorted_equivalent_t, InputIterator, InputIterator, const key_compare&); // greater using M = std::flat_multiset, std::deque>>; - int ar[] = {5, 4, 2, 1}; + int ar[] = {5, 4, 4, 2, 1}; auto m = M(std::sorted_equivalent, cpp17_input_iterator(ar), - cpp17_input_iterator(ar + 4), + cpp17_input_iterator(ar + 5), std::greater()); - assert((m == M{5, 4, 2, 1})); + assert((m == M{5, 4, 4, 2, 1})); } { // flat_multiset(sorted_equivalent_t, InputIterator, InputIterator, const key_compare&); @@ -119,14 +119,14 @@ void test() { // flat_multiset(sorted_equivalent_t, InputIterator , InputIterator, const Allocator&) using A1 = test_allocator; using M = std::flat_multiset, std::vector>; - int ar[] = {1, 2, 4, 5}; - auto m = M(std::sorted_equivalent, ar, ar + 4, A1(5)); - auto expected = M{1, 2, 4, 5}; + int ar[] = {1, 2, 4, 4, 5}; + auto m = M(std::sorted_equivalent, ar, ar + 5, A1(5)); + auto expected = M{1, 2, 4, 4, 5}; assert(m == expected); assert(M(m).extract().get_allocator() == A1(5)); // explicit(false) - M m2 = {std::sorted_equivalent, ar, ar + 4, A1(5)}; + M m2 = {std::sorted_equivalent, ar, ar + 5, A1(5)}; assert(m2 == m); assert(std::move(m2).extract().get_allocator() == A1(5)); } @@ -135,9 +135,9 @@ void test() { using C = test_less; using A1 = test_allocator; using M = std::flat_multiset>; - int ar[] = {1, 2, 4, 5}; - auto m = M(std::sorted_equivalent, ar, ar + 4, C(3), A1(5)); - assert((m == M{1, 2, 4, 5})); + int ar[] = {1, 2, 4, 4, 5}; + auto m = M(std::sorted_equivalent, ar, ar + 5, C(3), A1(5)); + assert((m == M{1, 2, 4, 4, 5})); assert(m.key_comp() == C(3)); assert(std::move(m).extract().get_allocator() == A1(5)); } @@ -146,9 +146,9 @@ void test() { // explicit(false) using A1 = test_allocator; using M = std::flat_multiset, std::deque>; - int ar[] = {1, 2, 4, 5}; - M m = {std::sorted_equivalent, ar, ar + 4, {}, A1(5)}; // implicit ctor - assert((m == M{1, 2, 4, 5})); + int ar[] = {1, 2, 4, 4, 5}; + M m = {std::sorted_equivalent, ar, ar + 5, {}, A1(5)}; // implicit ctor + assert((m == M{1, 2, 4, 4, 5})); assert(std::move(m).extract().get_allocator() == A1(5)); } } diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/helpers.h b/libcxx/test/std/containers/container.adaptors/flat.multiset/helpers.h index 2ee8b021337a0..77ce602454131 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/helpers.h +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/helpers.h @@ -6,8 +6,8 @@ // //===----------------------------------------------------------------------===// -#ifndef SUPPORT_FLAT_SET_HELPERS_H -#define SUPPORT_FLAT_SET_HELPERS_H +#ifndef SUPPORT_flat_multiset_HELPERS_H +#define SUPPORT_flat_multiset_HELPERS_H #include #include @@ -19,15 +19,9 @@ #include "test_macros.h" template -void check_invariant(const std::flat_set& m) { +void check_invariant(const std::flat_multiset& 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; @@ -185,6 +179,7 @@ struct ThrowOnMoveContainer : std::vector { #endif +#if 0 template void test_emplace_exception_guarantee([[maybe_unused]] F&& emplace_function) { #ifndef TEST_HAS_NO_EXCEPTIONS @@ -192,7 +187,7 @@ void test_emplace_exception_guarantee([[maybe_unused]] F&& emplace_function) { { // Throw on emplace the key, and underlying has strong exception guarantee using KeyContainer = std::vector>; - using M = std::flat_set; + using M = std::flat_multiset; LIBCPP_STATIC_ASSERT(std::__container_traits::__emplacement_has_strong_exception_safety_guarantee); @@ -200,7 +195,7 @@ void test_emplace_exception_guarantee([[maybe_unused]] F&& emplace_function) { KeyContainer a({1, 2, 3, 4}, test_allocator{&stats}); [[maybe_unused]] auto expected_keys = a; - M m(std::sorted_unique, std::move(a)); + M m(std::sorted_equivalent, std::move(a)); stats.throw_after = 1; try { @@ -208,7 +203,7 @@ void test_emplace_exception_guarantee([[maybe_unused]] F&& emplace_function) { assert(false); } catch (const std::bad_alloc&) { check_invariant(m); - // In libc++, the flat_set is unchanged + // In libc++, the flat_multiset is unchanged LIBCPP_ASSERT(m.size() == 4); LIBCPP_ASSERT(std::ranges::equal(m, expected_keys)); } @@ -216,17 +211,17 @@ void test_emplace_exception_guarantee([[maybe_unused]] F&& emplace_function) { { // Throw on emplace the key, and underlying has no strong exception guarantee using KeyContainer = EmplaceUnsafeContainer; - using M = std::flat_set; + using M = std::flat_multiset; 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)); + M m(std::sorted_equivalent, std::move(a)); try { emplace_function(m, 0); assert(false); } catch (int) { check_invariant(m); - // In libc++, the flat_set is cleared + // In libc++, the flat_multiset is cleared LIBCPP_ASSERT(m.size() == 0); } } @@ -237,10 +232,10 @@ 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; + using M = std::flat_multiset; test_allocator_statistics stats; KeyContainer a{1, 2, 3, 4}; - M m(std::sorted_unique, std::move(a)); + M m(std::sorted_equivalent, std::move(a)); std::vector newValues = {0, 1, 5, 6, 7, 8}; stats.throw_after = 1; @@ -261,10 +256,10 @@ void test_erase_exception_guarantee([[maybe_unused]] F&& erase_function) { { // key erase throws using KeyContainer = ThrowOnEraseContainer; - using M = std::flat_set; + using M = std::flat_multiset; KeyContainer a{1, 2, 3, 4}; - M m(std::sorted_unique, std::move(a)); + M m(std::sorted_equivalent, std::move(a)); try { erase_function(m, 3); assert(false); @@ -304,4 +299,5 @@ class Moveable { bool moved() const { return int_ == -1; } }; -#endif // SUPPORT_FLAT_SET_HELPERS_H +#endif // 0 +#endif // SUPPORT_flat_multiset_HELPERS_H 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 index d75a5c576abb6..d7d7a98f49d77 100644 --- 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 @@ -94,16 +94,6 @@ void test() { test_one>(); } -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(); 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 index 87f9e1a965d29..5ecdc429b3c58 100644 --- 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 @@ -67,15 +67,6 @@ void test() { test_one>>(); } -void test() { - test_one>(); - test_one>(); - test_one>(); - test_one>(); - test_one>>(); - test_one>>(); -} - int main(int, char**) { test(); 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 index 5d731cef4f002..e0416fc261ffc 100644 --- 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 @@ -73,13 +73,6 @@ void test() { test_one>>(); } -void test() { - test_one>(); - test_one>(); - test_one>(); - test_one>>(); -} - int main(int, char**) { test(); 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 index 0b02f7bacae7d..51aec21ca212b 100644 --- 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 @@ -73,13 +73,6 @@ void test() { test_one>>(); } -void test() { - test_one>(); - test_one>(); - test_one>(); - test_one>>(); -} - int main(int, char**) { test(); 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 index ca5231f441901..7a8b19273289d 100644 --- 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 @@ -81,13 +81,6 @@ void test() { test_one>>(); } -void test() { - test_one>(); - test_one>(); - test_one>(); - test_one>>(); -} - int main(int, char**) { test(); 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 index 4391c2c0ff8a1..953b8fe638547 100644 --- 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 @@ -57,13 +57,6 @@ void test() { test_one>>(); } -void test() { - test_one>(); - test_one>(); - test_one>(); - test_one>>(); -} - int main(int, char**) { test(); 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 index eaaa206cf0ada..32796b7a164f7 100644 --- 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 @@ -73,13 +73,6 @@ void test() { test_one>>(); } -void test() { - test_one>(); - test_one>(); - test_one>(); - test_one>>(); -} - int main(int, char**) { test(); 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 index 9574a66dc7400..6a967cb2371ba 100644 --- 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 @@ -74,13 +74,6 @@ void test() { test_one>>(); } -void test() { - test_one>(); - test_one>(); - test_one>(); - test_one>>(); -} - int main(int, char**) { test(); From b5ab4830c8270d7675d1701963c62937a091f5f3 Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Sun, 23 Mar 2025 18:46:15 +0000 Subject: [PATCH 12/23] rebase --- .../flat.set.capacity/empty.verify.cpp | 20 ------------------- 1 file changed, 20 deletions(-) delete mode 100644 libcxx/test/std/containers/container.adaptors/flat.set/flat.set.capacity/empty.verify.cpp diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.capacity/empty.verify.cpp b/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.capacity/empty.verify.cpp deleted file mode 100644 index 161fe533eabac..0000000000000 --- a/libcxx/test/std/containers/container.adaptors/flat.set/flat.set.capacity/empty.verify.cpp +++ /dev/null @@ -1,20 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// 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}} -} From 6f321013c75b3ea50a9df191382ca964cdab6a0f Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Sun, 23 Mar 2025 19:12:22 +0000 Subject: [PATCH 13/23] iterator test --- .../flat.multiset.iterators/iterator.pass.cpp | 98 +++++++++++ .../iterator_comparison.pass.cpp | 158 ++++++++++++++++++ ...rator_concept_conformance.compile.pass.cpp | 77 +++++++++ ...range_concept_conformance.compile.pass.cpp | 52 ++++++ .../reverse_iterator.pass.cpp | 92 ++++++++++ 5 files changed, 477 insertions(+) create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/iterator.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/iterator_comparison.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/iterator_concept_conformance.compile.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/range_concept_conformance.compile.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/reverse_iterator.pass.cpp diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/iterator.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/iterator.pass.cpp new file mode 100644 index 0000000000000..809f03df47977 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/iterator.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 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_multiset, KeyContainer>; + + M m = {1, 2, 3, 4, 1, 4, 2, 3, 1}; + int expected[] = {1, 1, 1, 2, 2, 3, 3, 4, 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() == 9); + assert(std::distance(m.begin(), m.end()) == 9); + assert(std::distance(cm.begin(), cm.end()) == 9); + assert(std::distance(m.cbegin(), m.cend()) == 9); + 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 = 0; j < 9; ++j, ++i) { // pre-increment + assert(*i == expected[j]); // operator* + } + assert(i == m.end()); + for (int j = 8; j >= 0; --j) { + --i; // pre-decrement + assert((*i) == expected[j]); + } + assert(i == m.begin()); +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); + + { + // N3644 testing + using C = std::flat_multiset; + 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.multiset/flat.multiset.iterators/iterator_comparison.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/iterator_comparison.pass.cpp new file mode 100644 index 0000000000000..d26e3446072ef --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset 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_multiset, 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, 1, 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.multiset/flat.multiset.iterators/iterator_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/iterator_concept_conformance.compile.pass.cpp new file mode 100644 index 0000000000000..0745b8f2433bc --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset, 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.multiset/flat.multiset.iterators/range_concept_conformance.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/range_concept_conformance.compile.pass.cpp new file mode 100644 index 0000000000000..ccb7b94e0b3f5 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset, 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.multiset/flat.multiset.iterators/reverse_iterator.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/reverse_iterator.pass.cpp new file mode 100644 index 0000000000000..9d443ef8784e2 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.iterators/reverse_iterator.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 + +// + +// 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_multiset, std::deque>; + M m = {1, 1, 2, 2, 3, 4}; + int expected[] = {1, 1, 2, 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() == 6); + assert(std::distance(m.rbegin(), m.rend()) == 6); + assert(std::distance(cm.rbegin(), cm.rend()) == 6); + assert(std::distance(m.crbegin(), m.crend()) == 6); + assert(std::distance(cm.crbegin(), cm.crend()) == 6); + 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 = 5; j >= 0; --j, ++i) { // pre-increment + assert(*i == expected[j]); + } + assert(i == m.rend()); + for (int j = 0; j <= 5; ++j) { + --i; // pre-decrement + assert(*i == expected[j]); + } + assert(i == m.rbegin()); + } + { + // N3644 testing + using C = std::flat_multiset; + 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; +} From b625d5a7a9929e98eebedec4c13658eb36f06303 Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Sun, 23 Mar 2025 19:18:04 +0000 Subject: [PATCH 14/23] capacity test --- .../flat.multiset.capacity/empty.pass.cpp | 52 ++++++++++++++ .../flat.multiset.capacity/max_size.pass.cpp | 68 ++++++++++++++++++ .../flat.multiset.capacity/size.pass.cpp | 71 +++++++++++++++++++ 3 files changed, 191 insertions(+) create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/empty.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/max_size.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/size.pass.cpp diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/empty.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/empty.pass.cpp new file mode 100644 index 0000000000000..52f77438df2ce --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset, 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.multiset/flat.multiset.capacity/max_size.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/max_size.pass.cpp new file mode 100644 index 0000000000000..4e3d1414b28af --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset, 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_multiset, 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_multiset 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.multiset/flat.multiset.capacity/size.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/size.pass.cpp new file mode 100644 index 0000000000000..69f9e52c927e9 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/size.pass.cpp @@ -0,0 +1,71 @@ +//===----------------------------------------------------------------------===// +// +// 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_multiset, 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() == 5); + } + { + 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); + m.emplace(i); + } + ASSERT_SAME_TYPE(decltype(m.size()), S); + ASSERT_NOEXCEPT(m.size()); + assert(m.size() == 2 * s); + } +} + +void test() { + test_one>(); + test_one>(); + test_one>(); + test_one>>(); +} + +int main(int, char**) { + test(); + + return 0; +} From f97693d9cc29c5e81f3df4e2f0f2ac0857b35cf4 Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Tue, 25 Mar 2025 18:27:57 +0000 Subject: [PATCH 15/23] complete tests --- libcxx/include/__flat_set/flat_multiset.h | 75 +++--- .../assert.sorted_unique.pass.cpp | 131 ++++++++++ .../flat.multiset/iterator.compile.pass.cpp | 42 +++ .../flat_multiset.nodiscard.verify.cpp | 20 ++ .../flat.multiset.cons/pmr.pass.cpp | 3 +- .../flat.multiset.erasure/erase_if.pass.cpp | 113 ++++++++ .../erase_if_exceptions.pass.cpp | 132 ++++++++++ .../flat.multiset.modifiers/clear.pass.cpp | 74 ++++++ .../flat.multiset.modifiers/emplace.pass.cpp | 136 ++++++++++ .../emplace_hint.pass.cpp | 241 ++++++++++++++++++ .../erase_iter.pass.cpp | 114 +++++++++ .../erase_iter_iter.pass.cpp | 98 +++++++ .../erase_key.pass.cpp | 100 ++++++++ .../erase_key_transparent.pass.cpp | 157 ++++++++++++ .../flat.multiset.modifiers/extract.pass.cpp | 102 ++++++++ .../insert_cv.pass.cpp | 85 ++++++ .../insert_initializer_list.pass.cpp | 91 +++++++ .../insert_iter_cv.pass.cpp | 86 +++++++ .../insert_iter_iter.pass.cpp | 94 +++++++ .../insert_iter_rv.pass.cpp | 88 +++++++ .../insert_range.pass.cpp | 100 ++++++++ .../insert_rv.pass.cpp | 92 +++++++ .../insert_sorted_initializer_list.pass.cpp | 68 +++++ .../insert_sorted_iter_iter.pass.cpp | 82 ++++++ .../flat.multiset.modifiers/replace.pass.cpp | 88 +++++++ .../swap_exception.pass.cpp | 61 +++++ .../swap_free.pass.cpp | 98 +++++++ .../swap_member.pass.cpp | 96 +++++++ .../flat.multiset.observers/comp.pass.cpp | 76 ++++++ .../contains.pass.cpp | 80 ++++++ .../contains_transparent.pass.cpp | 83 ++++++ .../flat.multiset.operations/count.pass.cpp | 80 ++++++ .../count_transparent.pass.cpp | 82 ++++++ .../equal_range.pass.cpp | 88 +++++++ .../equal_range_transparent.pass.cpp | 113 ++++++++ .../flat.multiset.operations/find.pass.cpp | 64 +++++ .../find_transparent.pass.cpp | 100 ++++++++ .../lower_bound.pass.cpp | 80 ++++++ .../lower_bound_transparent.pass.cpp | 106 ++++++++ .../upper_bound.pass.cpp | 81 ++++++ .../upper_bound_transparent.pass.cpp | 106 ++++++++ .../flat.multiset/helpers.h | 8 +- .../flat.multiset/incomplete_type.pass.cpp | 36 +++ .../flat.multiset/op_compare.pass.cpp | 105 ++++++++ .../flat.multiset/types.compile.pass.cpp | 94 +++++++ 45 files changed, 4001 insertions(+), 48 deletions(-) create mode 100644 libcxx/test/libcxx/containers/container.adaptors/flat.multiset/assert.sorted_unique.pass.cpp create mode 100644 libcxx/test/libcxx/containers/container.adaptors/flat.multiset/iterator.compile.pass.cpp create mode 100644 libcxx/test/libcxx/diagnostics/flat_multiset.nodiscard.verify.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.erasure/erase_if.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.erasure/erase_if_exceptions.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/clear.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/emplace.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/emplace_hint.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/erase_iter.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/erase_iter_iter.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/erase_key.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/erase_key_transparent.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/extract.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_cv.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_initializer_list.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_cv.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_iter.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_rv.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_range.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_rv.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_sorted_initializer_list.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_sorted_iter_iter.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/replace.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/swap_exception.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/swap_free.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/swap_member.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.observers/comp.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/contains.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/contains_transparent.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/count.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/count_transparent.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/equal_range.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/equal_range_transparent.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/find.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/find_transparent.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/lower_bound.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/lower_bound_transparent.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/upper_bound.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/upper_bound_transparent.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/incomplete_type.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/op_compare.pass.cpp create mode 100644 libcxx/test/std/containers/container.adaptors/flat.multiset/types.compile.pass.cpp diff --git a/libcxx/include/__flat_set/flat_multiset.h b/libcxx/include/__flat_set/flat_multiset.h index d84a06e664ed3..f1314ffd75109 100644 --- a/libcxx/include/__flat_set/flat_multiset.h +++ b/libcxx/include/__flat_set/flat_multiset.h @@ -375,45 +375,6 @@ class flat_multiset { } else { return __emplace_hint(std::move(__hint), _Key(std::forward<_Args>(__args)...)); } - /* - std::pair __pair(std::forward<_Args>(__args)...); - - auto __prev_larger = __hint != cbegin() && __compare_(__pair.first, (__hint - 1)->first); - auto __next_smaller = __hint != cend() && __compare_(__hint->first, __pair.first); - - auto __hint_distance = __hint.__key_iter_ - __containers_.keys.cbegin(); - auto __key_iter = __containers_.keys.begin() + __hint_distance; - auto __mapped_iter = __containers_.values.begin() + __hint_distance; - - if (!__prev_larger && !__next_smaller) [[likely]] { - // hint correct, just use exact hint iterators - } else if (__prev_larger && !__next_smaller) { - // the hint position is more to the right than the key should have been. - // we want to emplace the element to a position as right as possible - // e.g. Insert new element "2" in the following range - // 1, 1, 2, 2, 2, 3, 4, 6 - // ^ - // | - // hint - // We want to insert "2" after the last existing "2" - __key_iter = ranges::upper_bound(__containers_.keys.begin(), __key_iter, __pair.first, __compare_); - __mapped_iter = __corresponding_mapped_it(*this, __key_iter); - } else { - _LIBCPP_ASSERT_INTERNAL(!__prev_larger && __next_smaller, "this means that the multiset is not sorted"); - - // the hint position is more to the left than the key should have been. - // we want to emplace the element to a position as left as possible - // 1, 1, 2, 2, 2, 3, 4, 6 - // ^ - // | - // hint - // We want to insert "2" before the first existing "2" - __key_iter = ranges::lower_bound(__key_iter, __containers_.keys.end(), __pair.first, __compare_); - __mapped_iter = __corresponding_mapped_it(*this, __key_iter); - } - return __flat_map_utils::__emplace_exact_pos( - *this, __key_iter, __mapped_iter, std::move(__pair.first), std::move(__pair.second)); - */ } _LIBCPP_HIDE_FROM_ABI iterator insert(const value_type& __x) { return emplace(__x); } @@ -641,8 +602,8 @@ class flat_multiset { 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"); + _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT( + ranges::is_sorted(__keys_ | ranges::views::drop(__old_size)), "Key container is not sorted"); } ranges::inplace_merge(__keys_.begin(), __keys_.begin() + __old_size, __keys_.end(), __compare_); } @@ -655,6 +616,38 @@ class flat_multiset { return __flat_set_utils::__emplace_exact_pos(*this, __it, std::forward<_Kp>(__key)); } + template + _LIBCPP_HIDE_FROM_ABI iterator __emplace_hint(const_iterator __hint, _Kp&& __key) { + auto __prev_larger = __hint != cbegin() && __compare_(__key, *std::prev(__hint)); + auto __next_smaller = __hint != cend() && __compare_(*__hint, __key); + + if (!__prev_larger && !__next_smaller) [[likely]] { + // hint correct, just use exact hint iterators + } else if (__prev_larger && !__next_smaller) { + // the hint position is more to the right than the key should have been. + // we want to emplace the element to a position as right as possible + // e.g. Insert new element "2" in the following range + // 1, 1, 2, 2, 2, 3, 4, 6 + // ^ + // | + // hint + // We want to insert "2" after the last existing "2" + __hint = ranges::upper_bound(begin(), __hint, __key, __compare_); + } else { + _LIBCPP_ASSERT_INTERNAL(!__prev_larger && __next_smaller, "this means that the multiset is not sorted"); + + // the hint position is more to the left than the key should have been. + // we want to emplace the element to a position as left as possible + // 1, 1, 2, 2, 2, 3, 4, 6 + // ^ + // | + // hint + // We want to insert "2" before the first existing "2" + __hint = ranges::lower_bound(__hint, end(), __key, __compare_); + } + return __flat_set_utils::__emplace_exact_pos(*this, __hint, std::forward<_Kp>(__key)); + } + template _LIBCPP_HIDE_FROM_ABI static auto __find_impl(_Self&& __self, const _Kp& __key) { auto __it = __self.lower_bound(__key); diff --git a/libcxx/test/libcxx/containers/container.adaptors/flat.multiset/assert.sorted_unique.pass.cpp b/libcxx/test/libcxx/containers/container.adaptors/flat.multiset/assert.sorted_unique.pass.cpp new file mode 100644 index 0000000000000..54b07baaff27a --- /dev/null +++ b/libcxx/test/libcxx/containers/container.adaptors/flat.multiset/assert.sorted_unique.pass.cpp @@ -0,0 +1,131 @@ +// +// 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_multiset(container_type , const key_compare& __comp = key_compare()) +// flat_multiset(const container_type& , const _Allocator& ) +// flat_multiset(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_multiset; + + TEST_LIBCPP_ASSERT_FAILURE(([] { M m(std::sorted_equivalent, {4, 2, 3}); }()), "Key container is not sorted"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { M m(std::sorted_equivalent, {4, 2, 3}, std::less{}); }()), "Key container is not sorted"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + const std::vector keys{4, 2, 3}; + const std::allocator alloc{}; + M m(std::sorted_equivalent, keys, alloc); + }()), + "Key container is not sorted"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + const std::vector keys{4, 2, 3}; + const std::allocator alloc{}; + const std::less comp{}; + M m(std::sorted_equivalent, keys, comp, alloc); + }()), + "Key container is not sorted"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + const std::vector v{4, 2, 3}; + const std::less comp{}; + M m(std::sorted_equivalent, v.begin(), v.end(), comp); + }()), + "Key container is not sorted"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + const std::vector v{4, 2, 3}; + const std::less comp{}; + const std::allocator alloc{}; + M m(std::sorted_equivalent, v.begin(), v.end(), comp, alloc); + }()), + "Key container is not sorted"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + const std::vector v{4, 2, 3}; + const std::allocator alloc{}; + M m(std::sorted_equivalent, v.begin(), v.end(), alloc); + }()), + "Key container is not sorted"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + std::initializer_list v{4, 2, 3}; + const std::less comp{}; + M m(std::sorted_equivalent, v, comp); + }()), + "Key container is not sorted"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + std::initializer_list v{4, 2, 3}; + const std::less comp{}; + const std::allocator alloc{}; + M m(std::sorted_equivalent, v, comp, alloc); + }()), + "Key container is not sorted"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + std::initializer_list v{4, 2, 3}; + const std::allocator alloc{}; + M m(std::sorted_equivalent, v, alloc); + }()), + "Key container is not sorted"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + const std::vector v{4, 2, 3}; + M m; + m.insert(std::sorted_equivalent, v.begin(), v.end()); + }()), + "Key container is not sorted"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + std::initializer_list v{4, 2, 3}; + M m; + m.insert(std::sorted_equivalent, v); + }()), + "Key container is not sorted"); + + TEST_LIBCPP_ASSERT_FAILURE( + ([] { + std::vector keys{2, 1, 3}; + M m; + m.replace(std::move(keys)); + }()), + "Key container is not sorted"); + + return 0; +} diff --git a/libcxx/test/libcxx/containers/container.adaptors/flat.multiset/iterator.compile.pass.cpp b/libcxx/test/libcxx/containers/container.adaptors/flat.multiset/iterator.compile.pass.cpp new file mode 100644 index 0000000000000..0954e42e52001 --- /dev/null +++ b/libcxx/test/libcxx/containers/container.adaptors/flat.multiset/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_multiset are not compatible + +#include +#include +#include +#include + +using Iter1 = std::flat_multiset::iterator; +using Iter2 = std::flat_multiset::iterator; +using Iter3 = std::flat_multiset>::iterator; +using Iter4 = std::flat_multiset, 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/libcxx/diagnostics/flat_multiset.nodiscard.verify.cpp b/libcxx/test/libcxx/diagnostics/flat_multiset.nodiscard.verify.cpp new file mode 100644 index 0000000000000..a271a293e94e7 --- /dev/null +++ b/libcxx/test/libcxx/diagnostics/flat_multiset.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_multiset c; + c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}} +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/pmr.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/pmr.pass.cpp index 9f356cae961db..381aafb00d4fa 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/pmr.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/pmr.pass.cpp @@ -54,8 +54,7 @@ void test() { assert(std::move(vm[0]).extract().get_allocator().resource() == &mr); } { - // flat_multiset(const key_container_type& key_cont, const mapped_container_type& mapped_cont, - // const Allocator& a); + // flat_multiset(const container_type& key_cont, const Allocator& a); using M = std::flat_multiset, std::pmr::vector>; std::pmr::monotonic_buffer_resource mr; std::pmr::vector vm(&mr); diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.erasure/erase_if.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.erasure/erase_if.pass.cpp new file mode 100644 index 0000000000000..21f3c918dec0d --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.erasure/erase_if.pass.cpp @@ -0,0 +1,113 @@ +//===----------------------------------------------------------------------===// +// +// 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_multiset::size_type +// erase_if(flat_multiset& c, Predicate pred); + +#include +#include +#include +#include +#include + +#include "test_macros.h" +#include "test_allocator.h" +#include "min_allocator.h" + +// Verify that `flat_multiset` (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, 1, 1}, is1, {}, 3); + test0({1}, is2, {1}, 0); + test0({1, 1, 1}, is2, {1, 1, 1}, 0); + + test0({1, 2}, is1, {2}, 1); + test0({1, 1, 1, 2, 2}, is1, {2, 2}, 3); + test0({1, 2}, is2, {1}, 1); + test0({1, 1, 1, 2, 2}, is2, {1, 1, 1}, 2); + test0({1, 2}, is3, {1, 2}, 0); + test0({1, 1, 1, 2, 2}, is3, {1, 1, 1, 2, 2}, 0); + + test0({1, 2, 3}, is1, {2, 3}, 1); + test0({1, 1, 2, 2, 3, 3}, is1, {2, 2, 3, 3}, 2); + test0({1, 2, 3}, is2, {1, 3}, 1); + test0({1, 1, 2, 2, 3, 3}, is2, {1, 1, 3, 3}, 2); + test0({1, 2, 3}, is3, {1, 2}, 1); + test0({1, 1, 2, 2, 3, 3}, is3, {1, 1, 2, 2}, 2); + test0({1, 2, 3}, is4, {1, 2, 3}, 0); + test0({1, 1, 2, 2, 3, 3}, is4, {1, 1, 2, 2, 3, 3}, 0); + + test0({1, 2, 3}, True, {}, 3); + test0({1, 2, 2, 3, 3, 3}, True, {}, 6); + test0({1, 2, 3}, False, {1, 2, 3}, 0); + test0({1, 2, 2, 3, 3, 3}, False, {1, 2, 2, 3, 3, 3}, 0); + + test0({1, 2, 3}, nonBoolIs1, {2, 3}, 1); + test0({1, 1, 2, 2, 3}, nonBoolIs1, {2, 2, 3}, 2); +} + +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.multiset/flat.multiset.erasure/erase_if_exceptions.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.erasure/erase_if_exceptions.pass.cpp new file mode 100644 index 0000000000000..64dc110006a5a --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.erasure/erase_if_exceptions.pass.cpp @@ -0,0 +1,132 @@ +//===----------------------------------------------------------------------===// +// +// 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_multiset::size_type +// erase_if(flat_multiset& 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() { + { + using M = std::flat_multiset; + 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, 1, 2, 3, 3, 3, 4, 5, 6, 7, 8}); + try { + g_counter = {first_throw, second_throw, 0}; + auto n = std::erase_if(m, ErasurePredicate()); + assert(n == 5); + // If it didn't throw at all, we're done. + g_counter = {0, 0, 0}; + assert((m == M{1, 1, 2, 6, 7, 8})); + first_throw = 99; // "done" + break; + } catch (int ex) { + assert(ex == 42); + check_invariant(m); + LIBCPP_ASSERT(m.empty()); + if (g_counter.throws == 1) { + // We reached the first throw but not the second throw. + break; + } + } + } + } + } + + { + using M = std::flat_multiset>; + 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()); + 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.multiset/flat.multiset.modifiers/clear.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/clear.pass.cpp new file mode 100644 index 0000000000000..4d01ece7ed6a6 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset + +// 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_multiset, KeyContainer>; + { + M m = {1, 1, 3, 5, 2, 3, 4, 5}; + assert(m.size() == 8); + 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.multiset/flat.multiset.modifiers/emplace.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/emplace.pass.cpp new file mode 100644 index 0000000000000..3ef13964c905e --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/emplace.pass.cpp @@ -0,0 +1,136 @@ +//===----------------------------------------------------------------------===// +// +// 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(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_multiset, KeyContainer>; + using R = typename M::iterator; + { + // was empty + M m; + std::same_as decltype(auto) r = m.emplace(typename M::value_type(2)); + assert(r == m.begin()); + assert(m.size() == 1); + assert(*r == 2); + } + { + // key does not exist and inserted at the begin + M m = {3, 3, 3, 7}; + std::same_as decltype(auto) r = m.emplace(typename M::value_type(2)); + assert(r == m.begin()); + assert(m.size() == 5); + assert(*r == 2); + } + { + // key does not exist and inserted in the middle + M m = {1, 1, 3, 4}; + std::same_as decltype(auto) r = m.emplace(typename M::value_type(2)); + assert(r == m.begin() + 2); + assert(m.size() == 5); + assert(*r == 2); + } + { + // key does not exist and inserted at the end + M m = {1, 1}; + std::same_as decltype(auto) r = m.emplace(typename M::value_type(2)); + assert(r == m.begin() + 2); + assert(m.size() == 3); + assert(*r == 2); + } + { + // key already exists and original at the begin + M m = {2, 2, 5, 6}; + std::same_as decltype(auto) r = m.emplace(typename M::value_type(2)); + assert(r == m.begin() + 2); + assert(m.size() == 5); + assert(*r == 2); + } + { + // key already exists and original in the middle + M m = {0, 2, 2, 4}; + std::same_as decltype(auto) r = m.emplace(typename M::value_type(2)); + assert(r == m.begin() + 3); + assert(m.size() == 5); + assert(*r == 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 == m.begin() + 3); + assert(m.size() == 4); + assert(*r == 2); + } +} + +template +void test_emplaceable() { + using M = std::flat_multiset, KeyContainer>; + using R = typename M::iterator; + + M m; + ASSERT_SAME_TYPE(decltype(m.emplace()), R); + R r = m.emplace(2, 0.0); + assert(r == m.begin()); + assert(m.size() == 1); + assert(*r == Emplaceable(2, 0.0)); + r = m.emplace(1, 3.5); + assert(r == m.begin()); + assert(m.size() == 2); + assert(*r == Emplaceable(1, 3.5)); + r = m.emplace(1, 3.5); + assert(r == m.begin() + 1); + assert(m.size() == 3); + assert(*r == 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.multiset/flat.multiset.modifiers/emplace_hint.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/emplace_hint.pass.cpp new file mode 100644 index 0000000000000..41a2e9c4ce115 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/emplace_hint.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 + +// + +// 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" + +struct CompareTensDigit { + bool operator()(auto lhs, auto rhs) const { return (lhs / 10) < (rhs / 10); } +}; + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_multiset, 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 and no duplicates + M m = {0, 1, 3}; + 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() == 4); + 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() == 6); + assert(*r == 2); + } + { + // hint correct and at the first duplicate + using M2 = std::flat_multiset; + using R2 = M2::iterator; + M2 m{0, 10, 20, 25, 30}; + auto hint = m.begin() + 2; + std::same_as decltype(auto) r = m.emplace_hint(hint, typename M::value_type(21)); + assert(r == m.begin() + 2); + assert(m.size() == 6); + assert(*r == 21); + } + { + // hint correct and in-between duplicates + using M2 = std::flat_multiset; + using R2 = M2::iterator; + M2 m{0, 10, 20, 21, 22, 30}; + auto hint = m.begin() + 4; + std::same_as decltype(auto) r = m.emplace_hint(hint, typename M::value_type(23)); + assert(r == m.begin() + 4); + assert(m.size() == 7); + assert(*r == 23); + assert(*std::next(r) == 22); + } + { + // hint correct and after duplicates + using M2 = std::flat_multiset; + using R2 = M2::iterator; + M2 m{0, 10, 20, 21, 22, 30}; + auto hint = m.begin() + 5; + std::same_as decltype(auto) r = m.emplace_hint(hint, typename M::value_type(23)); + assert(r == m.begin() + 5); + assert(m.size() == 7); + assert(*r == 23); + assert(*std::next(r) == 30); + } + { + // hints incorrect and no duplicates + M m = {0, 1, 3}; + 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() == 4); + 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() == 6); + assert(*r == 2); + } + { + // hint incorrect and before the first duplicate + using M2 = std::flat_multiset; + using R2 = M2::iterator; + M2 m{0, 10, 20, 21, 22, 30}; + auto hint = m.begin(); + std::same_as decltype(auto) r = m.emplace_hint(hint, typename M::value_type(23)); + assert(r == m.begin() + 2); + assert(m.size() == 7); + assert(*r == 23); + assert(*std::next(r) == 20); + } + { + // hint incorrect and after the last duplicate + using M2 = std::flat_multiset; + using R2 = M2::iterator; + M2 m{0, 10, 20, 21, 22, 30, 40}; + auto hint = m.begin() + 6; + std::same_as decltype(auto) r = m.emplace_hint(hint, typename M::value_type(23)); + assert(r == m.begin() + 5); + assert(m.size() == 8); + assert(*r == 23); + assert(*std::next(r) == 30); + } +} + +template +void test_emplaceable() { + using M = std::flat_multiset, 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() + 1); + assert(m.size() == 3); + assert(*r == 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.multiset/flat.multiset.modifiers/erase_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/erase_iter.pass.cpp new file mode 100644 index 0000000000000..8418efa67bb23 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset, KeyContainer>; + using I = M::iterator; + + int ar[] = { + 1, + 3, + 3, + 3, + 5, + 5, + 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, 3, 3, 3, 5, 5, 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, 3, 3, 5, 5, 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({3, 3, 5, 5, 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({3, 3, 5, 5, 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({3, 5, 5, 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({3, 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({3, 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.multiset/flat.multiset.modifiers/erase_iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/erase_iter_iter.pass.cpp new file mode 100644 index 0000000000000..2d54fef17b6c0 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset, 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, + 1, + 3, + 3, + 5, + 6, + 6, + 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, 1, 3, 3, 5, 6, 6, 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, 3, 5, 6, 6, 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, 3})); + + 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.multiset/flat.multiset.modifiers/erase_key.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/erase_key.pass.cpp new file mode 100644 index 0000000000000..8175afa5b626e --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset; + + auto make = [](std::initializer_list il) { + M m; + for (int i : il) { + m.emplace(i); + } + return m; + }; + M m = make({1, 1, 3, 5, 5, 5, 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, 1, 3, 5, 5, 5, 7, 8})); + n = m.erase(4); + assert(n == 0); + assert(m == make({1, 1, 3, 5, 5, 5, 7, 8})); + n = m.erase(1); + assert(n == 2); + assert(m == make({3, 5, 5, 5, 7, 8})); + n = m.erase(8); + assert(n == 1); + assert(m == make({3, 5, 5, 5, 7})); + n = m.erase(3); + assert(n == 1); + assert(m == make({5, 5, 5, 7})); + n = m.erase(4); + assert(n == 0); + assert(m == make({5, 5, 5, 7})); + n = m.erase(6); + assert(n == 0); + assert(m == make({5, 5, 5, 7})); + n = m.erase(7); + assert(n == 1); + assert(m == make({5, 5, 5})); + n = m.erase(2); + assert(n == 0); + assert(m == make({5, 5, 5})); + n = m.erase(5); + assert(n == 3); + 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 Set = std::decay_t; + using Key = typename Set::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.multiset/flat.multiset.modifiers/erase_key_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/erase_key_transparent.pass.cpp new file mode 100644 index 0000000000000..de5ef5ffc72a5 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset; +using NonTransparentSet = std::flat_multiset; +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_multiset, KeyContainer>; + + M m = {1, 2, 3, 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 == 2); + 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_multiset; + { + M m = {"alpha", "beta", "beta", "epsilon", "epsilon", "epsilon", "eta", "eta", "gamma"}; + ASSERT_SAME_TYPE(decltype(m.erase(Transparent{"abc"})), typename M::size_type); + + auto n = m.erase(Transparent{"epsilon"}); + assert(n == 3); + + M expected = {"alpha", "beta", "beta", "eta", "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_multiset>; + 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_multiset>; + 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_multiset m(std::sorted_equivalent, {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.multiset/flat.multiset.modifiers/extract.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/extract.pass.cpp new file mode 100644 index 0000000000000..8a66431396916 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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 + +// + +// container_type 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_multiset, KeyContainer>; + { + M m = M({1, 1, 3}); + + std::same_as auto keys = std::move(m).extract(); + + auto expected_keys = {1, 1, 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_multiset, CopyOnlyVector>; + M m = M({1, 1, 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_multiset; + + 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_multiset + 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.multiset/flat.multiset.modifiers/insert_cv.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_cv.pass.cpp new file mode 100644 index 0000000000000..eeb1bdd26ca16 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_cv.pass.cpp @@ -0,0 +1,85 @@ +//===----------------------------------------------------------------------===// +// +// 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 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_multiset, 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(v1); + assert(r == m.begin()); + assert(m.size() == 1); + assert(*r == 2); + + const VT v2(1); + r = m.insert(v2); + assert(r == m.begin()); + assert(m.size() == 2); + assert(*r == 1); + + const VT v3(3); + r = m.insert(v3); + assert(r == std::ranges::prev(m.end())); + assert(m.size() == 3); + assert(*r == 3); + + const VT v4(3); + r = m.insert(v4); + assert(r == std::ranges::prev(m.end())); + assert(m.size() == 4); + assert(*r == 3); + + const VT v5(1); + r = m.insert(v5); + assert(r == m.begin() + 1); + assert(m.size() == 5); + assert(*r == 1); +} + +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.multiset/flat.multiset.modifiers/insert_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_initializer_list.pass.cpp new file mode 100644 index 0000000000000..aedd437c8ac10 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_initializer_list.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 + +// + +// 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_multiset, 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() == 15); + + KeyContainer expected{1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4}; + assert(std::ranges::equal(m, expected)); + } + { + // was empty + M m; + m.insert({ + 4, + 4, + 4, + 1, + 1, + 1, + 2, + 2, + 2, + }); + assert(m.size() == 9); + KeyContainer expected{1, 1, 1, 2, 2, 2, 4, 4, 4}; + assert(std::ranges::equal(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.multiset/flat.multiset.modifiers/insert_iter_cv.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_cv.pass.cpp new file mode 100644 index 0000000000000..61f00f5138118 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_cv.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 + +// + +// 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_multiset, 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() == 4); + assert(*r == 3); + + const VT v5(1); + r = m.insert(m.begin() + 2, v5); + assert(r == m.begin() + 1); + assert(m.size() == 5); + assert(*r == 1); +} + +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.multiset/flat.multiset.modifiers/insert_iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_iter.pass.cpp new file mode 100644 index 0000000000000..3505e097cca69 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset; + +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_multiset, 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() == 9); + M expected{1, 1, 1, 2, 2, 2, 3, 3, 3}; + assert(m == expected); + + m.insert(cpp17_input_iterator(ar2), cpp17_input_iterator(ar2 + sizeof(ar2) / sizeof(ar2[0]))); + assert(m.size() == 18); + M expected2{0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 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.multiset/flat.multiset.modifiers/insert_iter_rv.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_rv.pass.cpp new file mode 100644 index 0000000000000..9976c04c9973a --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_iter_rv.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 + +// +// 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_multiset, 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() == 4); + assert(*r == V(3)); + + r = m.insert(m.begin(), V(2)); + assert(r == m.begin() + 1); + assert(m.size() == 5); + assert(*r == V(2)); + + r = m.insert(m.begin() + 2, V(1)); + assert(r == m.begin() + 1); + assert(m.size() == 6); + assert(*r == V(1)); +} + +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.multiset/flat.multiset.modifiers/insert_range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_range.pass.cpp new file mode 100644 index 0000000000000..566be3921bf77 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_range.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 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_multiset; + +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_multiset, KeyContainer>; + using It = forward_iterator; + M m = {10, 10, 8, 5, 2, 1, 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, 1, 1, 1, 2, 3, 4, 5, 5, 8, 9, 10, 10})); + } + { + using M = std::flat_multiset, KeyContainer>; + using It = cpp20_input_iterator; + M m = {10, 10, 8, 5, 2, 1, 1}; + 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, 1, 1, 1, 2, 3, 4, 5, 5, 8, 9, 10, 10})); + } + { + // was empty + using M = std::flat_multiset, KeyContainer>; + M m; + int ar[] = {3, 1, 4, 1, 5, 9}; + m.insert_range(ar); + assert((m == M{1, 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_multiset m; + m.insert_range(a | std::views::as_rvalue); + MoveOnly expected[] = {1, 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.multiset/flat.multiset.modifiers/insert_rv.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_rv.pass.cpp new file mode 100644 index 0000000000000..9328c42fb0cda --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_rv.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 + +// + +// class flat_multiset + +// iterator 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_multiset; + using R = typename M::iterator; + using V = typename M::value_type; + + M m; + std::same_as decltype(auto) r = m.insert(V(2)); + assert(r == m.begin()); + assert(m.size() == 1); + assert(*r == V(2)); + + r = m.insert(V(1)); + assert(r == m.begin()); + assert(m.size() == 2); + assert(*r == V(1)); + + r = m.insert(V(3)); + assert(r == std::ranges::prev(m.end())); + assert(m.size() == 3); + assert(*r == V(3)); + + r = m.insert(V(3)); + assert(r == std::ranges::prev(m.end())); + assert(m.size() == 4); + assert(*r == V(3)); + + r = m.insert(V(2)); + assert(r == m.begin() + 2); + assert(m.size() == 5); + assert(*r == V(2)); + + r = m.insert(V(1)); + assert(r == m.begin() + 1); + assert(m.size() == 6); + assert(*r == V(1)); +} + +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.multiset/flat.multiset.modifiers/insert_sorted_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_sorted_initializer_list.pass.cpp new file mode 100644 index 0000000000000..38f959890c9b4 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_sorted_initializer_list.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 + +// + +// void insert(sorted_equivalent_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_multiset, KeyContainer>; + using V = Key; + { + M m = {1, 1, 1, 3, 3, 3}; + m.insert(std::sorted_equivalent, {0, 1, 1, 2, 2, 4}); + assert(m.size() == 12); + M expected = {0, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 4}; + assert(m == expected); + } + { + // empty + M m; + m.insert(std::sorted_equivalent, {0, 1, 1, 2, 2, 4}); + M expected = {0, 1, 1, 2, 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_equivalent, 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.multiset/flat.multiset.modifiers/insert_sorted_iter_iter.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_sorted_iter_iter.pass.cpp new file mode 100644 index 0000000000000..07b62d04e0ebc --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_equivalent_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_multiset; + +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_multiset, KeyContainer>; + + int ar1[] = {1, 2, 2, 3}; + + int ar2[] = {0, 2, 4, 4}; + + M m; + m.insert(std::sorted_equivalent, + cpp17_input_iterator(ar1), + cpp17_input_iterator(ar1 + sizeof(ar1) / sizeof(ar1[0]))); + assert(m.size() == 4); + M expected{1, 2, 2, 3}; + assert(m == expected); + + m.insert(std::sorted_equivalent, + cpp17_input_iterator(ar2), + cpp17_input_iterator(ar2 + sizeof(ar2) / sizeof(ar2[0]))); + assert(m.size() == 8); + M expected2{0, 1, 2, 2, 2, 3, 4, 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_equivalent, 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.multiset/flat.multiset.modifiers/replace.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/replace.pass.cpp new file mode 100644 index 0000000000000..5fe61389d72a1 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/replace.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 + +// + +// 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_multiset; +static_assert(CanReplace>); +static_assert(!CanReplace&>); + +template +void test_one() { + using Key = typename KeyContainer::value_type; + using M = std::flat_multiset, KeyContainer>; + { + // was empty + M m; + KeyContainer new_keys = {7, 7, 8}; + auto expected_keys = new_keys; + m.replace(std::move(new_keys)); + assert(m.size() == 3); + assert(std::ranges::equal(m, expected_keys)); + } + { + M m = M({1, 1, 2, 2, 3}); + KeyContainer new_keys = {7, 7, 8, 8}; + auto expected_keys = new_keys; + m.replace(std::move(new_keys)); + assert(m.size() == 4); + 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_multiset; + + 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 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.multiset/flat.multiset.modifiers/swap_exception.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/swap_exception.pass.cpp new file mode 100644 index 0000000000000..705ee88994872 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset& y) noexcept; +// friend void swap(flat_multiset& x, flat_multiset& 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_multiset; + + M m1, m2; + m1.emplace(1); + m1.emplace(1); + m2.emplace(1); + 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.multiset/flat.multiset.modifiers/swap_free.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/swap_free.pass.cpp new file mode 100644 index 0000000000000..2e3ed02c3c00e --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset& x, flat_multiset& 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_multiset, 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, 5, 7, 8, 8, 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, 1, 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, 1, 3, 4}; + int ar2[] = {5, 5, 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.multiset/flat.multiset.modifiers/swap_member.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/swap_member.pass.cpp new file mode 100644 index 0000000000000..1d0d9152d1c1f --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset& 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_multiset, 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, 5, 7, 7, 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, 1, 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, 1, 3, 4}; + int ar2[] = {5, 5, 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.multiset/flat.multiset.observers/comp.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.observers/comp.pass.cpp new file mode 100644 index 0000000000000..4ca64516e242f --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset; + 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_multiset; + 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_multiset; + 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.multiset/flat.multiset.operations/contains.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/contains.pass.cpp new file mode 100644 index 0000000000000..00fda6c2edd88 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset, KeyContainer>; + M m = {1, 2, 2, 2, 4, 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_multiset, KeyContainer>; + M m = {1, 2, 2, 4, 4, 5, 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_multiset, 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.multiset/flat.multiset.operations/contains_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/contains_transparent.pass.cpp new file mode 100644 index 0000000000000..cbb92c9a08a8b --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset; +using NonTransparentSet = std::flat_multiset; +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_multiset; + + { + M m = {"alpha", "beta", "beta", "epsilon", "eta", "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_multiset m(std::sorted_equivalent, {1, 1, 2, 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.multiset/flat.multiset.operations/count.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/count.pass.cpp new file mode 100644 index 0000000000000..1752dab0e0e3a --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset, KeyContainer>; + M m = {1, 2, 2, 2, 2, 4, 4, 5, 8, 8, 8}; + ASSERT_SAME_TYPE(decltype(m.count(0)), S); + assert(m.count(0) == 0); + assert(m.count(1) == 1); + assert(m.count(2) == 4); + assert(m.count(3) == 0); + assert(m.count(4) == 2); + assert(m.count(5) == 1); + assert(m.count(6) == 0); + assert(m.count(7) == 0); + assert(std::as_const(m).count(8) == 3); + assert(std::as_const(m).count(9) == 0); + } + { + using M = std::flat_multiset, KeyContainer>; + M m = {1, 2, 4, 4, 4, 4, 5, 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) == 4); + assert(m.count(5) == 2); + 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_multiset, 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.multiset/flat.multiset.operations/count_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/count_transparent.pass.cpp new file mode 100644 index 0000000000000..08aa1c8fca7d9 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset; +using NonTransparentSet = std::flat_multiset; +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_multiset; + { + M m = {"alpha", "beta", "beta", "beta", "epsilon", "eta", "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"}) == 3); + assert(m.count(Transparent{"epsilon"}) == 1); + assert(m.count(Transparent{"eta"}) == 2); + 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_multiset m(std::sorted_equivalent, {1, 2, 2, 2, 3, 3, 3, 3}, c); + assert(!transparent_used); + auto n = m.count(Transparent{3}); + assert(n == 4); + assert(transparent_used); + } +} + +int main(int, char**) { + test(); + + return 0; +} diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/equal_range.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/equal_range.pass.cpp new file mode 100644 index 0000000000000..54ae27e9ba19c --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset, KeyContainer>; + using R = std::pair; + using CR = std::pair; + M m = {1, 2, 2, 4, 4, 5, 5, 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 + 3)); + assert(m.equal_range(3) == std::pair(begin + 3, begin + 3)); + assert(m.equal_range(4) == std::pair(begin + 3, begin + 5)); + assert(m.equal_range(5) == std::pair(begin + 5, begin + 8)); + assert(m.equal_range(6) == std::pair(begin + 8, begin + 8)); + assert(m.equal_range(7) == std::pair(begin + 8, begin + 8)); + assert(std::as_const(m).equal_range(8) == std::pair(m.cbegin() + 8, m.cbegin() + 9)); + assert(std::as_const(m).equal_range(9) == std::pair(m.cbegin() + 9, m.cbegin() + 9)); + } + + { + using M = std::flat_multiset, KeyContainer>; + using R = std::pair; + using CR = std::pair; + M m = {1, 1, 1, 2, 4, 5, 8, 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 + 8, begin + 8)); + assert(m.equal_range(1) == std::pair(begin + 5, begin + 8)); + assert(m.equal_range(2) == std::pair(begin + 4, begin + 5)); + assert(m.equal_range(3) == std::pair(begin + 4, begin + 4)); + assert(m.equal_range(4) == std::pair(begin + 3, begin + 4)); + assert(m.equal_range(5) == std::pair(begin + 2, begin + 3)); + assert(m.equal_range(6) == std::pair(begin + 2, begin + 2)); + assert(m.equal_range(7) == std::pair(begin + 2, begin + 2)); + assert(std::as_const(m).equal_range(8) == std::pair(m.cbegin(), m.cbegin() + 2)); + assert(std::as_const(m).equal_range(9) == std::pair(m.cbegin(), m.cbegin())); + } + { + // empty + using M = std::flat_multiset, 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.multiset/flat.multiset.operations/equal_range_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/equal_range_transparent.pass.cpp new file mode 100644 index 0000000000000..6ed2585357ac2 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/equal_range_transparent.pass.cpp @@ -0,0 +1,113 @@ +//===----------------------------------------------------------------------===// +// +// 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_multiset; +using NonTransparentSet = std::flat_multiset; +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_multiset; + + using R = std::pair; + using CR = std::pair; + + auto test_found = [](auto&& set, const std::string& expected_key, long expected_offset, long expected_length) { + auto [first, last] = set.equal_range(Transparent{expected_key}); + assert(last - first == expected_length); + assert(first - set.begin() == expected_offset); + for (auto it = first; it != last; ++it) { + assert(*it == expected_key); + } + }; + + auto test_not_found = [](auto&& set, const std::string& expected_key, long expected_offset) { + auto [first, last] = set.equal_range(Transparent{expected_key}); + assert(first == last); + assert(first - set.begin() == expected_offset); + }; + { + M m = {"alpha", "beta", "beta", "beta", "epsilon", "eta", "eta", "eta", "eta", "gamma", "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", 0, 1); + test_found(m, "beta", 1, 3); + test_found(m, "epsilon", 4, 1); + test_found(m, "eta", 5, 4); + test_found(m, "gamma", 9, 2); + test_found(cm, "alpha", 0, 1); + test_found(cm, "beta", 1, 3); + test_found(cm, "epsilon", 4, 1); + test_found(cm, "eta", 5, 4); + test_found(cm, "gamma", 9, 2); + + test_not_found(m, "charlie", 4); + test_not_found(m, "aaa", 0); + test_not_found(m, "zzz", 11); + test_not_found(cm, "charlie", 4); + test_not_found(cm, "aaa", 0); + test_not_found(cm, "zzz", 11); + } + { + // 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_multiset m(std::sorted_equivalent, {1, 2, 3, 3, 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.multiset/flat.multiset.operations/find.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/find.pass.cpp new file mode 100644 index 0000000000000..49386a6f77fae --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset, KeyContainer>; + { + M m = {1, 1, 2, 4, 4, 4, 4, 5, 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() + 2); + assert(m.find(3) == m.end()); + assert(m.find(4) == m.begin() + 3); + assert(m.find(5) == m.begin() + 7); + assert(m.find(6) == m.end()); + assert(m.find(7) == m.end()); + assert(std::as_const(m).find(8) == m.begin() + 9); + 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.multiset/flat.multiset.operations/find_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/find_transparent.pass.cpp new file mode 100644 index 0000000000000..e1f84d68064d7 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset; +using NonTransparentSet = std::flat_multiset; +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_multiset; + + { + M m = {"alpha", "alpha", "alpha", "beta", "epsilon", "epsilon", "eta", "gamma", "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&& set, const std::string& expected_key, long expected_offset) { + auto iter = set.find(Transparent{expected_key}); + assert(iter - set.begin() == expected_offset); + }; + + test_find(m, "alpha", 0); + test_find(m, "beta", 3); + test_find(m, "epsilon", 4); + test_find(m, "eta", 6); + test_find(m, "gamma", 7); + test_find(m, "charlie", 9); + test_find(m, "aaa", 9); + test_find(m, "zzz", 9); + test_find(cm, "alpha", 0); + test_find(cm, "beta", 3); + test_find(cm, "epsilon", 4); + test_find(cm, "eta", 6); + test_find(cm, "gamma", 7); + test_find(cm, "charlie", 9); + test_find(cm, "aaa", 9); + test_find(cm, "zzz", 9); + } + { + // 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_multiset m(std::sorted_equivalent, {1, 2, 2, 2, 3, 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.multiset/flat.multiset.operations/lower_bound.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/lower_bound.pass.cpp new file mode 100644 index 0000000000000..ba41b822fda74 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset, KeyContainer>; + M m = {1, 2, 2, 2, 4, 4, 5, 8, 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() + 4); + assert(m.lower_bound(4) == m.begin() + 4); + assert(m.lower_bound(5) == m.begin() + 6); + assert(m.lower_bound(6) == m.begin() + 7); + assert(m.lower_bound(7) == m.begin() + 7); + assert(std::as_const(m).lower_bound(8) == m.begin() + 7); + assert(std::as_const(m).lower_bound(9) == m.end()); + } + { + using M = std::flat_multiset, KeyContainer>; + M m = {1, 1, 1, 2, 2, 4, 5, 5, 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() + 7); + assert(m.lower_bound(2) == m.begin() + 5); + assert(m.lower_bound(3) == m.begin() + 5); + assert(m.lower_bound(4) == m.begin() + 4); + 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_multiset, 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.multiset/flat.multiset.operations/lower_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/lower_bound_transparent.pass.cpp new file mode 100644 index 0000000000000..2f3d1beffabe9 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset; +using NonTransparentSet = std::flat_multiset; +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_multiset; + + { + M m = {"alpha", "alpha", "beta", "beta", "beta", "epsilon", "eta", "eta", "eta", "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&& set, const std::string& expected_key, long expected_offset) { + auto iter = set.lower_bound(Transparent{expected_key}); + assert(iter - set.begin() == expected_offset); + }; + + test_lower_bound(m, "abc", 0); + test_lower_bound(m, "alpha", 0); + test_lower_bound(m, "beta", 2); + test_lower_bound(m, "bets", 5); + test_lower_bound(m, "charlie", 5); + test_lower_bound(m, "echo", 5); + test_lower_bound(m, "epsilon", 5); + test_lower_bound(m, "eta", 6); + test_lower_bound(m, "gamma", 10); + test_lower_bound(m, "golf", 11); + test_lower_bound(m, "zzz", 11); + + test_lower_bound(cm, "abc", 0); + test_lower_bound(cm, "alpha", 0); + test_lower_bound(cm, "beta", 2); + test_lower_bound(cm, "bets", 5); + test_lower_bound(cm, "charlie", 5); + test_lower_bound(cm, "echo", 5); + test_lower_bound(cm, "epsilon", 5); + test_lower_bound(cm, "eta", 6); + test_lower_bound(cm, "gamma", 10); + test_lower_bound(cm, "golf", 11); + test_lower_bound(cm, "zzz", 11); + } + { + // 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_multiset m(std::sorted_equivalent, {1, 2, 2, 3, 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.multiset/flat.multiset.operations/upper_bound.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/upper_bound.pass.cpp new file mode 100644 index 0000000000000..7828f0500c8b9 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset, KeyContainer>; + M m = {1, 1, 2, 2, 4, 4, 5, 5, 8, 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() + 2); + assert(m.upper_bound(2) == m.begin() + 4); + assert(m.upper_bound(3) == m.begin() + 4); + assert(m.upper_bound(4) == m.begin() + 6); + assert(m.upper_bound(5) == m.begin() + 8); + assert(m.upper_bound(6) == m.begin() + 8); + assert(std::as_const(m).upper_bound(7) == m.begin() + 8); + assert(std::as_const(m).upper_bound(8) == m.end()); + assert(std::as_const(m).upper_bound(9) == m.end()); + } + + { + using M = std::flat_multiset, KeyContainer>; + M m = {1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 5, 5, 8, 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() + 12); + assert(m.upper_bound(3) == m.begin() + 10); + assert(m.upper_bound(4) == m.begin() + 10); + assert(m.upper_bound(5) == m.begin() + 7); + assert(m.upper_bound(6) == m.begin() + 2); + assert(m.upper_bound(7) == m.begin() + 2); + assert(std::as_const(m).upper_bound(8) == m.begin() + 2); + assert(std::as_const(m).upper_bound(9) == m.begin()); + } + { + // empty + using M = std::flat_multiset, 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.multiset/flat.multiset.operations/upper_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/upper_bound_transparent.pass.cpp new file mode 100644 index 0000000000000..c4215a5c86bca --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.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_multiset; +using NonTransparentSet = std::flat_multiset; +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_multiset; + + { + M m = {"alpha", "alpha", "beta", "epsilon", "epsilon", "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&& set, const std::string& expected_key, long expected_offset) { + auto iter = set.upper_bound(Transparent{expected_key}); + assert(iter - set.begin() == expected_offset); + }; + + test_upper_bound(m, "abc", 0); + test_upper_bound(m, "alpha", 2); + test_upper_bound(m, "beta", 3); + test_upper_bound(m, "bets", 3); + test_upper_bound(m, "charlie", 3); + test_upper_bound(m, "echo", 3); + test_upper_bound(m, "epsilon", 6); + test_upper_bound(m, "eta", 7); + test_upper_bound(m, "gamma", 8); + test_upper_bound(m, "golf", 8); + test_upper_bound(m, "zzz", 8); + + test_upper_bound(cm, "abc", 0); + test_upper_bound(cm, "alpha", 2); + test_upper_bound(cm, "beta", 3); + test_upper_bound(cm, "bets", 3); + test_upper_bound(cm, "charlie", 3); + test_upper_bound(cm, "echo", 3); + test_upper_bound(cm, "epsilon", 6); + test_upper_bound(cm, "eta", 7); + test_upper_bound(cm, "gamma", 8); + test_upper_bound(cm, "golf", 8); + test_upper_bound(cm, "zzz", 8); + } + { + // 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_multiset m(std::sorted_equivalent, {1, 1, 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.multiset/helpers.h b/libcxx/test/std/containers/container.adaptors/flat.multiset/helpers.h index 77ce602454131..60ea3e67d2244 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/helpers.h +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/helpers.h @@ -179,7 +179,6 @@ struct ThrowOnMoveContainer : std::vector { #endif -#if 0 template void test_emplace_exception_guarantee([[maybe_unused]] F&& emplace_function) { #ifndef TEST_HAS_NO_EXCEPTIONS @@ -193,7 +192,7 @@ void test_emplace_exception_guarantee([[maybe_unused]] F&& emplace_function) { test_allocator_statistics stats; - KeyContainer a({1, 2, 3, 4}, test_allocator{&stats}); + KeyContainer a({1, 1, 2, 2, 3, 4}, test_allocator{&stats}); [[maybe_unused]] auto expected_keys = a; M m(std::sorted_equivalent, std::move(a)); @@ -204,7 +203,7 @@ void test_emplace_exception_guarantee([[maybe_unused]] F&& emplace_function) { } catch (const std::bad_alloc&) { check_invariant(m); // In libc++, the flat_multiset is unchanged - LIBCPP_ASSERT(m.size() == 4); + LIBCPP_ASSERT(m.size() == 6); LIBCPP_ASSERT(std::ranges::equal(m, expected_keys)); } } @@ -214,7 +213,7 @@ void test_emplace_exception_guarantee([[maybe_unused]] F&& emplace_function) { using M = std::flat_multiset; LIBCPP_STATIC_ASSERT(!std::__container_traits::__emplacement_has_strong_exception_safety_guarantee); - KeyContainer a = {1, 2, 3, 4}; + KeyContainer a = {1, 1, 2, 2, 3, 4}; M m(std::sorted_equivalent, std::move(a)); try { emplace_function(m, 0); @@ -299,5 +298,4 @@ class Moveable { bool moved() const { return int_ == -1; } }; -#endif // 0 #endif // SUPPORT_flat_multiset_HELPERS_H diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/incomplete_type.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/incomplete_type.pass.cpp new file mode 100644 index 0000000000000..88aa8f5993efa --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/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_multiset and its iterators can be instantiated with an incomplete +// type. + +#include +#include + +struct A { + using Set = std::flat_multiset; + int data; + Set m; + Set::iterator it; + Set::const_iterator cit; +}; + +// Implement the operator< required in order to instantiate flat_multiset +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.multiset/op_compare.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/op_compare.pass.cpp new file mode 100644 index 0000000000000..94f0f2b34abcc --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/op_compare.pass.cpp @@ -0,0 +1,105 @@ +//===----------------------------------------------------------------------===// +// +// 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_multiset& x, const flat_multiset& y); +// friend synth-three-way-result +// operator<=>(const flat_multiset& x, const flat_multiset& 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_multiset; + C s1, s2; + ASSERT_SAME_TYPE(decltype(s1 <=> s2), std::strong_ordering); + AssertComparisonsReturnBool(); + assert(testComparisons(C{1, 1, 2}, C{1, 1, 3}, false, true)); + assert(testComparisons(C{1, 1}, C{1, 1}, true, false)); + assert(testComparisons(C{1, 10}, C{2, 2}, false, true)); + assert(testComparisons(C{}, C{1}, false, true)); + assert(testComparisons(C{2}, C{1, 1, 1, 1, 1}, false, false)); + } + { + // Comparisons use value_type's native operators, not the comparator + using C = std::flat_multiset>; + C s1 = {1, 1}; + C s2 = {2, 2}; + ASSERT_SAME_TYPE(decltype(s1 <=> s2), std::strong_ordering); + AssertComparisonsReturnBool(); + assert(testComparisons(s1, s2, false, true)); + s2 = {1, 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_multiset; + C s1 = {1}; + C s2 = C(std::sorted_equivalent, {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_multiset; + 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 = {1, 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.multiset/types.compile.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/types.compile.pass.cpp new file mode 100644 index 0000000000000..f035487c9e578 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/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_multiset; + 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_multiset>; + 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_multiset, 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>>); + } +} From 408c2dd838b3dba66b5696b05fcaa401cb77666d Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Fri, 28 Mar 2025 10:30:16 +0000 Subject: [PATCH 16/23] ci --- libcxx/include/__flat_set/flat_multiset.h | 1 - libcxx/include/__flat_set/flat_set.h | 1 - libcxx/include/flat_set | 4 ++-- libcxx/include/module.modulemap | 1 + .../flat.multiset.modifiers/insert_initializer_list.pass.cpp | 1 - .../insert_sorted_initializer_list.pass.cpp | 1 - libcxx/utils/libcxx/test/modules.py | 1 + 7 files changed, 4 insertions(+), 6 deletions(-) diff --git a/libcxx/include/__flat_set/flat_multiset.h b/libcxx/include/__flat_set/flat_multiset.h index f1314ffd75109..07e0439d36a20 100644 --- a/libcxx/include/__flat_set/flat_multiset.h +++ b/libcxx/include/__flat_set/flat_multiset.h @@ -68,7 +68,6 @@ #include <__utility/pair.h> #include <__utility/scope_guard.h> #include <__vector/vector.h> -#include #include #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) diff --git a/libcxx/include/__flat_set/flat_set.h b/libcxx/include/__flat_set/flat_set.h index 26336e840d17c..a87496bb9916e 100644 --- a/libcxx/include/__flat_set/flat_set.h +++ b/libcxx/include/__flat_set/flat_set.h @@ -10,7 +10,6 @@ #ifndef _LIBCPP___FLAT_SET_FLAT_SET_H #define _LIBCPP___FLAT_SET_FLAT_SET_H -#include "utils.h" #include <__algorithm/lexicographical_compare_three_way.h> #include <__algorithm/lower_bound.h> #include <__algorithm/min.h> diff --git a/libcxx/include/flat_set b/libcxx/include/flat_set index 5051b27097d2a..eb0e7efbc37f0 100644 --- a/libcxx/include/flat_set +++ b/libcxx/include/flat_set @@ -55,10 +55,10 @@ namespace std { # include <__config> # if _LIBCPP_STD_VER >= 23 -# include <__flat_map/sorted_unique.h> # include <__flat_map/sorted_equivalent.h> -# include <__flat_set/flat_set.h> +# include <__flat_map/sorted_unique.h> # include <__flat_set/flat_multiset.h> +# include <__flat_set/flat_set.h> # endif // for feature-test macros diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap index 6997b0385c0b1..7c35bab0e0c5e 100644 --- a/libcxx/include/module.modulemap +++ b/libcxx/include/module.modulemap @@ -1304,6 +1304,7 @@ module std [system] { module flat_set { module flat_set { header "__flat_set/flat_set.h" + header "__flat_set/flat_multiset.h" export std.vector.vector export std.vector.fwd } diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_initializer_list.pass.cpp index aedd437c8ac10..9c56d3bfb750b 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_initializer_list.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_initializer_list.pass.cpp @@ -26,7 +26,6 @@ template void test_one() { using Key = typename KeyContainer::value_type; using M = std::flat_multiset, KeyContainer>; - using V = typename M::value_type; { M m = {1, 1, 1, 3, 3, 3}; diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_sorted_initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_sorted_initializer_list.pass.cpp index 38f959890c9b4..11af199c3d1ee 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_sorted_initializer_list.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/insert_sorted_initializer_list.pass.cpp @@ -26,7 +26,6 @@ template void test_one() { using Key = typename KeyContainer::value_type; using M = std::flat_multiset, KeyContainer>; - using V = Key; { M m = {1, 1, 1, 3, 3, 3}; m.insert(std::sorted_equivalent, {0, 1, 1, 2, 2, 4}); diff --git a/libcxx/utils/libcxx/test/modules.py b/libcxx/utils/libcxx/test/modules.py index 4c4cd273be3c3..b03d5bc22c31c 100644 --- a/libcxx/utils/libcxx/test/modules.py +++ b/libcxx/utils/libcxx/test/modules.py @@ -93,6 +93,7 @@ ExtraHeader["functional"] = "v1/__compare/compare_three_way.h$" # reuses some functionality defined inside +ExtraHeader["flat_set"] = "v1/__flat_map/sorted_equivalent.h$" ExtraHeader["flat_set"] = "v1/__flat_map/sorted_unique.h$" # Some C compatibility headers define std::size_t, which is in <__cstddef/size_t.h> From 137cfefc794ff11e6952e9cea620e8eba3fc41cc Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Sat, 29 Mar 2025 11:29:40 +0000 Subject: [PATCH 17/23] review --- libcxx/docs/ReleaseNotes/21.rst | 2 +- libcxx/include/__flat_set/flat_multiset.h | 21 +++++++++---------- libcxx/include/__flat_set/utils.h | 2 -- .../flat.multiset.cons/copy_alloc.pass.cpp | 1 + .../initializer_list.pass.cpp | 1 + .../flat.multiset/helpers.h | 6 +++--- 6 files changed, 16 insertions(+), 17 deletions(-) diff --git a/libcxx/docs/ReleaseNotes/21.rst b/libcxx/docs/ReleaseNotes/21.rst index 7af109ddc8657..1f479d19e4772 100644 --- a/libcxx/docs/ReleaseNotes/21.rst +++ b/libcxx/docs/ReleaseNotes/21.rst @@ -43,8 +43,8 @@ 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 `__) - P0472R3: Put std::monostate in (`Github `__) +- P1222R4: A Standard ``flat_set`` (`Github `__) Improvements and New Features ----------------------------- diff --git a/libcxx/include/__flat_set/flat_multiset.h b/libcxx/include/__flat_set/flat_multiset.h index 07e0439d36a20..bf6ab53a43653 100644 --- a/libcxx/include/__flat_set/flat_multiset.h +++ b/libcxx/include/__flat_set/flat_multiset.h @@ -41,6 +41,7 @@ #include <__iterator/concepts.h> #include <__iterator/distance.h> #include <__iterator/iterator_traits.h> +#include <__iterator/prev.h> #include <__iterator/ranges_iterator_traits.h> #include <__iterator/reverse_iterator.h> #include <__memory/allocator_traits.h> @@ -442,7 +443,7 @@ class flat_multiset { return iterator(__key_iter); } - // iterator and const_iterator are the same type + // 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) { @@ -473,7 +474,7 @@ class flat_multiset { // 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. + // This is discussed in P3567, which hasn't been voted on yet. ranges::swap(__compare_, __y.__compare_); ranges::swap(__keys_, __y.__keys_); } @@ -597,15 +598,13 @@ class flat_multiset { auto __on_failure = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; }); size_type __old_size = size(); __flat_set_utils::__append(*this, 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( - ranges::is_sorted(__keys_ | ranges::views::drop(__old_size)), "Key container is not sorted"); - } - ranges::inplace_merge(__keys_.begin(), __keys_.begin() + __old_size, __keys_.end(), __compare_); + if constexpr (!_WasSorted) { + ranges::sort(__keys_.begin() + __old_size, __keys_.end(), __compare_); + } else { + _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT( + ranges::is_sorted(__keys_ | ranges::views::drop(__old_size)), "Key container is not sorted"); } + ranges::inplace_merge(__keys_.begin(), __keys_.begin() + __old_size, __keys_.end(), __compare_); __on_failure.__complete(); } @@ -621,7 +620,7 @@ class flat_multiset { auto __next_smaller = __hint != cend() && __compare_(*__hint, __key); if (!__prev_larger && !__next_smaller) [[likely]] { - // hint correct, just use exact hint iterators + // hint correct, just use exact hint iterator } else if (__prev_larger && !__next_smaller) { // the hint position is more to the right than the key should have been. // we want to emplace the element to a position as right as possible diff --git a/libcxx/include/__flat_set/utils.h b/libcxx/include/__flat_set/utils.h index c39fc6b33c5c8..ed3b4c48580fb 100644 --- a/libcxx/include/__flat_set/utils.h +++ b/libcxx/include/__flat_set/utils.h @@ -49,8 +49,6 @@ struct __flat_set_utils { return typename decay_t<_Set>::iterator(std::move(__key_it)); } - // TODO: We could optimize this, see - // https://github.com/llvm/llvm-project/issues/108624 template _LIBCPP_HIDE_FROM_ABI static void __append(_Set& __set, _InputIterator __first, _InputIterator __last) { __set.__keys_.insert(__set.__keys_.end(), std::move(__first), std::move(__last)); diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/copy_alloc.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/copy_alloc.pass.cpp index 0267c9c0a4f52..ec8ad824ea14b 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/copy_alloc.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/copy_alloc.pass.cpp @@ -12,6 +12,7 @@ // flat_multiset(const flat_multiset&, const allocator_type&); +#include #include #include #include diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/initializer_list.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/initializer_list.pass.cpp index b33994357ca3b..10638d75bbd14 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/initializer_list.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.cons/initializer_list.pass.cpp @@ -16,6 +16,7 @@ // template // flat_multiset(initializer_list il, const key_compare& comp, const Alloc& a); +#include #include #include #include diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/helpers.h b/libcxx/test/std/containers/container.adaptors/flat.multiset/helpers.h index 60ea3e67d2244..ffe1ad58f919e 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/helpers.h +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/helpers.h @@ -6,8 +6,8 @@ // //===----------------------------------------------------------------------===// -#ifndef SUPPORT_flat_multiset_HELPERS_H -#define SUPPORT_flat_multiset_HELPERS_H +#ifndef SUPPORT_FLAT_MULTISET_HELPERS_H +#define SUPPORT_FLAT_MULTISET_HELPERS_H #include #include @@ -298,4 +298,4 @@ class Moveable { bool moved() const { return int_ == -1; } }; -#endif // SUPPORT_flat_multiset_HELPERS_H +#endif // SUPPORT_FLAT_MULTISET_HELPERS_H From 46b3642b5781247d0190b7463637b7c43ef0592a Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Sat, 29 Mar 2025 17:01:17 +0000 Subject: [PATCH 18/23] transparent tests --- .../erase_key_transparent.pass.cpp | 8 ++++++++ .../contains_transparent.pass.cpp | 8 ++++++++ .../count_transparent.pass.cpp | 8 ++++++++ .../equal_range_transparent.pass.cpp | 9 +++++++++ .../flat.multiset.operations/find_transparent.pass.cpp | 10 ++++++++++ .../lower_bound_transparent.pass.cpp | 10 ++++++++++ .../upper_bound_transparent.pass.cpp | 8 ++++++++ 7 files changed, 61 insertions(+) diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/erase_key_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/erase_key_transparent.pass.cpp index de5ef5ffc72a5..a8765495d91d4 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/erase_key_transparent.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.modifiers/erase_key_transparent.pass.cpp @@ -138,6 +138,14 @@ void test() { assert(n == 1); assert(transparent_used); } + { + // std::string and C string literal + using M = std::flat_multiset>; + M m = {"alpha", "beta", "beta", "epsilon", "eta", "gamma"}; + auto n = m.erase("beta"); + assert(n == 2); + assert((m == M{"alpha", "epsilon", "eta", "gamma"})); + } } void test_exception() { diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/contains_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/contains_transparent.pass.cpp index cbb92c9a08a8b..abee2b1bb12f9 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/contains_transparent.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/contains_transparent.pass.cpp @@ -14,6 +14,7 @@ #include #include +#include #include #include #include @@ -74,6 +75,13 @@ void test() { assert(b); assert(transparent_used); } + { + // std::string and C string literal + using M = std::flat_multiset>; + M m = {"alpha", "beta", "beta", "epsilon", "eta", "gamma"}; + assert(m.contains("beta")); + assert(!m.contains("charlie")); + } } int main(int, char**) { diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/count_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/count_transparent.pass.cpp index 08aa1c8fca7d9..a9160aebb7517 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/count_transparent.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/count_transparent.pass.cpp @@ -15,6 +15,7 @@ #include #include #include +#include #include #include @@ -73,6 +74,13 @@ void test() { assert(n == 4); assert(transparent_used); } + { + // std::string and C string literal + using M = std::flat_multiset>; + M m = {"alpha", "beta", "beta", "epsilon", "eta", "gamma"}; + auto n = m.count("beta"); + assert(n == 2); + } } int main(int, char**) { diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/equal_range_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/equal_range_transparent.pass.cpp index 6ed2585357ac2..ae16ec1127f31 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/equal_range_transparent.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/equal_range_transparent.pass.cpp @@ -16,6 +16,7 @@ #include #include #include +#include #include #include @@ -104,6 +105,14 @@ void test() { assert(p.first != p.second); assert(transparent_used); } + { + // std::string and C string literal + using M = std::flat_multiset>; + M m = {"alpha", "beta", "beta", "epsilon", "eta", "gamma"}; + auto [first, last] = m.equal_range("beta"); + assert(first == m.begin() + 1); + assert(last == m.begin() + 3); + } } int main(int, char**) { diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/find_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/find_transparent.pass.cpp index e1f84d68064d7..9d0b75c7b52bc 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/find_transparent.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/find_transparent.pass.cpp @@ -16,6 +16,7 @@ #include #include #include +#include #include #include @@ -91,6 +92,15 @@ void test() { assert(it != m.end()); assert(transparent_used); } + { + // std::string and C string literal + using M = std::flat_multiset>; + M m = {"alpha", "beta", "beta", "epsilon", "eta", "gamma"}; + auto it = m.find("beta"); + assert(it == m.begin() + 1); + auto it2 = m.find("charlie"); + assert(it2 == m.end()); + } } int main(int, char**) { diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/lower_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/lower_bound_transparent.pass.cpp index 2f3d1beffabe9..c03fb27a7c27e 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/lower_bound_transparent.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/lower_bound_transparent.pass.cpp @@ -16,6 +16,7 @@ #include #include #include +#include #include #include @@ -97,6 +98,15 @@ void test() { assert(it != m.end()); assert(transparent_used); } + { + // std::string and C string literal + using M = std::flat_multiset>; + M m = {"alpha", "beta", "beta", "epsilon", "eta", "gamma"}; + auto it = m.lower_bound("beta"); + assert(it == m.begin() + 1); + auto it2 = m.lower_bound("charlie"); + assert(it2 == m.begin() + 3); + } } int main(int, char**) { diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/upper_bound_transparent.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/upper_bound_transparent.pass.cpp index c4215a5c86bca..de517fd7e520a 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/upper_bound_transparent.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.operations/upper_bound_transparent.pass.cpp @@ -16,6 +16,7 @@ #include #include #include +#include #include #include @@ -97,6 +98,13 @@ void test() { assert(it != m.end()); assert(transparent_used); } + { + // std::string and C string literal + using M = std::flat_multiset>; + M m = {"alpha", "beta", "beta", "epsilon", "eta", "gamma"}; + auto it = m.upper_bound("beta"); + assert(it == m.begin() + 3); + } } int main(int, char**) { From 55f5300136bd48e1c20042aec328e1bec23403b6 Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Sat, 29 Mar 2025 18:33:09 +0000 Subject: [PATCH 19/23] ci --- .../container.adaptors/flat.map/helpers.h | 172 +--------------- .../flat.multimap/helpers.h | 172 +--------------- .../flat.multiset/helpers.h | 184 +---------------- .../container.adaptors/flat.set/helpers.h | 187 +----------------- .../container.adaptors/flat_helpers.h | 184 +++++++++++++++++ libcxx/utils/libcxx/test/modules.py | 3 +- 6 files changed, 190 insertions(+), 712 deletions(-) create mode 100644 libcxx/test/std/containers/container.adaptors/flat_helpers.h diff --git a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h index 8dbb85a6c0acf..b6b8fa061c840 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h +++ b/libcxx/test/std/containers/container.adaptors/flat.map/helpers.h @@ -15,6 +15,7 @@ #include #include +#include "../flat_helpers.h" #include "test_allocator.h" #include "test_macros.h" @@ -30,150 +31,6 @@ void check_invariant(const std::flat_map& m) { assert(std::adjacent_find(keys.begin(), keys.end(), key_equal) == keys.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 -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 @@ -363,32 +220,5 @@ void test_erase_exception_guarantee([[maybe_unused]] F&& erase_function) { } #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 // SUPPORT_FLAT_MAP_HELPERS_H diff --git a/libcxx/test/std/containers/container.adaptors/flat.multimap/helpers.h b/libcxx/test/std/containers/container.adaptors/flat.multimap/helpers.h index 252e2454d497c..68d7f67a6669f 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multimap/helpers.h +++ b/libcxx/test/std/containers/container.adaptors/flat.multimap/helpers.h @@ -15,6 +15,7 @@ #include #include +#include "../flat_helpers.h" #include "test_allocator.h" #include "test_macros.h" @@ -25,150 +26,6 @@ void check_invariant(const std::flat_multimap& m) { assert(std::is_sorted(keys.begin(), keys.end(), m.key_comp())); } -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 -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 @@ -358,32 +215,5 @@ void test_erase_exception_guarantee([[maybe_unused]] F&& erase_function) { } #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 // SUPPORT_FLAT_MULTIMAP_HELPERS_H diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/helpers.h b/libcxx/test/std/containers/container.adaptors/flat.multiset/helpers.h index ffe1ad58f919e..e7ed8a091d3be 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/helpers.h +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/helpers.h @@ -15,6 +15,7 @@ #include #include +#include "../flat_helpers.h" #include "test_allocator.h" #include "test_macros.h" @@ -22,162 +23,6 @@ template void check_invariant(const std::flat_multiset& m) { assert(std::is_sorted(m.begin(), m.end(), m.key_comp())); } -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) { @@ -270,32 +115,5 @@ void test_erase_exception_guarantee([[maybe_unused]] F&& erase_function) { } #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 // SUPPORT_FLAT_MULTISET_HELPERS_H diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/helpers.h b/libcxx/test/std/containers/container.adaptors/flat.set/helpers.h index 6aed4b1cf131d..c1670c9101872 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.set/helpers.h +++ b/libcxx/test/std/containers/container.adaptors/flat.set/helpers.h @@ -15,6 +15,7 @@ #include #include +#include "../flat_helpers.h" #include "test_allocator.h" #include "test_macros.h" @@ -28,165 +29,8 @@ void check_invariant(const std::flat_set& m) { 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; - - explicit operator T() const - requires ConvertibleToT - { - return t; - } -}; - -template -using ExplicitlyConvertibleTransparent = 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) { +void test_emplace_exception_guarantee(F&& emplace_function) { #ifndef TEST_HAS_NO_EXCEPTIONS using C = TransparentComparator; { @@ -276,32 +120,5 @@ void test_erase_exception_guarantee([[maybe_unused]] F&& erase_function) { } #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_helpers.h b/libcxx/test/std/containers/container.adaptors/flat_helpers.h new file mode 100644 index 0000000000000..9cd408ef960a9 --- /dev/null +++ b/libcxx/test/std/containers/container.adaptors/flat_helpers.h @@ -0,0 +1,184 @@ +//===----------------------------------------------------------------------===// +// +// 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_HELPERS_H +#define TEST_STD_CONTAINERS_CONTAINER_ADAPTORS_FLAT_HELPERS_H + +#include + +#include "test_macros.h" + +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; + + explicit operator T() const + requires ConvertibleToT + { + return t; + } +}; + +template +using ConvertibleTransparent = Transparent; + +template +using ExplicitlyConvertibleTransparent = 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; +}; + +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; } +}; + +#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 // TEST_HAS_NO_EXCEPTIONS + +#endif // TEST_STD_CONTAINERS_CONTAINER_ADAPTORS_FLAT_HELPERS_H \ No newline at end of file diff --git a/libcxx/utils/libcxx/test/modules.py b/libcxx/utils/libcxx/test/modules.py index b03d5bc22c31c..bd4fbe78c1cdc 100644 --- a/libcxx/utils/libcxx/test/modules.py +++ b/libcxx/utils/libcxx/test/modules.py @@ -93,8 +93,7 @@ ExtraHeader["functional"] = "v1/__compare/compare_three_way.h$" # reuses some functionality defined inside -ExtraHeader["flat_set"] = "v1/__flat_map/sorted_equivalent.h$" -ExtraHeader["flat_set"] = "v1/__flat_map/sorted_unique.h$" +ExtraHeader["flat_set"] = "v1/__flat_map/sorted_.+.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"): From 2401a4c5466f195526dc9a93619affc3c8f633dc Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Sat, 29 Mar 2025 18:44:43 +0000 Subject: [PATCH 20/23] transparent --- libcxx/include/__flat_set/flat_multiset.h | 37 ++++++++++++----------- 1 file changed, 20 insertions(+), 17 deletions(-) diff --git a/libcxx/include/__flat_set/flat_multiset.h b/libcxx/include/__flat_set/flat_multiset.h index bf6ab53a43653..0fed377b25e5a 100644 --- a/libcxx/include/__flat_set/flat_multiset.h +++ b/libcxx/include/__flat_set/flat_multiset.h @@ -10,19 +10,17 @@ #ifndef _LIBCPP___FLAT_MAP_FLAT_MULTISET_H #define _LIBCPP___FLAT_MAP_FLAT_MULTISET_H -#include "utils.h" +#include <__algorithm/equal_range.h> #include <__algorithm/lexicographical_compare_three_way.h> +#include <__algorithm/lower_bound.h> #include <__algorithm/min.h> #include <__algorithm/ranges_equal.h> -#include <__algorithm/ranges_equal_range.h> #include <__algorithm/ranges_inplace_merge.h> #include <__algorithm/ranges_is_sorted.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 <__algorithm/upper_bound.h> #include <__assert> #include <__compare/synth_three_way.h> #include <__concepts/convertible_to.h> @@ -523,43 +521,47 @@ class flat_multiset { } _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const key_type& __x) { - return iterator(ranges::lower_bound(std::as_const(__keys_), __x, __compare_)); + const auto& __keys = __keys_; + return iterator(std::lower_bound(__keys.begin(), __keys.end(), __x, __compare_)); } _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const key_type& __x) const { - return const_iterator(ranges::lower_bound(__keys_, __x, __compare_)); + return const_iterator(std::lower_bound(__keys_.begin(), __keys_.end(), __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_)); + const auto& __keys = __keys_; + return iterator(std::lower_bound(__keys.begin(), __keys.end(), __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_)); + return const_iterator(std::lower_bound(__keys_.begin(), __keys_.end(), __x, __compare_)); } _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __x) { - return iterator(ranges::upper_bound(std::as_const(__keys_), __x, __compare_)); + const auto& __keys = __keys_; + return iterator(std::upper_bound(__keys.begin(), __keys.end(), __x, __compare_)); } _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const key_type& __x) const { - return const_iterator(ranges::upper_bound(__keys_, __x, __compare_)); + return const_iterator(std::upper_bound(__keys_.begin(), __keys_.end(), __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_)); + const auto& __keys = __keys_; + return iterator(std::upper_bound(__keys.begin(), __keys.end(), __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_)); + return const_iterator(std::upper_bound(__keys_.begin(), __keys_.end(), __x, __compare_)); } _LIBCPP_HIDE_FROM_ABI pair equal_range(const key_type& __x) { @@ -630,7 +632,7 @@ class flat_multiset { // | // hint // We want to insert "2" after the last existing "2" - __hint = ranges::upper_bound(begin(), __hint, __key, __compare_); + __hint = std::upper_bound(begin(), __hint, __key, __compare_); } else { _LIBCPP_ASSERT_INTERNAL(!__prev_larger && __next_smaller, "this means that the multiset is not sorted"); @@ -641,7 +643,7 @@ class flat_multiset { // | // hint // We want to insert "2" before the first existing "2" - __hint = ranges::lower_bound(__hint, end(), __key, __compare_); + __hint = std::lower_bound(__hint, end(), __key, __compare_); } return __flat_set_utils::__emplace_exact_pos(*this, __hint, std::forward<_Kp>(__key)); } @@ -658,8 +660,9 @@ class flat_multiset { template _LIBCPP_HIDE_FROM_ABI static auto __equal_range_impl(_Self&& __self, const _Kp& __key) { - using __iter = _If>, const_iterator, iterator>; - auto [__key_first, __key_last] = ranges::equal_range(__self.__keys_, __key, __self.__compare_); + using __iter = _If>, const_iterator, iterator>; + auto [__key_first, __key_last] = + std::equal_range(__self.__keys_.begin(), __self.__keys_.end(), __key, __self.__compare_); return std::make_pair(__iter(__key_first), __iter(__key_last)); } From 1f38bab98c57539ac7c30adf427282ec019475c0 Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Sat, 29 Mar 2025 18:52:47 +0000 Subject: [PATCH 21/23] ci --- libcxx/include/flat_set | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libcxx/include/flat_set b/libcxx/include/flat_set index eb0e7efbc37f0..ebbb3a0247f3e 100644 --- a/libcxx/include/flat_set +++ b/libcxx/include/flat_set @@ -31,7 +31,7 @@ namespace std { template typename flat_set::size_type erase_if(flat_set& c, Predicate pred); - + // [flat.multiset], class template flat_multiset template, class KeyContainer = vector> class flat_multiset; From 0662ae2c6edff53f6d3d6c02ba1fe4d0276ef115 Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Sun, 30 Mar 2025 21:04:03 +0100 Subject: [PATCH 22/23] ci --- .../test/std/containers/container.adaptors/flat.set/helpers.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libcxx/test/std/containers/container.adaptors/flat.set/helpers.h b/libcxx/test/std/containers/container.adaptors/flat.set/helpers.h index c1670c9101872..4cc720311cf01 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.set/helpers.h +++ b/libcxx/test/std/containers/container.adaptors/flat.set/helpers.h @@ -30,7 +30,7 @@ void check_invariant(const std::flat_set& m) { } template -void test_emplace_exception_guarantee(F&& emplace_function) { +void test_emplace_exception_guarantee([[maybe_unused]] F&& emplace_function) { #ifndef TEST_HAS_NO_EXCEPTIONS using C = TransparentComparator; { From 1bcb3f648a8f466319ebc3191db9e5e1feaf3d5f Mon Sep 17 00:00:00 2001 From: Hui Xie Date: Mon, 31 Mar 2025 19:06:29 +0100 Subject: [PATCH 23/23] ci --- .../flat.multiset/flat.multiset.capacity/size.pass.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/size.pass.cpp b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/size.pass.cpp index 69f9e52c927e9..4aff08b8127b6 100644 --- a/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/size.pass.cpp +++ b/libcxx/test/std/containers/container.adaptors/flat.multiset/flat.multiset.capacity/size.pass.cpp @@ -46,8 +46,8 @@ void test_one() { } { M m; - S s = 1000000; - for (auto i = 0u; i < s; ++i) { + S s = 500000; + for (std::size_t i = 0u; i < s; ++i) { m.emplace(i); m.emplace(i); }