From 54e205f87ed4be20f05165fe4a027dec2a360eab Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 26 Jan 2026 04:14:28 -0800
Subject: [PATCH 01/25] Drop `using namespace ranges;`, qualify
 `ranges::input_range` and `ranges::range_reference_t`.

---
 tests/std/tests/P1222R4_flat_set/test.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index f18ebbaf78e..d9374a8df9f 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -24,12 +24,11 @@
 #define TEST_ASSERT(...) assert((__VA_ARGS__))
 
 using namespace std;
-using namespace ranges;
 
 enum class iterator_pair_construction : bool { no_allocator, with_allocator };
 
 template <class R, class T>
-concept container_compatible_range = input_range<R> && convertible_to<range_reference_t<R>, T>;
+concept container_compatible_range = ranges::input_range<R> && convertible_to<ranges::range_reference_t<R>, T>;
 
 template <class T, class Alloc = allocator<T>,
     iterator_pair_construction Choice = iterator_pair_construction::with_allocator>

From 5ad5748ee847554b97ebb566e31fc0db0f96dfb5 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 26 Jan 2026 04:18:30 -0800
Subject: [PATCH 02/25] Drop `std::` for `less`, `greater`, `move`, `copy`.

---
 tests/std/tests/P1222R4_flat_set/test.cpp | 86 +++++++++++------------
 1 file changed, 43 insertions(+), 43 deletions(-)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index d9374a8df9f..abb77fbecad 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -67,7 +67,7 @@ class alternative_vector : private vector<T, Alloc> { // not allocator-aware, bu
     constexpr alternative_vector(allocator_arg_t, const type_identity_t<Alloc>& a, const alternative_vector& other)
         : base_type(other, a) {}
     constexpr alternative_vector(allocator_arg_t, const type_identity_t<Alloc>& a, alternative_vector&& other)
-        : base_type(std::move(other), a) {}
+        : base_type(move(other), a) {}
     constexpr explicit alternative_vector(initializer_list<T> il) : base_type(il) {}
 
     alternative_vector(const alternative_vector&) = default;
@@ -171,8 +171,8 @@ void assert_all_requirements_and_equals(
 
 template <class C>
 void test_constructors() {
-    using lt = std::less<int>;
-    using gt = std::greater<int>;
+    using lt = less<int>;
+    using gt = greater<int>;
 
     {
         // Test flat_set()
@@ -208,21 +208,21 @@ void test_constructors() {
     a = {1, 7, 7, 7, 2, 100, -1};
     assert_all_requirements_and_equals(a, {-1, 1, 2, 7, 100});
     assert_all_requirements_and_equals(flat_set<int>(a, allocator<int>{}), {-1, 1, 2, 7, 100});
-    assert_all_requirements_and_equals(flat_set<int>(std::move(a), allocator<int>{}), {-1, 1, 2, 7, 100});
+    assert_all_requirements_and_equals(flat_set<int>(move(a), allocator<int>{}), {-1, 1, 2, 7, 100});
     flat_multiset<int> b{};
     b = {1, 7, 7, 7, 2, 100, -1};
     assert_all_requirements_and_equals(b, {-1, 1, 2, 7, 7, 7, 100});
     assert_all_requirements_and_equals(flat_multiset<int>(b, allocator<int>{}), {-1, 1, 2, 7, 7, 7, 100});
-    assert_all_requirements_and_equals(flat_multiset<int>(std::move(b), allocator<int>{}), {-1, 1, 2, 7, 7, 7, 100});
+    assert_all_requirements_and_equals(flat_multiset<int>(move(b), allocator<int>{}), {-1, 1, 2, 7, 7, 7, 100});
 }
 
 template <iterator_pair_construction Choice>
 void test_allocator_extended_constructors() {
     using vec = alternative_vector<int, allocator<int>, Choice>;
     constexpr allocator<int> ator;
-    constexpr std::less<int> comp;
+    constexpr less<int> comp;
     {
-        using fs = flat_set<int, std::less<int>, vec>;
+        using fs = flat_set<int, less<int>, vec>;
 
         fs s{3, 7, 1, 85, 222, 1};
         fs s_expected{1, 3, 7, 85, 222};
@@ -233,7 +233,7 @@ void test_allocator_extended_constructors() {
 
         TEST_ASSERT(fs{s, ator} == s_expected);
         TEST_ASSERT(fs{s_expected, ator} == s_expected);
-        TEST_ASSERT(fs{std::move(s), ator} == s_expected);
+        TEST_ASSERT(fs{move(s), ator} == s_expected);
         TEST_ASSERT(fs{fs{s_expected}, ator} == s_expected);
 
         TEST_ASSERT(fs{v_raw, ator} == s_expected);
@@ -257,7 +257,7 @@ void test_allocator_extended_constructors() {
         }
     }
     {
-        using fms = flat_multiset<int, std::less<int>, vec>;
+        using fms = flat_multiset<int, less<int>, vec>;
 
         fms s{3, 7, 1, 85, 222, 1};
         fms s_expected{1, 1, 3, 7, 85, 222};
@@ -268,7 +268,7 @@ void test_allocator_extended_constructors() {
 
         TEST_ASSERT(fms{s, ator} == s_expected);
         TEST_ASSERT(fms{s_expected, ator} == s_expected);
-        TEST_ASSERT(fms{std::move(s), ator} == s_expected);
+        TEST_ASSERT(fms{move(s), ator} == s_expected);
         TEST_ASSERT(fms{fms{s_expected}, ator} == s_expected);
 
         TEST_ASSERT(fms{v_raw, ator} == s_expected);
@@ -311,7 +311,7 @@ void test_always_reversible() {
         using base::base;
     };
 
-    Set<int, std::greater<int>, not_reversible> fs({1, 2, 3});
+    Set<int, greater<int>, not_reversible> fs({1, 2, 3});
     assert_all_requirements_and_equals(fs, {3, 2, 1});
     assert(fs.rbegin() + 3 == fs.rend());
     assert(fs.crend() - fs.crbegin() == 3);
@@ -319,7 +319,7 @@ void test_always_reversible() {
 
 template <class C>
 void test_insert_1() {
-    using lt = std::less<int>;
+    using lt = less<int>;
 
     const vector<int> vec{0, 1, 2};
     {
@@ -374,7 +374,7 @@ void test_insert_1() {
 
 template <class C>
 void test_insert_2() {
-    using lt = std::less<int>;
+    using lt = less<int>;
 
     const int val = 1;
     {
@@ -403,7 +403,7 @@ void test_insert_2() {
     }
 
     // TRANSITION, too simple
-    using gt = std::greater<int>;
+    using gt = greater<int>;
     {
         flat_set<int, gt, C> a{0, 5};
         assert_all_requirements_and_equals(a, {5, 0});
@@ -417,7 +417,7 @@ void test_insert_2() {
 // Test that hint to emplace/insert is respected, when possible; check returned iterator
 template <class C>
 void test_insert_hint_is_respected() {
-    using lt = std::less<int>;
+    using lt = less<int>;
 
     {
         flat_multiset<int, lt, C> a{-1, -1, 1, 1};
@@ -621,7 +621,7 @@ void test_insert_upper_bound() {
 template <class T>
 void test_spaceship_operator() {
     static constexpr bool multi  = _Is_specialization_v<T, flat_multiset>;
-    static constexpr bool invert = is_same_v<typename T::key_compare, std::greater<typename T::key_type>>;
+    static constexpr bool invert = is_same_v<typename T::key_compare, greater<typename T::key_type>>;
 
     T a{3, 2, 2, 1};
     T b{1, 2, 3};
@@ -659,7 +659,7 @@ void test_non_static_comparer() {
     a.insert_range(vector{7, 7, 3, 3, 2});
     assert_all_requirements_and_equals(a, {9, 7, 5, 3, 2, -1});
 
-    a = std::move(aBackup);
+    a = move(aBackup);
     assert_all_requirements_and_equals(a, {1, 2, 3});
 
     a.insert(-100);
@@ -696,9 +696,9 @@ void test_extract_1() {
     };
 
     will_throw = false;
-    Set<int, std::less<int>, test_exception> fs{4, 3, 2, 1};
+    Set<int, less<int>, test_exception> fs{4, 3, 2, 1};
     assert_all_requirements_and_equals(fs, {1, 2, 3, 4});
-    auto extr = std::move(fs).extract();
+    auto extr = move(fs).extract();
     assert(ranges::equal(extr, vector{1, 2, 3, 4}));
     assert_all_requirements_and_equals(fs, {}); // assert empty
 
@@ -706,7 +706,7 @@ void test_extract_1() {
     assert_all_requirements_and_equals(fs, {1, 2, 3, 4});
     try {
         will_throw = true;
-        (void) std::move(fs).extract();
+        (void) move(fs).extract();
     } catch (...) {
         will_throw = false;
         assert_all_requirements_and_equals(fs, {}); // assert empty
@@ -736,9 +736,9 @@ void test_extract_2() {
         }
     };
 
-    Set<int, std::less<int>, always_copy> fs{4, 3, 2, 1};
+    Set<int, less<int>, always_copy> fs{4, 3, 2, 1};
     assert_all_requirements_and_equals(fs, {1, 2, 3, 4});
-    auto extr = std::move(fs).extract();
+    auto extr = move(fs).extract();
     assert(ranges::equal(extr, vector{1, 2, 3, 4}));
     assert_all_requirements_and_equals(fs, {}); // assert empty
 }
@@ -798,7 +798,7 @@ void test_invariant_robustness() {
         // this copy-assignment cannot provide strong-guarantee for `this`:
         odd_container& operator=(const odd_container& other) {
             resize(other.size());
-            std::copy(other.begin(), other.end(), begin());
+            copy(other.begin(), other.end(), begin());
             return *this;
         }
 
@@ -807,7 +807,7 @@ void test_invariant_robustness() {
         odd_container(odd_container&& other) {
             reserve(other.size());
             for (auto& e : other) {
-                push_back(std::move(e));
+                push_back(move(e));
             }
         }
 
@@ -815,7 +815,7 @@ void test_invariant_robustness() {
         // elements of `other` in moved-from state:
         odd_container& operator=(odd_container&& other) {
             resize(other.size());
-            std::move(other.begin(), other.end(), begin());
+            move(other.begin(), other.end(), begin());
             return *this;
         }
     };
@@ -846,7 +846,7 @@ void test_invariant_robustness() {
     {
         copy_limit = unlimited;
         SetT fs1{0, 1, 2, 3, 4};
-        SetT fs2{std::move(fs1)};
+        SetT fs2{move(fs1)};
 
         assert_all_requirements(fs1);
         assert(ranges::equal(fs2, vector{0, 1, 2, 3, 4}, {}, &odd_key::key));
@@ -854,7 +854,7 @@ void test_invariant_robustness() {
         bool caught = false;
         try {
             copy_limit = 2;
-            SetT fs3{std::move(fs2)}; // will throw after moving 2 odd_key.
+            SetT fs3{move(fs2)}; // will throw after moving 2 odd_key.
         } catch (...) {
             copy_limit = unlimited;
             assert_all_requirements(fs2);
@@ -868,7 +868,7 @@ void test_invariant_robustness() {
         SetT fs1{0, 1, 2, 3, 4};
         SetT fs2;
         SetT fs3{5, 6, 7, 8, 9};
-        fs2 = std::move(fs1);
+        fs2 = move(fs1);
 
         assert_all_requirements(fs1);
         assert(ranges::equal(fs2, vector{0, 1, 2, 3, 4}, {}, &odd_key::key));
@@ -877,7 +877,7 @@ void test_invariant_robustness() {
         bool caught = false;
         try {
             copy_limit = 2;
-            fs2        = std::move(fs3); // will throw after moving 2 odd_key.
+            fs2        = move(fs3); // will throw after moving 2 odd_key.
         } catch (...) {
             copy_limit = unlimited;
             assert_all_requirements(fs2);
@@ -912,14 +912,14 @@ template <class T>
 struct holder {
     T t;
     operator T() && {
-        return std::move(t);
+        return move(t);
     }
 };
 
 static_assert(is_convertible_v<holder<flat_set<int>::const_iterator>, flat_set<int>::const_iterator>);
 
 void test_erase_2() {
-    using C = flat_set<int, std::less<>>;
+    using C = flat_set<int, less<>>;
     C fs{0, 1, 2, 3};
     assert_all_requirements_and_equals(fs, {0, 1, 2, 3});
     // this should be allowed per P2077R3:
@@ -953,16 +953,16 @@ namespace detail {
     static_assert(same_as<C::size_type, decltype(declval<C>().erase(declval<int>()))>);
 
     // erase key_type
-    static_assert(can_erase_key<flat_set<int, std::less<int>>, int>);
-    static_assert(can_erase_key<flat_set<int, std::less<>>, int>);
+    static_assert(can_erase_key<flat_set<int, less<int>>, int>);
+    static_assert(can_erase_key<flat_set<int, less<>>, int>);
     static_assert(can_erase_key<flat_set<int, ranges::less>, int>);
     // erase wrapped key_type
-    static_assert(!can_erase_key<flat_set<int, std::less<int>>, holder<int>>);
-    static_assert(can_erase_key<flat_set<int, std::less<>>, holder<int>>);
+    static_assert(!can_erase_key<flat_set<int, less<int>>, holder<int>>);
+    static_assert(can_erase_key<flat_set<int, less<>>, holder<int>>);
     static_assert(can_erase_key<flat_set<int, ranges::less>, holder<int>>);
     // erase wrapped iterator - the member function template returning size_type must not be selected
-    static_assert(can_erase_iterator_holder<flat_set<int, std::less<int>>>);
-    static_assert(can_erase_iterator_holder<flat_set<int, std::less<>>>);
+    static_assert(can_erase_iterator_holder<flat_set<int, less<int>>>);
+    static_assert(can_erase_iterator_holder<flat_set<int, less<>>>);
     static_assert(can_erase_iterator_holder<flat_set<int, ranges::less>>);
 } // namespace detail
 
@@ -1244,12 +1244,12 @@ void test_non_strict_weak_order_compare() {
 void run_normal_tests() {
     test_spaceship_operator<flat_set<int>>();
     test_spaceship_operator<flat_multiset<int>>();
-    test_spaceship_operator<flat_set<int, std::greater<int>>>();
-    test_spaceship_operator<flat_multiset<int, std::greater<int>>>();
-    test_spaceship_operator<flat_set<int, std::less<int>, deque<int>>>();
-    test_spaceship_operator<flat_multiset<int, std::less<int>, deque<int>>>();
-    test_spaceship_operator<flat_set<int, std::greater<int>, deque<int>>>();
-    test_spaceship_operator<flat_multiset<int, std::greater<int>, deque<int>>>();
+    test_spaceship_operator<flat_set<int, greater<int>>>();
+    test_spaceship_operator<flat_multiset<int, greater<int>>>();
+    test_spaceship_operator<flat_set<int, less<int>, deque<int>>>();
+    test_spaceship_operator<flat_multiset<int, less<int>, deque<int>>>();
+    test_spaceship_operator<flat_set<int, greater<int>, deque<int>>>();
+    test_spaceship_operator<flat_multiset<int, greater<int>, deque<int>>>();
 
     test_constructors<vector<int>>();
     test_constructors<deque<int>>();

From 180e07834fe5de0a16db1ab71a925ae2a74943e0 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 26 Jan 2026 04:20:10 -0800
Subject: [PATCH 03/25] Use `ranges::equal` and `println()`.

This is more consistent with the flat_map test and improves the output from:

```
running normal tests...Expected: {1, 3, 7, 85, 223, }
Got:      {1, 3, 7, 85, 222, }
```

to:

```
running normal tests...Unexpected content!
Expected [1, 3, 7, 85, 223]
Actual {1, 3, 7, 85, 222}
```
---
 tests/std/tests/P1222R4_flat_set/test.cpp | 14 ++------------
 1 file changed, 2 insertions(+), 12 deletions(-)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index abb77fbecad..ccee35f4097 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -9,7 +9,6 @@
 #include <deque>
 #include <flat_set>
 #include <functional>
-#include <iostream>
 #include <memory>
 #include <print>
 #include <random>
@@ -146,17 +145,8 @@ template <class T>
 void assert_all_requirements_and_equals(const T& s, const initializer_list<typename T::value_type>& il) {
     assert_all_requirements(s);
 
-    if (!std::equal(s.begin(), s.end(), il.begin(), il.end())) {
-        cout << "Expected: {";
-        for (auto&& e : il) {
-            cout << e << ", ";
-        }
-        cout << "}" << endl;
-        cout << "Got:      {";
-        for (auto&& e : s) {
-            cout << e << ", ";
-        }
-        cout << "}" << endl;
+    if (!ranges::equal(s, il)) {
+        println("Unexpected content!\nExpected {}\nActual {}", il, s);
         assert(false);
     }
 }

From 1397a42f660e1539f45965fb173690403ff3f4cd Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 26 Jan 2026 04:47:51 -0800
Subject: [PATCH 04/25] `INT_MAX` => `(numeric_limits<int>::max)()`

---
 tests/std/tests/P1222R4_flat_set/test.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index ccee35f4097..708a89ee21d 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -3,12 +3,12 @@
 
 #include <algorithm>
 #include <cassert>
-#include <climits>
 #include <concepts>
 #include <cstdlib>
 #include <deque>
 #include <flat_set>
 #include <functional>
+#include <limits>
 #include <memory>
 #include <print>
 #include <random>
@@ -735,7 +735,7 @@ void test_extract_2() {
 
 void test_invariant_robustness() {
     static int copy_limit   = 2;
-    constexpr int unlimited = INT_MAX;
+    constexpr int unlimited = (numeric_limits<int>::max)();
 
     struct odd_key {
         static void countdown() {

From aa5983624779128d84330d4643b133a883e2cd81 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 26 Jan 2026 04:58:41 -0800
Subject: [PATCH 05/25] Cite N5032 [associative.reqmts.general] instead of
 P2077R3 Heterogeneous Erasure Overloads For Associative Containers.

---
 tests/std/tests/P1222R4_flat_set/test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 708a89ee21d..e1d57b6c6c2 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -912,7 +912,7 @@ void test_erase_2() {
     using C = flat_set<int, less<>>;
     C fs{0, 1, 2, 3};
     assert_all_requirements_and_equals(fs, {0, 1, 2, 3});
-    // this should be allowed per P2077R3:
+    // this should be allowed per N5032 [associative.reqmts.general]/7.23.2 and /122-125:
     fs.erase(holder<C::const_iterator>{fs.cbegin()});
     assert_all_requirements_and_equals(fs, {1, 2, 3});
     fs.erase(holder<C::iterator>{fs.begin()});

From cab2c030129a6a7774e1a56634793ad9f2d971a2 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 26 Jan 2026 08:43:27 -0800
Subject: [PATCH 06/25] Drop extra newlines.

---
 tests/std/tests/P1222R4_flat_set/test.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index e1d57b6c6c2..7395038dcfd 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -462,7 +462,6 @@ void test_insert_hint_is_respected() {
     }
 }
 
-
 struct key_comparer {
     const auto& extract_key(const auto& obj) const {
         if constexpr (requires { obj.key; }) {
@@ -956,7 +955,6 @@ namespace detail {
     static_assert(can_erase_iterator_holder<flat_set<int, ranges::less>>);
 } // namespace detail
 
-
 template <class C>
 void test_erase_if() {
     constexpr int erased_result[]{1, 3};

From 2b636754140d86ab114d0fa9f534baa406bff070 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 26 Jan 2026 08:49:41 -0800
Subject: [PATCH 07/25] Run tests in definition order.

---
 tests/std/tests/P1222R4_flat_set/test.cpp | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 7395038dcfd..e59eadd32a7 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -1230,15 +1230,6 @@ void test_non_strict_weak_order_compare() {
 }
 
 void run_normal_tests() {
-    test_spaceship_operator<flat_set<int>>();
-    test_spaceship_operator<flat_multiset<int>>();
-    test_spaceship_operator<flat_set<int, greater<int>>>();
-    test_spaceship_operator<flat_multiset<int, greater<int>>>();
-    test_spaceship_operator<flat_set<int, less<int>, deque<int>>>();
-    test_spaceship_operator<flat_multiset<int, less<int>, deque<int>>>();
-    test_spaceship_operator<flat_set<int, greater<int>, deque<int>>>();
-    test_spaceship_operator<flat_multiset<int, greater<int>, deque<int>>>();
-
     test_constructors<vector<int>>();
     test_constructors<deque<int>>();
     test_allocator_extended_constructors<iterator_pair_construction::no_allocator>();
@@ -1253,11 +1244,20 @@ void run_normal_tests() {
     test_insert_2<deque<int>>();
     test_insert_hint_is_respected<vector<int>>();
     test_insert_hint_is_respected<deque<int>>();
+    test_comparer_application();
     test_insert_transparent();
     test_insert_using_invalid_hint();
     test_insert_upper_bound();
 
-    test_comparer_application();
+    test_spaceship_operator<flat_set<int>>();
+    test_spaceship_operator<flat_multiset<int>>();
+    test_spaceship_operator<flat_set<int, greater<int>>>();
+    test_spaceship_operator<flat_multiset<int, greater<int>>>();
+    test_spaceship_operator<flat_set<int, less<int>, deque<int>>>();
+    test_spaceship_operator<flat_multiset<int, less<int>, deque<int>>>();
+    test_spaceship_operator<flat_set<int, greater<int>, deque<int>>>();
+    test_spaceship_operator<flat_multiset<int, greater<int>, deque<int>>>();
+
     test_non_static_comparer();
 
     test_extract_1<flat_set>();
@@ -1265,9 +1265,9 @@ void run_normal_tests() {
     test_extract_2<flat_set>();
     test_extract_2<flat_multiset>();
 
+    test_invariant_robustness();
     test_erase_1();
     test_erase_2();
-    test_invariant_robustness();
 
     test_erase_if<flat_set<int>>();
     test_erase_if<flat_multiset<int>>();

From 283b596a5161fdc0ff756b31a5705c8e29378587 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 26 Jan 2026 06:30:29 -0800
Subject: [PATCH 08/25] Overhaul `test_constructors()` to actually test all
 normal constructors.

Update 2-arg `assert_all_requirements_and_equals()` to accept other ranges.

Drop 3-arg `assert_all_requirements_and_equals()`.
---
 tests/std/tests/P1222R4_flat_set/test.cpp | 120 ++++++++++++++--------
 1 file changed, 75 insertions(+), 45 deletions(-)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index e59eadd32a7..641017e7bda 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -141,69 +141,99 @@ void assert_all_requirements(const T& s) {
     assert_is_sorted_maybe_unique<_Is_specialization_v<T, flat_set>>(s);
 }
 
-template <class T>
-void assert_all_requirements_and_equals(const T& s, const initializer_list<typename T::value_type>& il) {
+template <class T, class U = initializer_list<typename T::value_type>>
+void assert_all_requirements_and_equals(const T& s, const U& correct) {
     assert_all_requirements(s);
 
-    if (!ranges::equal(s, il)) {
-        println("Unexpected content!\nExpected {}\nActual {}", il, s);
+    if (!ranges::equal(s, correct)) {
+        println("Unexpected content!\nExpected {}\nActual {}", correct, s);
         assert(false);
     }
 }
 
-template <class T, class U>
-void assert_all_requirements_and_equals(
-    const T& first, const U& second, const initializer_list<typename T::value_type>& il) {
-    assert_all_requirements_and_equals(first, il);
-    assert_all_requirements_and_equals(second, il);
-    assert(first == second);
-}
-
 template <class C>
 void test_constructors() {
     using lt = less<int>;
     using gt = greater<int>;
 
+    // Test flat_set()
+    // and  flat_set(const key_compare&)
+    assert_all_requirements_and_equals(flat_set<int, lt, C>(), {});
+    assert_all_requirements_and_equals(flat_multiset<int, lt, C>(), {});
+    assert_all_requirements_and_equals(flat_set<int, lt, C>(lt{}), {});
+    assert_all_requirements_and_equals(flat_multiset<int, lt, C>(lt{}), {});
+
     {
-        // Test flat_set()
-        // and  flat_set(const key_compare&)
-        const lt comp;
-        {
-            flat_set<int, lt, C> fs;
-            flat_set<int, lt, C> fs1(comp);
-            assert_all_requirements_and_equals(fs, fs1, {});
-        }
-        {
-            flat_multiset<int, lt, C> fms;
-            flat_multiset<int, lt, C> fms1(comp);
-            assert_all_requirements_and_equals(fms, fms1, {});
-        }
-    }
-    {
-        // Test flat_set(const container)
+        // Test flat_set(container_type, const key_compare& = key_compare())
+        flat_set fs1(C{3, 7, 1, 85, 222, 1});
+        flat_multiset fms1(C{3, 7, 1, 85, 7, 222, 1});
+        flat_set fs2(C{1, 2, 3, 3}, gt{});
+        flat_multiset fms2(C{1, 1, 2, 3}, gt{});
+        assert_all_requirements_and_equals(fs1, {1, 3, 7, 85, 222});
+        assert_all_requirements_and_equals(fms1, {1, 1, 3, 7, 7, 85, 222});
+        assert_all_requirements_and_equals(fs2, {3, 2, 1});
+        assert_all_requirements_and_equals(fms2, {3, 2, 1, 1});
+
+        // Test flat_set(const flat_set&)
+        // and  flat_set(flat_set&&)
+        flat_set fs3(fs1);
+        flat_multiset fms3(fms1);
+        flat_set fs4(move(fs2));
+        flat_multiset fms4(move(fms2));
+        assert_all_requirements_and_equals(fs3, {1, 3, 7, 85, 222});
+        assert_all_requirements_and_equals(fms3, {1, 1, 3, 7, 7, 85, 222});
+        assert_all_requirements_and_equals(fs4, {3, 2, 1});
+        assert_all_requirements_and_equals(fms4, {3, 2, 1, 1});
     }
 
-    assert_all_requirements_and_equals(flat_set(C{3, 7, 1, 85, 222, 1}), {1, 3, 7, 85, 222});
-    assert_all_requirements_and_equals(flat_multiset(C{3, 7, 1, 85, 7, 222, 1}), {1, 1, 3, 7, 7, 85, 222});
-    assert_all_requirements_and_equals(flat_set(C{1, 2, 3, 3}, gt{}), {3, 2, 1});
-    assert_all_requirements_and_equals(flat_multiset(C{1, 1, 2, 3}, gt{}), {3, 2, 1, 1});
+    // Test flat_set(sorted_unique_t, container_type, const key_compare& = key_compare())
+    assert_all_requirements_and_equals(flat_set(sorted_unique, C{1, 200, 30000}), {1, 200, 30000});
+    assert_all_requirements_and_equals(flat_multiset(sorted_equivalent, C{-1, 3, 3}), {-1, 3, 3});
     assert_all_requirements_and_equals(flat_set(sorted_unique, C{30000, 200, 1}, gt{}), {30000, 200, 1});
     assert_all_requirements_and_equals(flat_multiset(sorted_equivalent, C{3, 3, -1}, gt{}), {3, 3, -1});
-    assert_all_requirements_and_equals(flat_set<int, gt, C>({30000, 200, 1}, gt{}), {30000, 200, 1});
-    assert_all_requirements_and_equals(flat_multiset<int, gt, C>({3, 3, -1}, gt{}), {3, 3, -1});
+
+    const int arr[] = {2, 7, 18, 28, 18, 28, 45, 90, 45, 23};
+
+    // Test flat_set(InIt, InIt, const key_compare& = key_compare())
+    assert_all_requirements_and_equals(flat_set<int, lt, C>(begin(arr), end(arr)), {2, 7, 18, 23, 28, 45, 90});
+    assert_all_requirements_and_equals(
+        flat_multiset<int, lt, C>(begin(arr), end(arr)), {2, 7, 18, 18, 23, 28, 28, 45, 45, 90});
+    assert_all_requirements_and_equals(flat_set<int, gt, C>(begin(arr), end(arr), gt{}), {90, 45, 28, 23, 18, 7, 2});
+    assert_all_requirements_and_equals(
+        flat_multiset<int, gt, C>(begin(arr), end(arr), gt{}), {90, 45, 45, 28, 28, 23, 18, 18, 7, 2});
+
+    {
+        // Test flat_set(sorted_unique_t, InIt, InIt, const key_compare& = key_compare())
+        const int ua[] = {10, 20, 30}; // unique ascending
+        const int ea[] = {40, 50, 50, 60, 60, 60}; // equivalent ascending
+        const int ud[] = {66, 55, 44}; // unique descending
+        const int ed[] = {33, 22, 22, 11, 11, 11}; // equivalent descending
+        assert_all_requirements_and_equals(flat_set<int, lt, C>(sorted_unique, begin(ua), end(ua)), ua);
+        assert_all_requirements_and_equals(flat_multiset<int, lt, C>(sorted_equivalent, begin(ea), end(ea)), ea);
+        assert_all_requirements_and_equals(flat_set<int, gt, C>(sorted_unique, begin(ud), end(ud), gt{}), ud);
+        assert_all_requirements_and_equals(flat_multiset<int, gt, C>(sorted_equivalent, begin(ed), end(ed), gt{}), ed);
+    }
+
+    // Test flat_set(from_range_t, R&&)
+    // and  flat_set(from_range_t, R&&, const key_compare&)
+    assert_all_requirements_and_equals(flat_set<int, lt, C>(from_range, arr), {2, 7, 18, 23, 28, 45, 90});
+    assert_all_requirements_and_equals(
+        flat_multiset<int, lt, C>(from_range, arr), {2, 7, 18, 18, 23, 28, 28, 45, 45, 90});
+    assert_all_requirements_and_equals(flat_set<int, gt, C>(from_range, arr, gt{}), {90, 45, 28, 23, 18, 7, 2});
+    assert_all_requirements_and_equals(
+        flat_multiset<int, gt, C>(from_range, arr, gt{}), {90, 45, 45, 28, 28, 23, 18, 18, 7, 2});
+
+    // Test flat_set(initializer_list<value_type>, const key_compare& = key_compare())
+    assert_all_requirements_and_equals(flat_set<int, lt, C>({3, 7, 1, 85, 222, 1}), {1, 3, 7, 85, 222});
+    assert_all_requirements_and_equals(flat_multiset<int, lt, C>({3, 7, 1, 85, 7, 222, 1}), {1, 1, 3, 7, 7, 85, 222});
+    assert_all_requirements_and_equals(flat_set<int, gt, C>({1, 2, 3, 3}, gt{}), {3, 2, 1});
+    assert_all_requirements_and_equals(flat_multiset<int, gt, C>({1, 1, 2, 3}, gt{}), {3, 2, 1, 1});
+
+    // Test flat_set(sorted_unique_t, initializer_list<value_type>, const key_compare& = key_compare())
+    assert_all_requirements_and_equals(flat_set<int, lt, C>(sorted_unique, {1, 200, 30000}), {1, 200, 30000});
+    assert_all_requirements_and_equals(flat_multiset<int, lt, C>(sorted_equivalent, {-1, 3, 3}), {-1, 3, 3});
     assert_all_requirements_and_equals(flat_set<int, gt, C>(sorted_unique, {30000, 200, 1}, gt{}), {30000, 200, 1});
     assert_all_requirements_and_equals(flat_multiset<int, gt, C>(sorted_equivalent, {3, 3, -1}, gt{}), {3, 3, -1});
-
-    flat_set<int> a{};
-    a = {1, 7, 7, 7, 2, 100, -1};
-    assert_all_requirements_and_equals(a, {-1, 1, 2, 7, 100});
-    assert_all_requirements_and_equals(flat_set<int>(a, allocator<int>{}), {-1, 1, 2, 7, 100});
-    assert_all_requirements_and_equals(flat_set<int>(move(a), allocator<int>{}), {-1, 1, 2, 7, 100});
-    flat_multiset<int> b{};
-    b = {1, 7, 7, 7, 2, 100, -1};
-    assert_all_requirements_and_equals(b, {-1, 1, 2, 7, 7, 7, 100});
-    assert_all_requirements_and_equals(flat_multiset<int>(b, allocator<int>{}), {-1, 1, 2, 7, 7, 7, 100});
-    assert_all_requirements_and_equals(flat_multiset<int>(move(b), allocator<int>{}), {-1, 1, 2, 7, 7, 7, 100});
 }
 
 template <iterator_pair_construction Choice>

From f0eb53a00a08f4a0c2787aa9afbbba44f2494923 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Mon, 26 Jan 2026 10:57:50 -0800
Subject: [PATCH 09/25] Test construction from just an allocator.

---
 tests/std/tests/P1222R4_flat_set/test.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 641017e7bda..9d6b00f1ed6 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -249,6 +249,7 @@ void test_allocator_extended_constructors() {
         vec v_raw{3, 7, 1, 85, 222, 1};
         vec v_sorted_unique{1, 3, 7, 85, 222};
 
+        TEST_ASSERT(fs{ator} == fs{});
         TEST_ASSERT(fs{comp, ator} == fs{});
 
         TEST_ASSERT(fs{s, ator} == s_expected);
@@ -284,6 +285,7 @@ void test_allocator_extended_constructors() {
         vec v_raw{3, 7, 1, 85, 222, 1};
         vec v_sorted_eq{1, 1, 3, 7, 85, 222};
 
+        TEST_ASSERT(fms{ator} == fms{});
         TEST_ASSERT(fms{comp, ator} == fms{});
 
         TEST_ASSERT(fms{s, ator} == s_expected);

From 8a6ca1748721a4bc5ba6fe4db2c5f567cd65ed11 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 27 Jan 2026 02:39:54 -0800
Subject: [PATCH 10/25] Expand `test_insert_2()`, fixing "TRANSITION, too
 simple".

---
 tests/std/tests/P1222R4_flat_set/test.cpp | 29 +++++++++++++++++------
 1 file changed, 22 insertions(+), 7 deletions(-)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 9d6b00f1ed6..756b806c92f 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -424,15 +424,30 @@ void test_insert_2() {
         assert_all_requirements_and_equals(a, {0, 0, 0, 1, 5, 6});
     }
 
-    // TRANSITION, too simple
     using gt = greater<int>;
     {
-        flat_set<int, gt, C> a{0, 5};
-        assert_all_requirements_and_equals(a, {5, 0});
-        a.insert(a.begin(), 3);
-        assert_all_requirements_and_equals(a, {5, 3, 0});
-        a.insert(a.end(), 4);
-        assert_all_requirements_and_equals(a, {5, 4, 3, 0});
+        flat_set<int, gt, C> a{5, 7, 9};
+        assert_all_requirements_and_equals(a, {9, 7, 5});
+        a.emplace_hint(a.end());
+        assert_all_requirements_and_equals(a, {9, 7, 5, 0});
+        a.emplace_hint(a.begin() + 1, 8);
+        assert_all_requirements_and_equals(a, {9, 8, 7, 5, 0});
+        a.insert(a.begin() + 3, 6);
+        assert_all_requirements_and_equals(a, {9, 8, 7, 6, 5, 0});
+        a.insert(a.end() - 1, val);
+        assert_all_requirements_and_equals(a, {9, 8, 7, 6, 5, 1, 0});
+    }
+    {
+        flat_multiset<int, gt, C> a{3, 1, 4, 1, 5, 9};
+        assert_all_requirements_and_equals(a, {9, 5, 4, 3, 1, 1});
+        a.emplace_hint(a.end());
+        assert_all_requirements_and_equals(a, {9, 5, 4, 3, 1, 1, 0});
+        a.emplace_hint(a.begin() + 2, 4);
+        assert_all_requirements_and_equals(a, {9, 5, 4, 4, 3, 1, 1, 0});
+        a.insert(a.begin() + 1, 6);
+        assert_all_requirements_and_equals(a, {9, 6, 5, 4, 4, 3, 1, 1, 0});
+        a.insert(a.end() - 3, val);
+        assert_all_requirements_and_equals(a, {9, 6, 5, 4, 4, 3, 1, 1, 1, 0});
     }
 }
 

From ca727a3c5d5ca6c03e5cfadad61d28459d43941c Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 27 Jan 2026 03:14:03 -0800
Subject: [PATCH 11/25] Extract identical key_comparer to
 test_container_requirements.hpp.

---
 .../std/include/test_container_requirements.hpp  | 16 ++++++++++++++++
 tests/std/tests/P0429R9_flat_map/test.cpp        | 16 ----------------
 tests/std/tests/P1222R4_flat_set/test.cpp        | 16 ----------------
 3 files changed, 16 insertions(+), 32 deletions(-)

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index cebe64d3ab1..664b88e7eaf 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -187,3 +187,19 @@ void assert_three_way_comparability() {
         static_assert(std::three_way_comparable<T>);
     }
 }
+
+struct key_comparer {
+    const auto& extract_key(const auto& obj) const {
+        if constexpr (requires { obj.key; }) {
+            return obj.key;
+        } else {
+            return obj;
+        }
+    }
+
+    bool operator()(const auto& lhs, const auto& rhs) const {
+        return extract_key(lhs) < extract_key(rhs);
+    }
+
+    using is_transparent = int;
+};
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index fbd797b28be..0ded4ac821e 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -233,22 +233,6 @@ struct MyAllocatorCounter {
     size_t activeAllocations;
 };
 
-struct key_comparer {
-    const auto& extract_key(const auto& obj) const {
-        if constexpr (requires { obj.key; }) {
-            return obj.key;
-        } else {
-            return obj;
-        }
-    }
-
-    bool operator()(const auto& lhs, const auto& rhs) const {
-        return extract_key(lhs) < extract_key(rhs);
-    }
-
-    using is_transparent = int;
-};
-
 template <template <class...> class KeyCont, template <class...> class MappedCont>
 void test_construction() {
     // Using CTAD, the given MyAllocator is only used by the container when the constructor (deduction guide)
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 756b806c92f..27df78feacd 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -509,22 +509,6 @@ void test_insert_hint_is_respected() {
     }
 }
 
-struct key_comparer {
-    const auto& extract_key(const auto& obj) const {
-        if constexpr (requires { obj.key; }) {
-            return obj.key;
-        } else {
-            return obj;
-        }
-    }
-
-    bool operator()(const auto& lhs, const auto& rhs) const {
-        return extract_key(lhs) < extract_key(rhs);
-    }
-
-    using is_transparent = int;
-};
-
 void test_comparer_application() {
     // The set must rely on its comparer to do the comparisons.
     struct incomparable {

From 70d7b39630d3a689d281f57e58a79417a2323d5e Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 27 Jan 2026 03:15:03 -0800
Subject: [PATCH 12/25] `key_comparer::extract_key()` can be private and
 static.

---
 tests/std/include/test_container_requirements.hpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index 664b88e7eaf..82879d06de8 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -188,8 +188,9 @@ void assert_three_way_comparability() {
     }
 }
 
-struct key_comparer {
-    const auto& extract_key(const auto& obj) const {
+class key_comparer {
+private:
+    static const auto& extract_key(const auto& obj) {
         if constexpr (requires { obj.key; }) {
             return obj.key;
         } else {
@@ -197,6 +198,7 @@ struct key_comparer {
         }
     }
 
+public:
     bool operator()(const auto& lhs, const auto& rhs) const {
         return extract_key(lhs) < extract_key(rhs);
     }

From ac56e1dac65187542dc26ac7b39491290022e9c2 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 27 Jan 2026 03:17:37 -0800
Subject: [PATCH 13/25] comparer => comparator

---
 .../include/test_container_requirements.hpp   |  2 +-
 tests/std/tests/P0429R9_flat_map/test.cpp     |  2 +-
 tests/std/tests/P1222R4_flat_set/test.cpp     | 28 +++++++++----------
 3 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index 82879d06de8..be234339777 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -188,7 +188,7 @@ void assert_three_way_comparability() {
     }
 }
 
-class key_comparer {
+class key_comparator {
 private:
     static const auto& extract_key(const auto& obj) {
         if constexpr (requires { obj.key; }) {
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index 0ded4ac821e..f2d8d9a9b0e 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -1172,7 +1172,7 @@ void test_map_operations_transparent() {
         }
     };
 
-    Map<int, char, key_comparer> fm{{0, 'a'}, {3, 'g'}, {5, 't'}};
+    Map<int, char, key_comparator> fm{{0, 'a'}, {3, 'g'}, {5, 't'}};
     assert(check_key_content(fm, {0, 3, 5}));
     assert(check_value_content(fm, {'a', 'g', 't'}));
 
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 27df78feacd..05282a2be4a 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -509,15 +509,15 @@ void test_insert_hint_is_respected() {
     }
 }
 
-void test_comparer_application() {
-    // The set must rely on its comparer to do the comparisons.
+void test_comparator_application() {
+    // The set must rely on its comparator to do the comparisons.
     struct incomparable {
         int key;
         bool operator<(const incomparable&) const  = delete;
         bool operator==(const incomparable&) const = delete;
     };
 
-    flat_set<incomparable, key_comparer> fs{{0}, {3}, {1}, {0}, {5}};
+    flat_set<incomparable, key_comparator> fs{{0}, {3}, {1}, {0}, {5}};
     assert(fs.contains(0));
     assert(!fs.contains(2));
     fs.insert(fs.begin(), incomparable{4});
@@ -543,7 +543,7 @@ void test_insert_transparent() {
         }
     };
 
-    flat_set<int, key_comparer> fs{0, 3, 5};
+    flat_set<int, key_comparator> fs{0, 3, 5};
     assert_all_requirements_and_equals(fs, {0, 3, 5});
     detect_conversion detector{3};
 
@@ -628,13 +628,13 @@ void test_insert_upper_bound() {
         extra = e++;
     }
 
-    flat_multiset<test_position, key_comparer> fs;
+    flat_multiset<test_position, key_comparator> fs;
     for (const auto& val : seq) {
         fs.insert(val);
     }
 
     // The result should be identical to as if doing stable_sort on seq.
-    ranges::stable_sort(seq, key_comparer{});
+    ranges::stable_sort(seq, key_comparator{});
     assert(ranges::equal(fs, seq));
 }
 
@@ -659,7 +659,7 @@ void test_spaceship_operator() {
 }
 
 template <class T>
-struct proxy_comparer {
+struct proxy_comparator {
     bool operator()(const T& lhs, const T& rhs) const {
         return m_less ? (lhs < rhs) : (lhs > rhs);
     }
@@ -667,10 +667,10 @@ struct proxy_comparer {
     bool m_less = true;
 };
 
-void test_non_static_comparer() {
-    flat_set<int, proxy_comparer<int>> a{3, 2, 2, 1};
+void test_non_static_comparator() {
+    flat_set<int, proxy_comparator<int>> a{3, 2, 2, 1};
     assert_all_requirements_and_equals(a, {1, 2, 3});
-    auto b = flat_set<int, proxy_comparer<int>>({-1, 5, 9, 9, 9, 9, 9}, proxy_comparer<int>{.m_less = false});
+    auto b = flat_set<int, proxy_comparator<int>>({-1, 5, 9, 9, 9, 9, 9}, proxy_comparator<int>{.m_less = false});
     assert_all_requirements_and_equals(b, {9, 5, -1});
 
     auto aBackup = a;
@@ -840,7 +840,7 @@ void test_invariant_robustness() {
         }
     };
 
-    using SetT = flat_set<odd_key, key_comparer, odd_container>;
+    using SetT = flat_set<odd_key, key_comparator, odd_container>;
 
     // copy-assignment
     {
@@ -1104,7 +1104,7 @@ void test_set_operations_transparent() {
         }
     };
 
-    Set<int, key_comparer> fs{0, 3, 5};
+    Set<int, key_comparator> fs{0, 3, 5};
     assert_all_requirements_and_equals(fs, {0, 3, 5});
 
     assert(fs.find(shouldnt_convert{0}) != fs.end());
@@ -1275,7 +1275,7 @@ void run_normal_tests() {
     test_insert_2<deque<int>>();
     test_insert_hint_is_respected<vector<int>>();
     test_insert_hint_is_respected<deque<int>>();
-    test_comparer_application();
+    test_comparator_application();
     test_insert_transparent();
     test_insert_using_invalid_hint();
     test_insert_upper_bound();
@@ -1289,7 +1289,7 @@ void run_normal_tests() {
     test_spaceship_operator<flat_set<int, greater<int>, deque<int>>>();
     test_spaceship_operator<flat_multiset<int, greater<int>, deque<int>>>();
 
-    test_non_static_comparer();
+    test_non_static_comparator();
 
     test_extract_1<flat_set>();
     test_extract_1<flat_multiset>();

From a236a74622cb78c88bfe927e315d992673910fb6 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 27 Jan 2026 03:18:22 -0800
Subject: [PATCH 14/25] Pre-existing/unrelated: comparer => comparator

---
 .../test.compile.pass.cpp                      | 18 +++++++++---------
 .../test.compile.pass.cpp                      | 12 ++++++------
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/tests/std/tests/Dev11_0437519_container_requirements/test.compile.pass.cpp b/tests/std/tests/Dev11_0437519_container_requirements/test.compile.pass.cpp
index 4cfa84a262e..d391f30b16c 100644
--- a/tests/std/tests/Dev11_0437519_container_requirements/test.compile.pass.cpp
+++ b/tests/std/tests/Dev11_0437519_container_requirements/test.compile.pass.cpp
@@ -13,7 +13,7 @@
 // A brief overview of the contents of this file:
 //
 // The first 650 lines or so of this file (everything up to the first use of DEFINE_TEST) are test
-// utilities:  stub allocators, comparers, and other kinds of types with which we can instantiate
+// utilities:  stub allocators, comparators, and other kinds of types with which we can instantiate
 // containers; test types that define a restricted set of operations; and a set of container traits
 // classes that unify the interfaces for the containers so we can use a common set of tests for
 // them (these traits also define a few useful properties for each container so we know what to
@@ -1678,7 +1678,7 @@ NOT_SUPPORTED_SPECIALIZATION(test_ordered_associative_typedefs_for_maps, tag_mul
 NOT_SUPPORTED_SPECIALIZATION(test_ordered_associative_typedefs_for_maps, tag_set);
 
 
-DEFINE_TEST(test_ordered_associative_default_constructor_with_comparer,
+DEFINE_TEST(test_ordered_associative_default_constructor_with_comparator,
 {
     // X(c) and X a(c);
     // Requires:  key_compare is CopyConstructible
@@ -1710,13 +1710,13 @@ DEFINE_TEST(test_ordered_associative_default_constructor_with_comparer,
 });
 
 
-DEFINE_TEST(test_ordered_associative_range_constructor_with_comparer, {
+DEFINE_TEST(test_ordered_associative_range_constructor_with_comparator, {
     // SPEC:  These are the only two operations for which traits are specified for key_compare, but
     // there are many other operations for which key_compare must meet other requirements (e.g. a
     // call to a.key_comp() necessitates that the key_comp type is move constructible.
     //
-    // In the rest of the tests, I have assumed std::less for the comparer, which meets any possible
-    // requirements, but it should be considered whether the comparer requirements should be more
+    // In the rest of the tests, I have assumed std::less for the comparator, which meets any possible
+    // requirements, but it should be considered whether the comparator requirements should be more
     // thoroughly specified.
 
     std::move_iterator<input_iterator<typename Traits::emplace_argument_type>> i;
@@ -1746,7 +1746,7 @@ DEFINE_TEST(test_ordered_associative_initializer_list_assign, {
 });
 
 
-DEFINE_TEST(test_ordered_associative_comparers, {
+DEFINE_TEST(test_ordered_associative_comparators, {
     // a.key_comp()
     // [No Requires clause]
     c_of_erasable const a;
@@ -1926,10 +1926,10 @@ struct check_all_ordered_associative_requirements {
     check_all_ordered_associative_requirements() {
         test_ordered_associative_typedefs<Tag>();
         test_ordered_associative_typedefs_for_maps<Tag>();
-        test_ordered_associative_default_constructor_with_comparer<Tag>();
-        test_ordered_associative_range_constructor_with_comparer<Tag>();
+        test_ordered_associative_default_constructor_with_comparator<Tag>();
+        test_ordered_associative_range_constructor_with_comparator<Tag>();
         test_ordered_associative_initializer_list_assign<Tag>();
-        test_ordered_associative_comparers<Tag>();
+        test_ordered_associative_comparators<Tag>();
         test_ordered_associative_emplace<Tag>();
         test_ordered_associative_insert<Tag>();
         test_ordered_associative_erase<Tag>();
diff --git a/tests/std/tests/VSO_0191296_allocator_construct/test.compile.pass.cpp b/tests/std/tests/VSO_0191296_allocator_construct/test.compile.pass.cpp
index f407db63e9b..e78577b4164 100644
--- a/tests/std/tests/VSO_0191296_allocator_construct/test.compile.pass.cpp
+++ b/tests/std/tests/VSO_0191296_allocator_construct/test.compile.pass.cpp
@@ -994,7 +994,7 @@ struct check_all_optional_sequence_requirements<Tag, false> {};
 //
 //
 
-DEFINE_TEST(test_ordered_associative_default_constructor_with_comparer,
+DEFINE_TEST(test_ordered_associative_default_constructor_with_comparator,
 {
     // X(c) and X a(c);
     // Requires:  key_compare is CopyConstructible
@@ -1022,13 +1022,13 @@ DEFINE_TEST(test_ordered_associative_default_constructor_with_comparer,
 });
 
 
-DEFINE_TEST(test_ordered_associative_range_constructor_with_comparer, {
+DEFINE_TEST(test_ordered_associative_range_constructor_with_comparator, {
     // SPEC:  These are the only two operations for which traits are specified for key_compare, but
     // there are many other operations for which key_compare must meet other requirements (e.g. a
     // call to a.key_comp() necessitates that the key_comp type is move constructible.
     //
-    // In the rest of the tests, I have assumed std::less for the comparer, which meets any possible
-    // requirements, but it should be considered whether the comparer requirements should be more
+    // In the rest of the tests, I have assumed std::less for the comparator, which meets any possible
+    // requirements, but it should be considered whether the comparator requirements should be more
     // thoroughly specified.
 
     std::move_iterator<typename Traits::emplace_argument_type*> i;
@@ -1076,8 +1076,8 @@ DEFINE_TEST(test_ordered_associative_insert, {
 template <container_tag Tag, bool = (container_traits<Tag>::features & c_is_ordered_associative) != 0>
 struct check_all_ordered_associative_requirements {
     check_all_ordered_associative_requirements() {
-        test_ordered_associative_default_constructor_with_comparer<Tag>();
-        test_ordered_associative_range_constructor_with_comparer<Tag>();
+        test_ordered_associative_default_constructor_with_comparator<Tag>();
+        test_ordered_associative_range_constructor_with_comparator<Tag>();
         test_ordered_associative_emplace<Tag>();
         test_ordered_associative_insert<Tag>();
     }

From b17114f034b108bb57acce39ad6d6d8765a3093f Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 27 Jan 2026 03:26:19 -0800
Subject: [PATCH 15/25] Prefer range-for with `auto&` / `const auto&`.

---
 tests/std/tests/P1222R4_flat_set/test.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 05282a2be4a..a98d9bb3fa4 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -580,14 +580,14 @@ void test_insert_using_invalid_hint() {
     uniform_int_distribution<int> dist_seq(0, 20);
 
     vector<int> seq(200);
-    for (int& val : seq) {
+    for (auto& val : seq) {
         val = dist_seq(eng);
     }
 
     {
         flat_multiset<int> with_hint;
         flat_multiset<int> no_hint;
-        for (const int val : seq) {
+        for (const auto& val : seq) {
             uniform_int_distribution<int> dist_idx(0, static_cast<int>(with_hint.size()));
             auto random_hint = with_hint.begin() + dist_idx(eng);
             with_hint.insert(random_hint, val);
@@ -600,7 +600,7 @@ void test_insert_using_invalid_hint() {
     {
         flat_set<int> with_hint;
         flat_set<int> no_hint;
-        for (const int val : seq) {
+        for (const auto& val : seq) {
             uniform_int_distribution<int> dist_idx(0, static_cast<int>(with_hint.size()));
             auto random_hint = with_hint.begin() + dist_idx(eng);
             with_hint.insert(random_hint, val);

From 4fa9c4e88106c19f7b225feb382daf524b9629ac Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 27 Jan 2026 03:28:39 -0800
Subject: [PATCH 16/25] Reduce `dist_seq`'s scope to avoid confusion with
 `dist_idx`.

---
 tests/std/tests/P1222R4_flat_set/test.cpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index a98d9bb3fa4..24836f9d37d 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -577,11 +577,13 @@ void test_insert_transparent() {
 void test_insert_using_invalid_hint() {
     mt19937 eng(42);
 
-    uniform_int_distribution<int> dist_seq(0, 20);
-
     vector<int> seq(200);
-    for (auto& val : seq) {
-        val = dist_seq(eng);
+
+    {
+        uniform_int_distribution<int> dist_seq(0, 20);
+        for (auto& val : seq) {
+            val = dist_seq(eng);
+        }
     }
 
     {

From 1bfdf81f34068d48bb9ce74c633f2d9b9d56da04 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 27 Jan 2026 03:38:20 -0800
Subject: [PATCH 17/25] Extract the engine, prefer `mt19937_64`.

---
 tests/std/tests/P1222R4_flat_set/test.cpp | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 24836f9d37d..8be4d1bc320 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -574,9 +574,7 @@ void test_insert_transparent() {
     assert(detector.converted);
 }
 
-void test_insert_using_invalid_hint() {
-    mt19937 eng(42);
-
+void test_insert_using_invalid_hint(mt19937_64& eng) {
     vector<int> seq(200);
 
     {
@@ -613,7 +611,7 @@ void test_insert_using_invalid_hint() {
     }
 }
 
-void test_insert_upper_bound() {
+void test_insert_upper_bound(mt19937_64& eng) {
     // For flat_multiset's single-element insertion, the key should be inserted before the upper_bound.
     struct test_position {
         int key;
@@ -621,7 +619,6 @@ void test_insert_upper_bound() {
         bool operator==(const test_position&) const = default;
     };
 
-    mt19937 eng(24);
     uniform_int_distribution<int> dist_seq(0, 20);
 
     vector<test_position> seq(200);
@@ -1263,6 +1260,8 @@ void test_non_strict_weak_order_compare() {
 }
 
 void run_normal_tests() {
+    mt19937_64 eng(42);
+
     test_constructors<vector<int>>();
     test_constructors<deque<int>>();
     test_allocator_extended_constructors<iterator_pair_construction::no_allocator>();
@@ -1279,8 +1278,8 @@ void run_normal_tests() {
     test_insert_hint_is_respected<deque<int>>();
     test_comparator_application();
     test_insert_transparent();
-    test_insert_using_invalid_hint();
-    test_insert_upper_bound();
+    test_insert_using_invalid_hint(eng);
+    test_insert_upper_bound(eng);
 
     test_spaceship_operator<flat_set<int>>();
     test_spaceship_operator<flat_multiset<int>>();

From ff9dd750d5fc1104b1b6e9229ac8e23c1cfcb6b6 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 27 Jan 2026 03:43:27 -0800
Subject: [PATCH 18/25] Avoid almost always auto.

---
 tests/std/tests/P1222R4_flat_set/test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 8be4d1bc320..bc2fd38839d 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -669,7 +669,7 @@ struct proxy_comparator {
 void test_non_static_comparator() {
     flat_set<int, proxy_comparator<int>> a{3, 2, 2, 1};
     assert_all_requirements_and_equals(a, {1, 2, 3});
-    auto b = flat_set<int, proxy_comparator<int>>({-1, 5, 9, 9, 9, 9, 9}, proxy_comparator<int>{.m_less = false});
+    flat_set<int, proxy_comparator<int>> b({-1, 5, 9, 9, 9, 9, 9}, proxy_comparator<int>{.m_less = false});
     assert_all_requirements_and_equals(b, {9, 5, -1});
 
     auto aBackup = a;

From d80d7b8471bd5281b0e85a46729b4870f76dbf73 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 27 Jan 2026 04:06:57 -0800
Subject: [PATCH 19/25] Improve comments.

---
 tests/std/tests/P1222R4_flat_set/test.cpp | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index bc2fd38839d..8f2067a8ad3 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -814,15 +814,15 @@ void test_invariant_robustness() {
         using base::base;
         odd_container(const odd_container&) = default;
 
-        // this copy-assignment cannot provide strong-guarantee for `this`:
+        // this copy assignment operator cannot provide the strong guarantee for `this`:
         odd_container& operator=(const odd_container& other) {
             resize(other.size());
             copy(other.begin(), other.end(), begin());
             return *this;
         }
 
-        // this move-ctor cannot provide strong-guarantee for `other`, and even successful, will leave elements of
-        // `other` in moved-from state:
+        // this move ctor cannot provide the strong guarantee for `other`,
+        // and even if it is successful, it will leave the elements of `other` in a moved-from state:
         odd_container(odd_container&& other) {
             reserve(other.size());
             for (auto& e : other) {
@@ -830,8 +830,8 @@ void test_invariant_robustness() {
             }
         }
 
-        // this move-assignment cannot provide strong-guarantee for `this` and `other`, and even successful, will leave
-        // elements of `other` in moved-from state:
+        // this move assignment operator cannot provide the strong guarantee for `this` and `other`,
+        // and even if it is successful, it will leave the elements of `other` in a moved-from state:
         odd_container& operator=(odd_container&& other) {
             resize(other.size());
             move(other.begin(), other.end(), begin());
@@ -841,7 +841,7 @@ void test_invariant_robustness() {
 
     using SetT = flat_set<odd_key, key_comparator, odd_container>;
 
-    // copy-assignment
+    // copy assignment
     {
         copy_limit = unlimited;
         SetT fs1{0, 1, 2, 3, 4};
@@ -861,7 +861,8 @@ void test_invariant_robustness() {
         }
         assert(caught);
     }
-    // move-ctor
+
+    // move ctor
     {
         copy_limit = unlimited;
         SetT fs1{0, 1, 2, 3, 4};
@@ -881,7 +882,8 @@ void test_invariant_robustness() {
         }
         assert(caught);
     }
-    // move-assignment
+
+    // move assignment
     {
         copy_limit = unlimited;
         SetT fs1{0, 1, 2, 3, 4};
@@ -959,7 +961,7 @@ template <class Cont>
 concept can_erase_iterator_holder = requires(Cont c) {
     { c.erase(holder<typename Cont::const_iterator>{c.begin()}) } -> same_as<typename Cont::iterator>;
 };
-// Note that std::less<T> is not transparent, std::less<> and ranges::less are
+// Note that std::less<T> is not transparent, while std::less<> and ranges::less are
 
 namespace detail {
     using C = flat_set<int>;

From e6bedf7924f7e9642eda0be564b9c3a2353f57fc Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 27 Jan 2026 04:07:21 -0800
Subject: [PATCH 20/25] Add const.

---
 tests/std/tests/P1222R4_flat_set/test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 8f2067a8ad3..0236400103e 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -913,7 +913,7 @@ void test_erase_1() {
     flat_set<int> fs{1};
     assert(1 == fs.erase(1));
     assert_all_requirements_and_equals(fs, {});
-    int numbers[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+    const int numbers[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
     fs.insert_range(numbers);
     assert_all_requirements_and_equals(fs, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
     fs.insert_range(numbers);

From a8161a81c7df23d7b28c82ed7ff576e26225ef9e Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 27 Jan 2026 04:16:57 -0800
Subject: [PATCH 21/25] Improve `namespace test_erase_compile_time`.

Rename the namespace to make its purpose clear, and that it doesn't need to match any other detail namespace.

Move the concepts inside.

Move the comment about transparency to where it applies.
---
 tests/std/tests/P1222R4_flat_set/test.cpp | 25 +++++++++++++----------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 0236400103e..4310a634b76 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -953,17 +953,16 @@ void test_erase_2() {
     assert_all_requirements_and_equals(fs, {3});
 }
 
-template <class Cont, class OtherKey>
-concept can_erase_key = requires(Cont c, OtherKey key) {
-    { c.erase(key) } -> same_as<typename Cont::size_type>;
-};
-template <class Cont>
-concept can_erase_iterator_holder = requires(Cont c) {
-    { c.erase(holder<typename Cont::const_iterator>{c.begin()}) } -> same_as<typename Cont::iterator>;
-};
-// Note that std::less<T> is not transparent, while std::less<> and ranges::less are
+namespace test_erase_compile_time {
+    template <class Cont, class OtherKey>
+    concept can_erase_key = requires(Cont c, OtherKey key) {
+        { c.erase(key) } -> same_as<typename Cont::size_type>;
+    };
+    template <class Cont>
+    concept can_erase_iterator_holder = requires(Cont c) {
+        { c.erase(holder<typename Cont::const_iterator>{c.begin()}) } -> same_as<typename Cont::iterator>;
+    };
 
-namespace detail {
     using C = flat_set<int>;
     static_assert(same_as<C::iterator, decltype(declval<C>().erase(declval<C::iterator>()))>);
     static_assert(same_as<C::iterator, decltype(declval<C>().erase(declval<holder<C::iterator>>()))>);
@@ -973,19 +972,23 @@ namespace detail {
     static_assert(same_as<C::size_type, decltype(declval<C>().erase(declval<holder<int>>()))>);
     static_assert(same_as<C::size_type, decltype(declval<C>().erase(declval<int>()))>);
 
+    // Note that std::less<T> is not transparent, while std::less<> and ranges::less are
+
     // erase key_type
     static_assert(can_erase_key<flat_set<int, less<int>>, int>);
     static_assert(can_erase_key<flat_set<int, less<>>, int>);
     static_assert(can_erase_key<flat_set<int, ranges::less>, int>);
+
     // erase wrapped key_type
     static_assert(!can_erase_key<flat_set<int, less<int>>, holder<int>>);
     static_assert(can_erase_key<flat_set<int, less<>>, holder<int>>);
     static_assert(can_erase_key<flat_set<int, ranges::less>, holder<int>>);
+
     // erase wrapped iterator - the member function template returning size_type must not be selected
     static_assert(can_erase_iterator_holder<flat_set<int, less<int>>>);
     static_assert(can_erase_iterator_holder<flat_set<int, less<>>>);
     static_assert(can_erase_iterator_holder<flat_set<int, ranges::less>>);
-} // namespace detail
+} // namespace test_erase_compile_time
 
 template <class C>
 void test_erase_if() {

From 81c68c0b1d0fcea7fe96ac03d2c96f2c9cea55f0 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 27 Jan 2026 04:23:28 -0800
Subject: [PATCH 22/25] Be more specific about find() results.

---
 tests/std/tests/P1222R4_flat_set/test.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 4310a634b76..f5281e9cd95 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -1048,7 +1048,7 @@ void test_set_operations() {
         // flat_set:
         assert_all_requirements_and_equals(fs, {2, 3, 8, 11, 20});
 
-        assert(fs.find(3) != fs.end());
+        assert(fs.find(3) == fs.begin() + 1);
         assert(fs.find(4) == fs.end());
 
         assert(fs.count(1) == 0);
@@ -1074,7 +1074,7 @@ void test_set_operations() {
         // flat_multiset:
         assert_all_requirements_and_equals(fs, {2, 3, 3, 8, 11, 11, 11, 20});
 
-        assert(fs.find(3) != fs.end());
+        assert(fs.find(3) == fs.begin() + 1);
         assert(fs.find(4) == fs.end());
 
         assert(fs.count(1) == 0);
@@ -1111,7 +1111,7 @@ void test_set_operations_transparent() {
     Set<int, key_comparator> fs{0, 3, 5};
     assert_all_requirements_and_equals(fs, {0, 3, 5});
 
-    assert(fs.find(shouldnt_convert{0}) != fs.end());
+    assert(fs.find(shouldnt_convert{0}) == fs.begin());
     assert(fs.count(shouldnt_convert{3}) == 1);
     assert(!fs.contains(shouldnt_convert{1}));
     assert(fs.lower_bound(shouldnt_convert{-1}) == fs.begin());
@@ -1236,7 +1236,7 @@ void test_non_strict_weak_order_compare() {
         assert(first == cont.begin());
         assert(last == cont.begin() + 2);
 
-        assert(cont.end() != cont.find(strange_int{1}));
+        assert(cont.begin() + 2 == cont.find(strange_int{1}));
         assert(cont.end() == cont.find(strange_int{3}));
 
         assert(2 == cont.erase(strange_int{0}));
@@ -1256,7 +1256,7 @@ void test_non_strict_weak_order_compare() {
         assert(first == cont.begin());
         assert(last == cont.begin() + 2);
 
-        assert(cont.end() != cont.find(strange_int{1}));
+        assert(cont.begin() + 2 == cont.find(strange_int{1}));
         assert(cont.end() == cont.find(strange_int{3}));
 
         assert(2 == cont.erase(strange_int{0}));

From 2a8e67cc7ff2ce5788ec93ca502701dad0d04547 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 27 Jan 2026 04:33:49 -0800
Subject: [PATCH 23/25] Test const overloads of transparent operations.

---
 tests/std/tests/P1222R4_flat_set/test.cpp | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index f5281e9cd95..453810db722 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -1117,8 +1117,17 @@ void test_set_operations_transparent() {
     assert(fs.lower_bound(shouldnt_convert{-1}) == fs.begin());
     assert(fs.lower_bound(shouldnt_convert{8}) == fs.end());
     assert(fs.upper_bound(shouldnt_convert{2}) == fs.find(3));
-    auto [first, last] = fs.equal_range(shouldnt_convert{5});
-    assert(first + 1 == last);
+    assert(fs.equal_range(shouldnt_convert{5}) == (pair{fs.begin() + 2, fs.end()}));
+
+    // Also test const overloads:
+    const auto& cfs = fs;
+    assert(cfs.find(shouldnt_convert{0}) == cfs.begin());
+    assert(cfs.count(shouldnt_convert{3}) == 1);
+    assert(!cfs.contains(shouldnt_convert{1}));
+    assert(cfs.lower_bound(shouldnt_convert{-1}) == cfs.begin());
+    assert(cfs.lower_bound(shouldnt_convert{8}) == cfs.end());
+    assert(cfs.upper_bound(shouldnt_convert{2}) == cfs.find(3));
+    assert(cfs.equal_range(shouldnt_convert{5}) == (pair{cfs.begin() + 2, cfs.end()}));
 }
 
 namespace test_throwing_swap {

From df268268c52f5a192c97979f4233a1ee24e6bedb Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 27 Jan 2026 04:53:00 -0800
Subject: [PATCH 24/25] De-templatize the "duplicates" tests, they're always
 exercising the unique case.

---
 tests/std/tests/P0429R9_flat_map/test.cpp | 63 +++++++++--------------
 tests/std/tests/P1222R4_flat_set/test.cpp | 61 +++++++++-------------
 2 files changed, 49 insertions(+), 75 deletions(-)

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index f2d8d9a9b0e..54ac624422c 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -1495,61 +1495,48 @@ void test_death_insert_unsorted_initializer_list() {
     cont.insert(sorted, {{137, 'a'}, {42, 'g'}, {3337, 'f'}, {15, 'r'}});
 }
 
-template <cont_type type>
 void test_death_construct_duplicates_initializer_list() {
-    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    C cont(sorted, {{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}});
+    using C = flat_map<int, char>;
+    C cont(sorted_unique, {{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}});
 }
 
-template <cont_type type>
 void test_death_construct_duplicates_iter_iter() {
-    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    vector<typename C::value_type> values{{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}};
-    C cont(sorted, values.begin(), values.end());
+    using C = flat_map<int, char>;
+    vector<C::value_type> values{{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}};
+    C cont(sorted_unique, values.begin(), values.end());
 }
 
-template <cont_type type>
 void test_death_construct_duplicates_container() {
-    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    typename C::key_container_type keys{42, 137, 137, 3337};
-    typename C::mapped_container_type mapped{'a', 'g', 'f', 'r'};
-    C cont(sorted, keys, mapped);
+    using C = flat_map<int, char>;
+    C::key_container_type keys{42, 137, 137, 3337};
+    C::mapped_container_type mapped{'a', 'g', 'f', 'r'};
+    C cont(sorted_unique, keys, mapped);
 }
 
-template <cont_type type>
 void test_death_replace_duplicates_container() {
-    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    using C = flat_map<int, char>;
     C cont;
     cont.replace({42, 137, 137, 3337}, {'a', 'g', 'f', 'r'});
 }
 
-template <cont_type type>
 void test_death_insert_duplicates_iter_iter() {
-    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    vector<typename C::value_type> values{{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}};
+    using C = flat_map<int, char>;
+    vector<C::value_type> values{{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}};
     C cont;
-    cont.insert(sorted, values.begin(), values.end());
+    cont.insert(sorted_unique, values.begin(), values.end());
 }
 
-template <cont_type type>
 void test_death_insert_duplicates_range() {
-    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    vector<typename C::value_type> values{{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}};
+    using C = flat_map<int, char>;
+    vector<C::value_type> values{{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}};
     C cont;
-    cont.insert_range(sorted, values);
+    cont.insert_range(sorted_unique, values);
 }
 
-template <cont_type type>
 void test_death_insert_duplicates_initializer_list() {
-    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    using C = flat_map<int, char>;
     C cont;
-    cont.insert(sorted, {{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}});
+    cont.insert(sorted_unique, {{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}});
 }
 
 template <cont_type type>
@@ -1624,13 +1611,13 @@ int main(int argc, char* argv[]) {
         test_death_insert_unsorted_initializer_list<cont_type::multi>,
 
         // Tests shared between flat_set and flat_map - violation of unique elements
-        test_death_construct_duplicates_initializer_list<cont_type::unique>,
-        test_death_construct_duplicates_iter_iter<cont_type::unique>,
-        test_death_construct_duplicates_container<cont_type::unique>,
-        test_death_replace_duplicates_container<cont_type::unique>,
-        test_death_insert_duplicates_iter_iter<cont_type::unique>,
-        test_death_insert_duplicates_range<cont_type::unique>,
-        test_death_insert_duplicates_initializer_list<cont_type::unique>,
+        test_death_construct_duplicates_initializer_list,
+        test_death_construct_duplicates_iter_iter,
+        test_death_construct_duplicates_container,
+        test_death_replace_duplicates_container,
+        test_death_insert_duplicates_iter_iter,
+        test_death_insert_duplicates_range,
+        test_death_insert_duplicates_initializer_list,
 
         // Tests not present in flat_set - mismatch of length of key and mapped containers
         test_death_different_size_ctor<cont_type::unique>,
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 453810db722..df41f20067c 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -1388,60 +1388,47 @@ void test_death_insert_unsorted_initializer_list() {
     cont.insert(sorted, {137, 42, 3337, 15});
 }
 
-template <cont_type type>
 void test_death_construct_duplicates_initializer_list() {
-    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    C cont(sorted, {42, 137, 137, 3337});
+    using C = flat_set<int>;
+    C cont(sorted_unique, {42, 137, 137, 3337});
 }
 
-template <cont_type type>
 void test_death_construct_duplicates_iter_iter() {
-    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    typename C::container_type values{42, 137, 137, 3337};
-    C cont(sorted, values.begin(), values.end());
+    using C = flat_set<int>;
+    C::container_type values{42, 137, 137, 3337};
+    C cont(sorted_unique, values.begin(), values.end());
 }
 
-template <cont_type type>
 void test_death_construct_duplicates_container() {
-    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    typename C::container_type values{42, 137, 137, 3337};
-    C cont(sorted, values);
+    using C = flat_set<int>;
+    C::container_type values{42, 137, 137, 3337};
+    C cont(sorted_unique, values);
 }
 
-template <cont_type type>
 void test_death_replace_duplicates_container() {
-    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
+    using C = flat_set<int>;
     C cont;
     cont.replace({42, 137, 137, 3337});
 }
 
-template <cont_type type>
 void test_death_insert_duplicates_iter_iter() {
-    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    typename C::container_type values{42, 137, 137, 3337};
+    using C = flat_set<int>;
+    C::container_type values{42, 137, 137, 3337};
     C cont;
-    cont.insert(sorted, values.begin(), values.end());
+    cont.insert(sorted_unique, values.begin(), values.end());
 }
 
-template <cont_type type>
 void test_death_insert_duplicates_range() {
-    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    typename C::container_type values{42, 137, 137, 3337};
+    using C = flat_set<int>;
+    C::container_type values{42, 137, 137, 3337};
     C cont;
-    cont.insert_range(sorted, values);
+    cont.insert_range(sorted_unique, values);
 }
 
-template <cont_type type>
 void test_death_insert_duplicates_initializer_list() {
-    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    using C = flat_set<int>;
     C cont;
-    cont.insert(sorted, {42, 137, 137, 3337});
+    cont.insert(sorted_unique, {42, 137, 137, 3337});
 }
 
 int main(int argc, char* argv[]) {
@@ -1467,13 +1454,13 @@ int main(int argc, char* argv[]) {
         test_death_insert_unsorted_initializer_list<cont_type::multi>,
 
         // Tests shared between flat_set and flat_map - violation of unique elements
-        test_death_construct_duplicates_initializer_list<cont_type::unique>,
-        test_death_construct_duplicates_iter_iter<cont_type::unique>,
-        test_death_construct_duplicates_container<cont_type::unique>,
-        test_death_replace_duplicates_container<cont_type::unique>,
-        test_death_insert_duplicates_iter_iter<cont_type::unique>,
-        test_death_insert_duplicates_range<cont_type::unique>,
-        test_death_insert_duplicates_initializer_list<cont_type::unique>,
+        test_death_construct_duplicates_initializer_list,
+        test_death_construct_duplicates_iter_iter,
+        test_death_construct_duplicates_container,
+        test_death_replace_duplicates_container,
+        test_death_insert_duplicates_iter_iter,
+        test_death_insert_duplicates_range,
+        test_death_insert_duplicates_initializer_list,
     });
 #endif // defined(_DEBUG)
 

From 0d2b66c1ba337aec3875aa3a8cf6802473fc8b2f Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Tue, 27 Jan 2026 06:03:11 -0800
Subject: [PATCH 25/25] Add test coverage: iterators, capacity, replace(),
 clear(), equality, non-member swap().

---
 tests/std/tests/P1222R4_flat_set/test.cpp | 73 +++++++++++++++++++++++
 1 file changed, 73 insertions(+)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index df41f20067c..242a27d47ea 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -315,6 +315,48 @@ void test_allocator_extended_constructors() {
     }
 }
 
+template <class T>
+void test_iterators_and_capacity() {
+    T t{11, 22, 33, 44};
+    const T& c = t;
+
+    {
+        const int arr[]{11, 22, 33, 44};
+        assert(equal(t.begin(), t.end(), begin(arr), end(arr)));
+        assert(equal(c.begin(), c.end(), begin(arr), end(arr)));
+        assert(equal(t.cbegin(), t.cend(), begin(arr), end(arr)));
+        assert(equal(c.cbegin(), c.cend(), begin(arr), end(arr)));
+    }
+    {
+        const int rev[]{44, 33, 22, 11};
+        assert(equal(t.rbegin(), t.rend(), begin(rev), end(rev)));
+        assert(equal(c.rbegin(), c.rend(), begin(rev), end(rev)));
+        assert(equal(t.crbegin(), t.crend(), begin(rev), end(rev)));
+        assert(equal(c.crbegin(), c.crend(), begin(rev), end(rev)));
+    }
+
+    {
+        const T zero;
+
+        assert(!t.empty());
+        assert(zero.empty());
+
+        assert(t.size() == 4);
+        assert(zero.size() == 0);
+
+        assert(t.max_size() > 10);
+        assert(zero.max_size() > 10);
+    }
+
+    // Finally, test replace() and clear().
+    typename T::container_type primes{17, 29, 47};
+    t.replace(move(primes));
+    assert(t.size() == 3);
+    assert(*t.begin() == 17);
+    t.clear();
+    assert(t.empty());
+}
+
 template <template <class...> class Set>
 void test_always_reversible() {
     // Test that flat_meow is unconditionally reversible.
@@ -655,6 +697,12 @@ void test_spaceship_operator() {
 
     T f{1, 2, 3, 4};
     assert((f <=> a) == strong_ordering::greater);
+
+    // also test equality
+    assert(f == f);
+    assert(!(f != f));
+    assert(!(f == a));
+    assert(f != a);
 }
 
 template <class T>
@@ -1164,6 +1212,13 @@ void test_throwing_compare_single() {
         assert(ranges::equal(s1, initializer_list<int>{4, 5, 6}));
         assert(ranges::equal(s2, initializer_list<int>{1, 2, 3}));
     }
+    {
+        set_type s1{{1, 2, 3}, comparator{false}};
+        set_type s2{{4, 5, 6}, comparator{false}};
+        swap(s1, s2);
+        assert(ranges::equal(s1, initializer_list<int>{4, 5, 6}));
+        assert(ranges::equal(s2, initializer_list<int>{1, 2, 3}));
+    }
     {
         set_type s1{{1, 2, 3}, comparator{false}};
         set_type s2{{4, 5, 6}, comparator{false}};
@@ -1184,6 +1239,19 @@ void test_throwing_compare_single() {
             assert(false);
         }
     }
+    {
+        set_type s1{{1, 2, 3}, comparator{true}};
+        set_type s2{{4, 5, 6}, comparator{false}};
+        try {
+            swap(s1, s2);
+            assert(false);
+        } catch (const unique_exception&) {
+            assert(s1.empty());
+            assert(s2.empty());
+        } catch (...) {
+            assert(false);
+        }
+    }
     {
         set_type s1{{1, 2, 3}, comparator{true}};
         set_type s2{{4, 5, 6}, comparator{false}};
@@ -1281,6 +1349,11 @@ void run_normal_tests() {
     test_allocator_extended_constructors<iterator_pair_construction::no_allocator>();
     test_allocator_extended_constructors<iterator_pair_construction::with_allocator>();
 
+    test_iterators_and_capacity<flat_set<int>>();
+    test_iterators_and_capacity<flat_multiset<int>>();
+    test_iterators_and_capacity<flat_set<int, less<int>, deque<int>>>();
+    test_iterators_and_capacity<flat_multiset<int, less<int>, deque<int>>>();
+
     test_always_reversible<flat_set>();
     test_always_reversible<flat_multiset>();