From c06daba33b4ad766da571855708e724618bd99c4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Wed, 7 Jan 2026 23:20:54 +0100
Subject: [PATCH 01/48] Test that hints given to `flat_multiset::emplace_hint`
 and `insert` are respected.

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

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 40f7786a12..75fe53b793 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -11,6 +11,7 @@
 #include <functional>
 #include <iostream>
 #include <memory>
+#include <print>
 #include <random>
 #include <ranges>
 #include <tuple>
@@ -493,6 +494,65 @@ 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>;
+
+    {
+        flat_multiset<int, lt, C> a{-1, -1, 1, 1};
+        bool problem_seen                      = false;
+        auto const assert_inserted_at_position = [&a, &problem_seen](
+                                                     const int expected_index, const auto insert_position) {
+            const auto expected_position = a.begin() + expected_index;
+            if (expected_position != insert_position) {
+                println("Wrong insert position: expected {}, actual {}\nContainer after insert {}", expected_index,
+                    insert_position - a.begin(), a);
+                problem_seen = true;
+            }
+        };
+
+        // hint is greater
+        assert_all_requirements_and_equals(a, {-1, -1, 1, 1});
+        assert_inserted_at_position(2, a.insert(a.end(), 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 1, 1});
+        assert_inserted_at_position(3, a.insert(a.find(1), 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 1, 1});
+        assert_inserted_at_position(4, a.insert(a.find(1), 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 1, 1});
+        assert_inserted_at_position(5, a.insert(a.upper_bound(0), 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 0, 1, 1});
+
+        // hint is correct
+        assert_inserted_at_position(5, a.insert(a.upper_bound(0) - 1, 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 0, 0, 1, 1});
+        assert_inserted_at_position(6, a.insert(a.upper_bound(0) - 1, 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 0, 0, 0, 1, 1});
+        assert_inserted_at_position(6, a.insert(a.begin() + 6, 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 0, 0, 0, 0, 1, 1});
+        assert_inserted_at_position(4, a.insert(a.begin() + 4, 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1});
+        assert_inserted_at_position(2, a.insert(a.begin() + 2, 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1});
+        assert_inserted_at_position(2, a.emplace_hint(a.lower_bound(0), 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1});
+
+        // hint is less
+        assert_inserted_at_position(2, a.emplace_hint(a.lower_bound(0) - 1, 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1});
+        assert_inserted_at_position(2, a.insert(a.begin() + 1, 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1});
+        assert_inserted_at_position(2, a.insert(a.begin(), 0));
+        assert_all_requirements_and_equals(a, {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1});
+
+        assert(!problem_seen);
+
+        assert(13 == erase_if(a, [](const auto value) { return value == 0; }));
+        assert_all_requirements_and_equals(a, {-1, -1, 1, 1});
+    }
+}
+
+
 struct key_comparer {
     const auto& extract_key(const auto& obj) const {
         if constexpr (requires { obj.key; }) {
@@ -1167,6 +1227,8 @@ int main() {
     test_insert_1<deque<int>>();
     test_insert_2<vector<int>>();
     test_insert_2<deque<int>>();
+    test_insert_hint_is_respected<vector<int>>();
+    test_insert_hint_is_respected<deque<int>>();
     test_insert_transparent();
     test_insert_using_invalid_hint();
     test_insert_upper_bound();

From 08f6af53f4625f8a903a0622c99d7c28bbbeda6e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Wed, 7 Jan 2026 23:21:27 +0100
Subject: [PATCH 02/48] Test that hints given to `flat_multimap::emplace_hint`
 and `insert` are respected.

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

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index cc5002dca0..a2db0a691e 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -10,6 +10,7 @@
 #include <flat_map>
 #include <functional>
 #include <memory>
+#include <print>
 #include <ranges>
 #include <type_traits>
 #include <vector>
@@ -72,6 +73,16 @@ bool check_value_content(const T& obj, const typename T::mapped_container_type&
     return ranges::equal(obj.values(), expected);
 }
 
+template <IsFlatMap T>
+bool assert_check_content(const T& obj, const type_identity_t<T>& expected) {
+    if (!ranges::equal(obj, expected)) {
+        println(stderr, "Unexpected content!\nExpected {}", expected);
+        println(stderr, "Actual {}", obj);
+        return false;
+    }
+    return true;
+}
+
 enum class subrange_type : bool {
     equal,
     permutation,
@@ -794,6 +805,71 @@ void test_lookup_call_on_temporaries() {
     }
 }
 
+// Test that hint to emplace/insert is respected, when possible; check returned iterator
+template <template <class...> class KeyC, template <class...> class ValueC>
+void test_insert_hint_is_respected() {
+    using lt = std::less<int>;
+
+    {
+        flat_multimap<int, char, lt, KeyC<int>, ValueC<char>> a{{-1, 'x'}, {-1, 'x'}, {1, 'x'}, {1, 'x'}};
+        bool problem_seen                      = false;
+        auto const assert_inserted_at_position = [&a, &problem_seen](
+                                                     const int expected_index, const auto insert_position) {
+            const auto expected_position = a.begin() + expected_index;
+            if (expected_position != insert_position) {
+                println("Wrong insert position: expected {}, actual {}\nContainer after insert {}", expected_index,
+                    insert_position - a.begin(), a);
+                problem_seen = true;
+            }
+        };
+
+        struct pseudopair {
+            int i;
+            char c;
+
+            operator pair<int, char>() const {
+                return pair{i, c};
+            }
+        };
+
+        pair pair0c{0, 'c'};
+        pair const pair0f{0, 'f'};
+        // hint is greater
+        assert(assert_check_content(a, {{-1, 'x'}, {-1, 'x'}, {1, 'x'}, {1, 'x'}}));
+        assert_inserted_at_position(2, a.emplace_hint(a.end(), 0, 'a'));
+        assert(assert_check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {1, 'x'}, {1, 'x'}}));
+        assert_inserted_at_position(3, a.emplace_hint(a.find(1), pair{0, 'b'}));
+        assert(assert_check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {0, 'b'}, {1, 'x'}, {1, 'x'}}));
+        assert_inserted_at_position(4, a.insert(a.upper_bound(0), std::move(pair0c)));
+        assert(assert_check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {0, 'b'}, {0, 'c'}, {1, 'x'}, {1, 'x'}}));
+        // hint is correct
+        assert_inserted_at_position(4, a.emplace_hint(a.upper_bound(0) - 1, 0, 'd'));
+        assert(assert_check_content(
+            a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {0, 'b'}, {0, 'd'}, {0, 'c'}, {1, 'x'}, {1, 'x'}}));
+        assert_inserted_at_position(3, a.emplace_hint(a.begin() + 3, pseudopair{0, 'e'}));
+        assert(assert_check_content(
+            a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {0, 'e'}, {0, 'b'}, {0, 'd'}, {0, 'c'}, {1, 'x'}, {1, 'x'}}));
+        assert_inserted_at_position(2, a.insert(a.lower_bound(0), pair0f));
+        assert(assert_check_content(
+            a, {{-1, 'x'}, {-1, 'x'}, {0, 'f'}, {0, 'a'}, {0, 'e'}, {0, 'b'}, {0, 'd'}, {0, 'c'}, {1, 'x'}, {1, 'x'}}));
+        // hint is less
+        assert_inserted_at_position(2, a.emplace_hint(a.lower_bound(0) - 1, pair{0, 'g'}));
+        assert(assert_check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'g'}, {0, 'f'}, {0, 'a'}, {0, 'e'}, {0, 'b'},
+                                           {0, 'd'}, {0, 'c'}, {1, 'x'}, {1, 'x'}}));
+        assert_inserted_at_position(2, a.insert(a.begin(), pseudopair{0, 'h'}));
+        assert(assert_check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'h'}, {0, 'g'}, {0, 'f'}, {0, 'a'}, {0, 'e'},
+                                           {0, 'b'}, {0, 'd'}, {0, 'c'}, {1, 'x'}, {1, 'x'}}));
+
+        assert(!problem_seen);
+
+        assert(4 == erase_if(a, [](const auto pair) { return pair.second <= 'd'; }));
+        assert(assert_check_content(
+            a, {{-1, 'x'}, {-1, 'x'}, {0, 'h'}, {0, 'g'}, {0, 'f'}, {0, 'e'}, {1, 'x'}, {1, 'x'}}));
+        assert(4 == a.erase(0));
+        assert(assert_check_content(a, {{-1, 'x'}, {-1, 'x'}, {1, 'x'}, {1, 'x'}}));
+    }
+}
+
 int main() {
     test_construction();
     test_pointer_to_incomplete_type();
@@ -805,4 +881,8 @@ int main() {
     test_comparison();
     test_throwing_compare_swap();
     test_lookup_call_on_temporaries();
+    test_insert_hint_is_respected<vector, vector>();
+    test_insert_hint_is_respected<vector, deque>();
+    test_insert_hint_is_respected<deque, vector>();
+    test_insert_hint_is_respected<deque, deque>();
 }

From e24412d477af6b0681f2c0b4b6bbf918ced31166 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Thu, 8 Jan 2026 00:21:29 +0100
Subject: [PATCH 03/48] Add more tests for flat_set::erase.

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

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 75fe53b793..5c538c9237 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -968,11 +968,24 @@ void test_invariant_robustness() {
     }
 }
 
-// TRANSITION, too simple
 void test_erase_1() {
     flat_set<int> fs{1};
-    fs.erase(1);
+    assert(1 == fs.erase(1));
     assert_all_requirements_and_equals(fs, {});
+    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);
+    assert_all_requirements_and_equals(fs, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
+    assert(0 == fs.erase(-1));
+    assert(0 == fs.erase(10));
+    assert_all_requirements_and_equals(fs, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
+    {
+        const auto iter = fs.erase(fs.begin() + 3, fs.begin() + 6);
+        assert(fs.begin() + 3 == iter);
+        assert(6 == *iter);
+        assert_all_requirements_and_equals(fs, {0, 1, 2, 6, 7, 8, 9});
+    }
 }
 
 template <class T>
@@ -983,6 +996,8 @@ struct holder {
     }
 };
 
+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<>>;
     C fs{0, 1, 2, 3};
@@ -997,6 +1012,40 @@ 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, std::less<> and ranges::less are
+
+using C = flat_set<int>;
+static_assert(same_as<C::iterator, decltype(std::declval<C>().erase(std::declval<C::iterator>()))>);
+static_assert(same_as<C::iterator, decltype(std::declval<C>().erase(std::declval<holder<C::iterator>>()))>);
+static_assert(same_as<C::iterator, decltype(std::declval<C>().erase(std::declval<C::const_iterator>()))>);
+static_assert(same_as<C::iterator, decltype(std::declval<C>().erase(std::declval<holder<C::const_iterator>>()))>);
+static_assert(
+    same_as<C::iterator, decltype(std::declval<C>().erase(std::declval<C::iterator>(), std::declval<C::iterator>()))>);
+static_assert(same_as<C::size_type, decltype(std::declval<C>().erase(std::declval<holder<int>>()))>);
+static_assert(same_as<C::size_type, decltype(std::declval<C>().erase(std::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, _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, _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, _RANGES less>>);
+
+
 template <class C>
 void test_erase_if() {
     constexpr int erased_result[]{1, 3};

From 355c3911203d2ca4340b278cd7694d9e45805fac Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Thu, 8 Jan 2026 14:48:40 +0100
Subject: [PATCH 04/48] Refactor existing flat_map construction tests - use all
 codepaths (including default args).

---
 tests/std/tests/P0429R9_flat_map/test.cpp | 135 +++++++++++++++-------
 1 file changed, 91 insertions(+), 44 deletions(-)

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index a2db0a691e..e0252e7e76 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -213,31 +213,54 @@ struct TransparentPackagedCompare : PackagedCompare<T> {
 
 void test_construction() {
     {
-        flat_map<int, int> fmap;
-        assert(check_requirements(fmap));
-        assert(check_key_content(fmap, {}));
-        assert(check_value_content(fmap, {}));
-        flat_multimap<int, int> fmmap;
-        assert(check_requirements(fmmap));
-        assert(check_key_content(fmmap, {}));
-        assert(check_value_content(fmmap, {}));
+        // Test flat_map() and flat_map(const key_compare&)
+        auto compare = less<int>();
+        {
+            flat_map<int, int> fmap;
+            flat_map<int, int> fmap1(compare);
+
+            assert(check_requirements(fmap));
+            assert(check_key_content(fmap, {}));
+            assert(check_value_content(fmap, {}));
+            assert(fmap == fmap1);
+        }
+        {
+            flat_multimap<int, int> fmmap;
+            flat_multimap<int, int> fmmap1(compare);
+
+            assert(check_requirements(fmmap));
+            assert(check_key_content(fmmap, {}));
+            assert(check_value_content(fmmap, {}));
+            assert(fmmap == fmmap1);
+        }
     }
     {
+        // Test flat_map(key_cont, mapped_cont, comp = key_comp()())
         vector<int> keys = {0, 1, 2, 3, 4, 2};
         vector<int> vals = {44, 2324, 635462, 433, 5, 7};
-        flat_map fmap(keys, vals);
-        assert(check_requirements(fmap));
-        assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
-        assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
-        flat_multimap fmmap(keys, vals);
-        assert(check_requirements(fmmap));
-        assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
-        assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5},
-            {
-                {0, 1, subrange_type::equal},
-                {2, 3, subrange_type::permutation},
-                {4, 5, subrange_type::equal},
-            }));
+        {
+            flat_map fmap(keys, vals);
+            flat_map fmap1(keys, vals, less<int>());
+
+            assert(check_requirements(fmap));
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            flat_multimap fmmap(keys, vals);
+            flat_multimap fmmap1(keys, vals, less<int>());
+
+            assert(check_requirements(fmmap));
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5},
+                {
+                    {0, 1, subrange_type::equal},
+                    {2, 3, subrange_type::permutation},
+                    {4, 5, subrange_type::equal},
+                }));
+            assert(fmmap == fmmap1);
+        }
     }
     {
         vector<int, MyAllocator<int>> keys = {0, 1, 2, 3, 4, 2};
@@ -259,35 +282,59 @@ void test_construction() {
         assert(MyAllocator<int>::getActiveAllocationCount() > activeAllocations);
     }
     {
-        static_assert(is_constructible_v<flat_map<int, int>, sorted_unique_t, vector<int>, vector<int>>);
-        vector<int> keys = {0, 1, 2, 3, 38, 242};
-        vector<int> vals = {44, 2324, 635462, 433, 5, 7};
-        flat_map fmap(sorted_unique, keys, vals);
-        assert(check_requirements(fmap));
-        assert(check_key_content(fmap, {0, 1, 2, 3, 38, 242}));
-        assert(check_value_content(fmap, {44, 2324, 635462, 433, 5, 7}));
-        static_assert(!is_constructible_v<flat_multimap<int, int>, sorted_unique_t, vector<int>, vector<int>>);
+        // Test flat_map(_Sorted_t, key_cont, mapped_cont, comp = key_comp()())
+        {
+            static_assert(is_constructible_v<flat_map<int, int>, sorted_unique_t, vector<int>, vector<int>>);
+            static_assert(!is_constructible_v<flat_multimap<int, int>, sorted_unique_t, vector<int>, vector<int>>);
+            vector<int> keys = {0, 1, 2, 3, 38, 242};
+            vector<int> vals = {44, 2324, 635462, 433, 5, 7};
+
+            flat_map fmap(sorted_unique, keys, vals);
+            flat_map fmap1(sorted_unique, keys, vals, less<int>());
+
+            assert(check_requirements(fmap));
+            assert(check_key_content(fmap, {0, 1, 2, 3, 38, 242}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5, 7}));
+            assert(fmap == fmap1);
+        }
+        {
+            static_assert(!is_constructible_v<flat_map<int, int>, sorted_equivalent_t, vector<int>, vector<int>>);
+            static_assert(is_constructible_v<flat_multimap<int, int>, sorted_equivalent_t, vector<int>, vector<int>>);
+            vector<int> keys = {0, 1, 2, 2, 3, 4};
+            vector<int> vals = {44, 2324, 635462, 7, 433, 5};
+
+            flat_multimap fmmap(sorted_equivalent, keys, vals);
+            flat_multimap fmmap1(sorted_equivalent, keys, vals, less<int>());
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(
+                fmmap, {44, 2324, 635462, 7, 433, 5})); // guaranteed by N4971 [flat.multimap.cons]/6
+            assert(fmmap == fmmap1);
+        }
     }
     {
-        static_assert(!is_constructible_v<flat_map<int, int>, sorted_equivalent_t, vector<int>, vector<int>>);
-        static_assert(is_constructible_v<flat_multimap<int, int>, sorted_equivalent_t, vector<int>, vector<int>>);
-        vector<int, MyAllocator<int>> keys = {0, 1, 2, 2, 3, 4};
-        vector<int, MyAllocator<int>> vals = {44, 2324, 635462, 7, 433, 5};
-        flat_multimap fmmap(sorted_equivalent, keys, vals);
-        assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
-        assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5})); // guaranteed by N4971 [flat.multimap.cons]/6
     }
     // FIXME, test more flat_map and flat_multimap constructors
     {
         PackagedCompare<int> comp;
-        flat_map<Packaged<int>, int, PackagedCompare<int>> fmap(comp);
-        assert(check_requirements(fmap));
-        assert(check_key_content(fmap, {}));
-        assert(check_value_content(fmap, {}));
-        flat_multimap<Packaged<int>, int, PackagedCompare<int>> fmmap(comp);
-        assert(check_requirements(fmmap));
-        assert(check_key_content(fmmap, {}));
-        assert(check_value_content(fmmap, {}));
+        {
+            flat_map<Packaged<int>, int, PackagedCompare<int>> fmap;
+            flat_map<Packaged<int>, int, PackagedCompare<int>> fmap1(comp);
+
+            assert(check_requirements(fmap));
+            assert(check_key_content(fmap, {}));
+            assert(check_value_content(fmap, {}));
+            assert(fmap == fmap1);
+        }
+        {
+            flat_multimap<Packaged<int>, int, PackagedCompare<int>> fmmap;
+            flat_multimap<Packaged<int>, int, PackagedCompare<int>> fmmap1(comp);
+
+            assert(check_requirements(fmmap));
+            assert(check_key_content(fmmap, {}));
+            assert(check_value_content(fmmap, {}));
+            assert(fmmap == fmmap1);
+        }
     }
     {
         PackagedCompare<int> comp;

From ba114e60f2d48f08b4c5975c846b5ddf6c4f2d8c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Thu, 8 Jan 2026 14:49:40 +0100
Subject: [PATCH 05/48] Refactor existing flat_map allocator construction tests
 - add allocation-count-checking helper.

---
 tests/std/tests/P0429R9_flat_map/test.cpp | 56 +++++++++++++++++------
 1 file changed, 41 insertions(+), 15 deletions(-)

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index e0252e7e76..8f9363e6a7 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -211,6 +211,18 @@ struct TransparentPackagedCompare : PackagedCompare<T> {
     }
 };
 
+struct MyAllocatorCounter {
+    MyAllocatorCounter() : activeAllocations{MyAllocator<int>::getActiveAllocationCount()} {}
+
+    bool check_then_reset() {
+        const bool allocated_some = MyAllocator<int>::getActiveAllocationCount() > activeAllocations;
+        activeAllocations         = MyAllocator<int>::getActiveAllocationCount();
+        return allocated_some;
+    }
+
+    size_t activeAllocations;
+};
+
 void test_construction() {
     {
         // Test flat_map() and flat_map(const key_compare&)
@@ -263,23 +275,37 @@ void test_construction() {
         }
     }
     {
+        // Test flat_map(const key_cont&, const mapped_cont&, const key_comp&, const alloc&)
+        // and  flat_map(const key_cont&, const mapped_cont&, const alloc&)
         vector<int, MyAllocator<int>> keys = {0, 1, 2, 3, 4, 2};
         vector<int, MyAllocator<int>> vals = {44, 2324, 635462, 433, 5, 7};
-        size_t activeAllocations           = MyAllocator<int>::getActiveAllocationCount();
-        flat_map fmap(keys, vals, MyAllocator<int>());
-        assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
-        assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
-        assert(MyAllocator<int>::getActiveAllocationCount() > activeAllocations);
-        activeAllocations = MyAllocator<int>::getActiveAllocationCount();
-        flat_multimap fmmap(keys, vals); // FIXME, should use MyAllocator<int>(); deduction guides must be constrained
-        assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
-        assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5},
-            {
-                {0, 1, subrange_type::equal},
-                {2, 3, subrange_type::permutation},
-                {4, 5, subrange_type::equal},
-            }));
-        assert(MyAllocator<int>::getActiveAllocationCount() > activeAllocations);
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_map fmap(keys, vals, MyAllocator<int>());
+            assert(allocation_counter.check_then_reset());
+            flat_map fmap1(keys, vals, less<int>(), MyAllocator<int>());
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_multimap fmmap(keys, vals, MyAllocator<int>());
+            assert(allocation_counter.check_then_reset());
+            flat_multimap fmmap1(keys, vals, less<int>(), MyAllocator<int>());
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5},
+                {
+                    {0, 1, subrange_type::equal},
+                    {2, 3, subrange_type::permutation},
+                    {4, 5, subrange_type::equal},
+                }));
+            assert(fmmap == fmmap1);
+        }
     }
     {
         // Test flat_map(_Sorted_t, key_cont, mapped_cont, comp = key_comp()())

From 439980b4e738308dc729fa3cfdd2eb591a7d56fe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Thu, 8 Jan 2026 14:50:26 +0100
Subject: [PATCH 06/48] Add tests for flat_map construction from (iter, iter),
 initializer_list and Range&&, including allocator ctors.

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

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index 8f9363e6a7..b90c860f8d 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -163,6 +163,32 @@ class MyAllocator : public allocator<T> {
     static inline atomic<size_t> s_allocations{0};
 };
 
+template <class T, class U>
+struct almost_pair {
+    using first_type  = T;
+    using second_type = U;
+
+    T first;
+    U second;
+
+    constexpr operator pair<T, U>() const {
+        return {first, second};
+    }
+};
+
+namespace std {
+    template <class T, class U, size_t N>
+    struct tuple_element<N, almost_pair<T, U>> {
+        using type = conditional_t<N == 1, T, U>;
+    };
+
+    // template<class T, class U>
+    // struct tuple_size<almost_pair<T, U>> {
+    //     using type = conditional_t<N == 1, T, U>;
+    // };
+
+} // namespace std
+
 template <typename T>
 class Packaged {
 private:
@@ -224,6 +250,16 @@ struct MyAllocatorCounter {
 };
 
 void test_construction() {
+    // Using CTAD, the given MyAllocator is only used by the container when the constructor (deduction guide)
+    // directly accepts KeyContainer and MappedContainer or using two deduction guides:
+    //      flat_map(from_range_t, _Rng&&, _Compare, _Allocator)
+    //      flat_map(from_range_t, _Rng&&, _Allocator)
+    // In other cases we have to fully specify template arguments, such as for  flat_map(_Iter, _Iter, _Allocator)
+    using flat_map_my_allocator =
+        flat_map<int, int, less<int>, vector<int, MyAllocator<int>>, vector<int, MyAllocator<int>>>;
+    using flat_multimap_my_allocator =
+        flat_multimap<int, int, less<int>, vector<int, MyAllocator<int>>, vector<int, MyAllocator<int>>>;
+
     {
         // Test flat_map() and flat_map(const key_compare&)
         auto compare = less<int>();
@@ -339,6 +375,301 @@ void test_construction() {
         }
     }
     {
+        // Test flat_map(_Sorted_t, const key_cont&, const mapped_cont&, const key_comp&, const alloc&)
+        // and flat_map(_Sorted_t, const key_cont&, const mapped_cont&, const alloc&)
+        {
+            vector<int, MyAllocator<int>> keys = {0, 1, 2, 3, 4};
+            vector<int, MyAllocator<int>> vals = {44, 2324, 635462, 433, 5};
+
+            MyAllocatorCounter allocation_counter;
+            flat_map fmap(sorted_unique, keys, vals, MyAllocator<int>());
+            assert(allocation_counter.check_then_reset());
+            flat_map fmap1(sorted_unique, keys, vals, less<int>(), MyAllocator<int>());
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            vector<int, MyAllocator<int>> keys = {0, 1, 2, 2, 3, 4};
+            vector<int, MyAllocator<int>> vals = {44, 2324, 635462, 7, 433, 5};
+
+            MyAllocatorCounter allocation_counter;
+            flat_multimap fmmap(sorted_equivalent, keys, vals, MyAllocator<int>());
+            assert(allocation_counter.check_then_reset());
+            flat_multimap fmmap1(sorted_equivalent, keys, vals, less<int>(), MyAllocator<int>());
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5},
+                {
+                    {0, 1, subrange_type::equal},
+                    {2, 3, subrange_type::permutation},
+                    {4, 5, subrange_type::equal},
+                }));
+            assert(fmmap == fmmap1);
+        }
+    }
+    {
+        // Test flat_map(iter, iter, comp = key_compare())
+        almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}};
+
+        {
+            flat_map fmap{ranges::begin(value_types), ranges::end(value_types)};
+            flat_map fmap1{ranges::begin(value_types), ranges::end(value_types), less<int>{}};
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            flat_multimap fmmap{ranges::begin(value_types), ranges::end(value_types)};
+            flat_multimap fmmap1{ranges::begin(value_types), ranges::end(value_types), less<int>{}};
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
+    }
+    {
+        // Test flat_map(iter, iter, const key_comp&, const alloc&)
+        // and  flat_map(iter, iter, const alloc&)
+        almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}};
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_map_my_allocator fmap{ranges::begin(value_types), ranges::end(value_types), MyAllocator<int>()};
+            assert(allocation_counter.check_then_reset());
+            flat_map_my_allocator fmap1{
+                ranges::begin(value_types), ranges::end(value_types), less<int>(), MyAllocator<int>()};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_multimap_my_allocator fmmap{ranges::begin(value_types), ranges::end(value_types), MyAllocator<int>()};
+            assert(allocation_counter.check_then_reset());
+            flat_multimap_my_allocator fmmap1{
+                ranges::begin(value_types), ranges::end(value_types), less<int>(), MyAllocator<int>()};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
+    }
+    {
+        // Test flat_map(from_range_t, _Rng &&, const key_compare&)
+        // and  flat_map(from_range_t, _Rng &&)
+        almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}};
+        {
+            flat_map fmap{from_range, value_types};
+            flat_map fmap1{from_range, value_types, less<int>()};
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+
+        {
+            flat_multimap fmmap{from_range, value_types};
+            flat_multimap fmmap1{from_range, value_types, less<int>()};
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
+    }
+    {
+        // Test flat_map(from_range_t, _Rng &&, const key_compare&, const alloc&)
+        // and  flat_map(from_range_t, _Rng &&, const alloc&)
+        // These constructors with allocators have a corresponding deduction guide -  can rely on CTAD
+        almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}};
+
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_map fmap{from_range, value_types, MyAllocator<int>()};
+            assert(allocation_counter.check_then_reset());
+            flat_map fmap1{from_range, value_types, less<int>(), MyAllocator<int>()};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_multimap fmmap{from_range, value_types, MyAllocator<int>()};
+            assert(allocation_counter.check_then_reset());
+            flat_multimap fmmap1{from_range, value_types, less<int>(), MyAllocator<int>()};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
+    }
+    {
+        // Test flat_map(_Sorted_t, iter, iter, comp = key_comp())
+        {
+            almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {3, 433}, {4, 5}};
+
+            flat_map fmap{sorted_unique, ranges::begin(value_types), ranges::end(value_types)};
+            flat_map fmap1{sorted_unique, ranges::begin(value_types), ranges::end(value_types), less<int>{}};
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}};
+
+            flat_multimap fmmap{sorted_equivalent, ranges::begin(value_types), ranges::end(value_types)};
+            flat_multimap fmmap1{sorted_equivalent, ranges::begin(value_types), ranges::end(value_types), less<int>{}};
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
+    }
+    {
+        // Test flat_map(_Sorted_t, iter, iter, const key_comp&, const alloc&)
+        // and flat_map(_Sorted_t, iter, iter, const alloc&)
+        {
+            almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {3, 433}, {4, 5}};
+
+            MyAllocatorCounter allocation_counter;
+            flat_map_my_allocator fmap{
+                sorted_unique, ranges::begin(value_types), ranges::end(value_types), MyAllocator<int>()};
+            assert(allocation_counter.check_then_reset());
+            flat_map_my_allocator fmap1{
+                sorted_unique, ranges::begin(value_types), ranges::end(value_types), less<int>(), MyAllocator<int>()};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}};
+
+            MyAllocatorCounter allocation_counter;
+            flat_multimap_my_allocator fmmap{
+                sorted_equivalent, ranges::begin(value_types), ranges::end(value_types), MyAllocator<int>()};
+            assert(allocation_counter.check_then_reset());
+            flat_multimap_my_allocator fmmap1{sorted_equivalent, ranges::begin(value_types), ranges::end(value_types),
+                less<int>(), MyAllocator<int>()};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
+    }
+    {
+        // Test flat_map(initializer_list, comp = key_comp())
+        {
+            flat_map fmap{{pair{0, 44}, pair{1, 2324}, pair{2, 635462}, pair{2, 7}, pair{3, 433}, pair{4, 5}}};
+            flat_map fmap1{
+                {pair{0, 44}, pair{1, 2324}, pair{2, 635462}, pair{2, 7}, pair{3, 433}, pair{4, 5}}, less<int>{}};
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            flat_multimap fmmap{{pair{0, 44}, pair{1, 2324}, pair{2, 635462}, pair{2, 7}, pair{3, 433}, pair{4, 5}}};
+            flat_multimap fmmap1{
+                {pair{0, 44}, pair{1, 2324}, pair{2, 635462}, pair{2, 7}, pair{3, 433}, pair{4, 5}}, less<int>{}};
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
+    }
+    {
+        // Test flat_map(initializer_list, const key_comp&, const alloc&)
+        // and  flat_map(initializer_list, const alloc&)
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_map_my_allocator fmap{{{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, MyAllocator<int>()};
+            assert(allocation_counter.check_then_reset());
+            flat_map_my_allocator fmap1{
+                {{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, less<int>(), MyAllocator<int>()};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_multimap_my_allocator fmmap{
+                {{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, MyAllocator<int>()};
+            assert(allocation_counter.check_then_reset());
+            flat_multimap_my_allocator fmmap1{
+                {{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, less<int>(), MyAllocator<int>()};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
+    }
+    {
+        // Test flat_map(_Sorted_t, initializer_list, comp = key_comp())
+        {
+            flat_map fmap{sorted_unique, {pair{0, 44}, pair{1, 2324}, pair{2, 635462}, pair{3, 433}, pair{4, 5}}};
+            flat_map fmap1{
+                sorted_unique, {pair{0, 44}, pair{1, 2324}, pair{2, 635462}, pair{3, 433}, pair{4, 5}}, less<int>{}};
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            flat_multimap fmmap{
+                sorted_equivalent, {pair{0, 44}, pair{1, 2324}, pair{2, 635462}, pair{2, 7}, pair{3, 433}, pair{4, 5}}};
+            flat_multimap fmmap1{sorted_equivalent,
+                {pair{0, 44}, pair{1, 2324}, pair{2, 635462}, pair{2, 7}, pair{3, 433}, pair{4, 5}}, less<int>{}};
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
+    }
+    {
+        // Test flat_map(_Sorted_t, initializer_list, const key_comp&, const alloc&)
+        // and  flat_map(_Sorted_t, initializer_list, const alloc&)
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_map_my_allocator fmap{
+                sorted_unique, {{0, 44}, {1, 2324}, {2, 635462}, {3, 433}, {4, 5}}, MyAllocator<int>()};
+            assert(allocation_counter.check_then_reset());
+            flat_map_my_allocator fmap1{
+                sorted_unique, {{0, 44}, {1, 2324}, {2, 635462}, {3, 433}, {4, 5}}, less<int>(), MyAllocator<int>()};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_multimap_my_allocator fmmap{
+                sorted_equivalent, {{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, MyAllocator<int>()};
+            assert(allocation_counter.check_then_reset());
+            flat_multimap_my_allocator fmmap1{sorted_equivalent,
+                {{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, less<int>(), MyAllocator<int>()};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
     }
     // FIXME, test more flat_map and flat_multimap constructors
     {

From 386b1f4a41e9c66e333a86db271f425a80af9fcd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Thu, 8 Jan 2026 14:50:46 +0100
Subject: [PATCH 07/48] Reword fixme regarding missing flat_map construction
 tests.

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

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index b90c860f8d..58f0b96a04 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -671,7 +671,7 @@ void test_construction() {
             assert(fmmap == fmmap1);
         }
     }
-    // FIXME, test more flat_map and flat_multimap constructors
+    // FIXME, verify that all flat_map and flat_multimap constructors are tested
     {
         PackagedCompare<int> comp;
         {

From 5139e7a95bec5225af4e48763404327710c3d616 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Thu, 8 Jan 2026 15:21:21 +0100
Subject: [PATCH 08/48] Unify checks that flat_map and flat_multimap accept
 their dedicated _Sorted_t

---
 tests/std/tests/P0429R9_flat_map/test.cpp | 88 +++++++++++++----------
 1 file changed, 49 insertions(+), 39 deletions(-)

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index 58f0b96a04..cb423cb6e8 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -249,6 +249,7 @@ struct MyAllocatorCounter {
     size_t activeAllocations;
 };
 
+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)
     // directly accepts KeyContainer and MappedContainer or using two deduction guides:
@@ -256,9 +257,9 @@ void test_construction() {
     //      flat_map(from_range_t, _Rng&&, _Allocator)
     // In other cases we have to fully specify template arguments, such as for  flat_map(_Iter, _Iter, _Allocator)
     using flat_map_my_allocator =
-        flat_map<int, int, less<int>, vector<int, MyAllocator<int>>, vector<int, MyAllocator<int>>>;
+        flat_map<int, int, less<int>, KeyCont<int, MyAllocator<int>>, MappedCont<int, MyAllocator<int>>>;
     using flat_multimap_my_allocator =
-        flat_multimap<int, int, less<int>, vector<int, MyAllocator<int>>, vector<int, MyAllocator<int>>>;
+        flat_multimap<int, int, less<int>, KeyCont<int, MyAllocator<int>>, MappedCont<int, MyAllocator<int>>>;
 
     {
         // Test flat_map() and flat_map(const key_compare&)
@@ -284,8 +285,8 @@ void test_construction() {
     }
     {
         // Test flat_map(key_cont, mapped_cont, comp = key_comp()())
-        vector<int> keys = {0, 1, 2, 3, 4, 2};
-        vector<int> vals = {44, 2324, 635462, 433, 5, 7};
+        KeyCont<int> keys    = {0, 1, 2, 3, 4, 2};
+        MappedCont<int> vals = {44, 2324, 635462, 433, 5, 7};
         {
             flat_map fmap(keys, vals);
             flat_map fmap1(keys, vals, less<int>());
@@ -313,8 +314,8 @@ void test_construction() {
     {
         // Test flat_map(const key_cont&, const mapped_cont&, const key_comp&, const alloc&)
         // and  flat_map(const key_cont&, const mapped_cont&, const alloc&)
-        vector<int, MyAllocator<int>> keys = {0, 1, 2, 3, 4, 2};
-        vector<int, MyAllocator<int>> vals = {44, 2324, 635462, 433, 5, 7};
+        KeyCont<int, MyAllocator<int>> keys    = {0, 1, 2, 3, 4, 2};
+        MappedCont<int, MyAllocator<int>> vals = {44, 2324, 635462, 433, 5, 7};
         {
             MyAllocatorCounter allocation_counter;
             flat_map fmap(keys, vals, MyAllocator<int>());
@@ -346,10 +347,8 @@ void test_construction() {
     {
         // Test flat_map(_Sorted_t, key_cont, mapped_cont, comp = key_comp()())
         {
-            static_assert(is_constructible_v<flat_map<int, int>, sorted_unique_t, vector<int>, vector<int>>);
-            static_assert(!is_constructible_v<flat_multimap<int, int>, sorted_unique_t, vector<int>, vector<int>>);
-            vector<int> keys = {0, 1, 2, 3, 38, 242};
-            vector<int> vals = {44, 2324, 635462, 433, 5, 7};
+            KeyCont<int> keys    = {0, 1, 2, 3, 38, 242};
+            MappedCont<int> vals = {44, 2324, 635462, 433, 5, 7};
 
             flat_map fmap(sorted_unique, keys, vals);
             flat_map fmap1(sorted_unique, keys, vals, less<int>());
@@ -360,10 +359,8 @@ void test_construction() {
             assert(fmap == fmap1);
         }
         {
-            static_assert(!is_constructible_v<flat_map<int, int>, sorted_equivalent_t, vector<int>, vector<int>>);
-            static_assert(is_constructible_v<flat_multimap<int, int>, sorted_equivalent_t, vector<int>, vector<int>>);
-            vector<int> keys = {0, 1, 2, 2, 3, 4};
-            vector<int> vals = {44, 2324, 635462, 7, 433, 5};
+            KeyCont<int> keys    = {0, 1, 2, 2, 3, 4};
+            MappedCont<int> vals = {44, 2324, 635462, 7, 433, 5};
 
             flat_multimap fmmap(sorted_equivalent, keys, vals);
             flat_multimap fmmap1(sorted_equivalent, keys, vals, less<int>());
@@ -373,13 +370,21 @@ void test_construction() {
                 fmmap, {44, 2324, 635462, 7, 433, 5})); // guaranteed by N4971 [flat.multimap.cons]/6
             assert(fmmap == fmmap1);
         }
+        {
+            using non_multi = flat_map<int, int, less<int>, KeyCont<int>, MappedCont<int>>;
+            using multi     = flat_multimap<int, int, less<int>, KeyCont<int>, MappedCont<int>>;
+            static_assert(is_constructible_v<non_multi, sorted_unique_t, KeyCont<int>, MappedCont<int>>);
+            static_assert(!is_constructible_v<multi, sorted_unique_t, KeyCont<int>, MappedCont<int>>);
+            static_assert(!is_constructible_v<non_multi, sorted_equivalent_t, KeyCont<int>, MappedCont<int>>);
+            static_assert(is_constructible_v<multi, sorted_equivalent_t, KeyCont<int>, MappedCont<int>>);
+        }
     }
     {
         // Test flat_map(_Sorted_t, const key_cont&, const mapped_cont&, const key_comp&, const alloc&)
         // and flat_map(_Sorted_t, const key_cont&, const mapped_cont&, const alloc&)
         {
-            vector<int, MyAllocator<int>> keys = {0, 1, 2, 3, 4};
-            vector<int, MyAllocator<int>> vals = {44, 2324, 635462, 433, 5};
+            KeyCont<int, MyAllocator<int>> keys    = {0, 1, 2, 3, 4};
+            MappedCont<int, MyAllocator<int>> vals = {44, 2324, 635462, 433, 5};
 
             MyAllocatorCounter allocation_counter;
             flat_map fmap(sorted_unique, keys, vals, MyAllocator<int>());
@@ -392,8 +397,8 @@ void test_construction() {
             assert(fmap == fmap1);
         }
         {
-            vector<int, MyAllocator<int>> keys = {0, 1, 2, 2, 3, 4};
-            vector<int, MyAllocator<int>> vals = {44, 2324, 635462, 7, 433, 5};
+            KeyCont<int, MyAllocator<int>> keys    = {0, 1, 2, 2, 3, 4};
+            MappedCont<int, MyAllocator<int>> vals = {44, 2324, 635462, 7, 433, 5};
 
             MyAllocatorCounter allocation_counter;
             flat_multimap fmmap(sorted_equivalent, keys, vals, MyAllocator<int>());
@@ -696,14 +701,14 @@ void test_construction() {
     {
         PackagedCompare<int> comp;
         MyAllocator<Packaged<int>> alloc;
-        flat_map<Packaged<int>, Packaged<int>, PackagedCompare<int>, vector<Packaged<int>, MyAllocator<Packaged<int>>>,
-            vector<Packaged<int>, MyAllocator<Packaged<int>>>>
+        flat_map<Packaged<int>, Packaged<int>, PackagedCompare<int>, KeyCont<Packaged<int>, MyAllocator<Packaged<int>>>,
+            MappedCont<Packaged<int>, MyAllocator<Packaged<int>>>>
             fmap(comp, alloc);
         assert(check_requirements(fmap));
         assert(check_key_content(fmap, {}));
         assert(check_value_content(fmap, {}));
         flat_multimap<Packaged<int>, Packaged<int>, PackagedCompare<int>,
-            vector<Packaged<int>, MyAllocator<Packaged<int>>>, vector<Packaged<int>, MyAllocator<Packaged<int>>>>
+            KeyCont<Packaged<int>, MyAllocator<Packaged<int>>>, MappedCont<Packaged<int>, MyAllocator<Packaged<int>>>>
             fmmap(comp, alloc);
         assert(check_requirements(fmmap));
         assert(check_key_content(fmmap, {}));
@@ -711,14 +716,14 @@ void test_construction() {
     }
     {
         MyAllocator<Packaged<int>> alloc;
-        flat_map<Packaged<int>, Packaged<int>, PackagedCompare<int>, vector<Packaged<int>, MyAllocator<Packaged<int>>>,
-            vector<Packaged<int>, MyAllocator<Packaged<int>>>>
+        flat_map<Packaged<int>, Packaged<int>, PackagedCompare<int>, KeyCont<Packaged<int>, MyAllocator<Packaged<int>>>,
+            MappedCont<Packaged<int>, MyAllocator<Packaged<int>>>>
             fmap(alloc);
         assert(check_requirements(fmap));
         assert(check_key_content(fmap, {}));
         assert(check_value_content(fmap, {}));
         flat_multimap<Packaged<int>, Packaged<int>, PackagedCompare<int>,
-            vector<Packaged<int>, MyAllocator<Packaged<int>>>, vector<Packaged<int>, MyAllocator<Packaged<int>>>>
+            KeyCont<Packaged<int>, MyAllocator<Packaged<int>>>, MappedCont<Packaged<int>, MyAllocator<Packaged<int>>>>
             fmmap(alloc);
         assert(check_requirements(fmmap));
         assert(check_key_content(fmmap, {}));
@@ -726,14 +731,14 @@ void test_construction() {
     }
     {
         MyAllocator<Packaged<int>> alloc;
-        flat_map<Packaged<int>, int, PackagedCompare<int>, vector<Packaged<int>, MyAllocator<Packaged<int>>>,
-            vector<int, MyAllocator<int>>>
+        flat_map<Packaged<int>, int, PackagedCompare<int>, KeyCont<Packaged<int>, MyAllocator<Packaged<int>>>,
+            MappedCont<int, MyAllocator<int>>>
             fmap(alloc);
         assert(check_requirements(fmap));
         assert(check_key_content(fmap, {}));
         assert(check_value_content(fmap, {}));
-        flat_multimap<Packaged<int>, int, PackagedCompare<int>, vector<Packaged<int>, MyAllocator<Packaged<int>>>,
-            vector<int, MyAllocator<int>>>
+        flat_multimap<Packaged<int>, int, PackagedCompare<int>, KeyCont<Packaged<int>, MyAllocator<Packaged<int>>>,
+            MappedCont<int, MyAllocator<int>>>
             fmmap(alloc);
         assert(check_requirements(fmmap));
         assert(check_key_content(fmmap, {}));
@@ -742,8 +747,8 @@ void test_construction() {
     {
         PackagedCompare<int> comp;
         MyAllocator<int> alloc;
-        vector<Packaged<int>, MyAllocator<Packaged<int>>> keys = {0, 1, 2, 3, 4, 2};
-        vector<int, MyAllocator<int>> vals                     = {44, 2324, 635462, 433, 5, 7};
+        KeyCont<Packaged<int>, MyAllocator<Packaged<int>>> keys = {0, 1, 2, 3, 4, 2};
+        MappedCont<int, MyAllocator<int>> vals                  = {44, 2324, 635462, 433, 5, 7};
         flat_map fmap(keys, vals, comp, alloc);
         assert(check_requirements(fmap));
         assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
@@ -761,8 +766,8 @@ void test_construction() {
     {
         TransparentPackagedCompare<int> comp;
         MyAllocator<int> alloc;
-        vector<Packaged<int>, MyAllocator<Packaged<int>>> keys = {0, 1, 2, 3, 4, 2};
-        vector<int, MyAllocator<int>> vals                     = {44, 2324, 635462, 433, 5, 7};
+        KeyCont<Packaged<int>, MyAllocator<Packaged<int>>> keys = {0, 1, 2, 3, 4, 2};
+        MappedCont<int, MyAllocator<int>> vals                  = {44, 2324, 635462, 433, 5, 7};
         flat_map fmap(keys, vals, comp, alloc);
         assert(check_requirements(fmap));
         assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
@@ -781,14 +786,14 @@ void test_construction() {
     {
         allocator<int> ator;
 
-        using fm = flat_map<int, int, less<>, vector<int>, vector<int>>;
+        using fm = flat_map<int, int, less<>, KeyCont<int>, MappedCont<int>>;
         fm m0;
         fm m1(m0);
         fm m2(m0, ator);
         fm m3(move(m0));
         fm m4(move(m1), ator);
 
-        using fmm = flat_multimap<int, int, less<>, vector<int>, vector<int>>;
+        using fmm = flat_multimap<int, int, less<>, KeyCont<int>, MappedCont<int>>;
         fmm mm0;
         fmm mm1(mm0);
         fmm mm2(mm0, ator);
@@ -1274,8 +1279,17 @@ void test_insert_hint_is_respected() {
     }
 }
 
+template <template <class...> class KeyCont, template <class...> class MappedCont>
+void test_key_mapped_cont_combinations() {
+    test_construction<KeyCont, MappedCont>();
+    test_insert_hint_is_respected<KeyCont, MappedCont>();
+}
+
 int main() {
-    test_construction();
+    test_key_mapped_cont_combinations<vector, vector>();
+    test_key_mapped_cont_combinations<vector, deque>();
+    test_key_mapped_cont_combinations<deque, vector>();
+    test_key_mapped_cont_combinations<deque, deque>();
     test_pointer_to_incomplete_type();
     test_erase_if();
     test_insert();
@@ -1285,8 +1299,4 @@ int main() {
     test_comparison();
     test_throwing_compare_swap();
     test_lookup_call_on_temporaries();
-    test_insert_hint_is_respected<vector, vector>();
-    test_insert_hint_is_respected<vector, deque>();
-    test_insert_hint_is_respected<deque, vector>();
-    test_insert_hint_is_respected<deque, deque>();
 }

From 21838ca98b02780a0219bb642b9db3557d74ed13 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Thu, 8 Jan 2026 15:22:16 +0100
Subject: [PATCH 09/48] Generalize flat_map erase_if and swap tests for various
 containers.

---
 tests/std/tests/P0429R9_flat_map/test.cpp | 22 ++++++----------------
 1 file changed, 6 insertions(+), 16 deletions(-)

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index cb423cb6e8..b90b277c11 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -802,10 +802,11 @@ void test_construction() {
     }
 }
 
+template <template <class...> class KeyCont, template <class...> class MappedCont>
 void test_erase_if() {
     {
-        vector<int> keys      = {0, 1, 2, 3, 4, 2};
-        vector<int> vals      = {44, 2324, 635462, 433, 5, 7};
+        KeyCont<int> keys     = {0, 1, 2, 3, 4, 2};
+        MappedCont<int> vals  = {44, 2324, 635462, 433, 5, 7};
         auto even_key_odd_val = [](pair<const int&, const int&> p) { return p.first % 2 == 0 && p.second % 2 != 0; };
         flat_map fmap(keys, vals);
         const auto erased_num = erase_if(fmap, even_key_odd_val);
@@ -1179,18 +1180,6 @@ void test_throwing_compare_swap_single() {
     }
 }
 
-void test_throwing_compare_swap() {
-    test_throwing_compare_swap_single<flat_map, vector, vector>();
-    test_throwing_compare_swap_single<flat_map, vector, deque>();
-    test_throwing_compare_swap_single<flat_map, deque, vector>();
-    test_throwing_compare_swap_single<flat_map, deque, deque>();
-
-    test_throwing_compare_swap_single<flat_multimap, vector, vector>();
-    test_throwing_compare_swap_single<flat_multimap, vector, deque>();
-    test_throwing_compare_swap_single<flat_multimap, deque, vector>();
-    test_throwing_compare_swap_single<flat_multimap, deque, deque>();
-}
-
 // Test that changes in GH-5987 did not break calls of lookup member functions by using deducing this.
 template <typename T>
 void test_lookup_call_on_temporaries_single() {
@@ -1283,6 +1272,9 @@ template <template <class...> class KeyCont, template <class...> class MappedCon
 void test_key_mapped_cont_combinations() {
     test_construction<KeyCont, MappedCont>();
     test_insert_hint_is_respected<KeyCont, MappedCont>();
+    test_throwing_compare_swap_single<flat_map, KeyCont, MappedCont>();
+    test_throwing_compare_swap_single<flat_multimap, KeyCont, MappedCont>();
+    test_erase_if<KeyCont, MappedCont>();
 }
 
 int main() {
@@ -1291,12 +1283,10 @@ int main() {
     test_key_mapped_cont_combinations<deque, vector>();
     test_key_mapped_cont_combinations<deque, deque>();
     test_pointer_to_incomplete_type();
-    test_erase_if();
     test_insert();
     test_insert_range();
     test_gh_4344();
     test_insert_or_assign();
     test_comparison();
-    test_throwing_compare_swap();
     test_lookup_call_on_temporaries();
 }

From 8a4dd863ce438bc9a79d3b2c534a3922fa1e7754 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Thu, 8 Jan 2026 15:39:15 +0100
Subject: [PATCH 10/48] Remove explicitly specified template arguments in
 flat_set constructor test to test deduction guides.

---
 tests/std/tests/P1222R4_flat_set/test.cpp | 41 ++++++++++++++++++-----
 1 file changed, 33 insertions(+), 8 deletions(-)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 5c538c9237..399e3e1900 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -266,19 +266,44 @@ void assert_all_requirements_and_equals(const T& s, const initializer_list<typen
     }
 }
 
+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 = std::less<int>;
     using gt = std::greater<int>;
 
-    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>(C{3, 7, 1, 85, 222, 1}), {1, 3, 7, 85, 222});
-    assert_all_requirements_and_equals(flat_multiset<int, lt, C>(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>(C{1, 2, 3, 3}, gt()), {3, 2, 1});
-    assert_all_requirements_and_equals(flat_multiset<int, gt, C>(C{1, 1, 2, 3}, gt()), {3, 2, 1, 1});
-    assert_all_requirements_and_equals(flat_set<int, gt, C>(sorted_unique, C{30000, 200, 1}, gt()), {30000, 200, 1});
-    assert_all_requirements_and_equals(flat_multiset<int, gt, C>(sorted_equivalent, C{3, 3, -1}, gt()), {3, 3, -1});
+    {
+        // Test flat_set()
+        // and  flat_set(const key_compare&)
+        const auto comp = std::less<int>;
+        {
+            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)
+    }
+
+    assert_all_requirements_and_equals(flat_set<int>(C{3, 7, 1, 85, 222, 1}), {1, 3, 7, 85, 222});
+    assert_all_requirements_and_equals(flat_multiset<int>(C{3, 7, 1, 85, 7, 222, 1}), {1, 1, 3, 7, 7, 85, 222});
+    assert_all_requirements_and_equals(flat_set<int>(C{1, 2, 3, 3}, gt()), {3, 2, 1});
+    assert_all_requirements_and_equals(flat_multiset<int>(C{1, 1, 2, 3}, gt()), {3, 2, 1, 1});
+    assert_all_requirements_and_equals(flat_set<int>(sorted_unique, C{30000, 200, 1}, gt()), {30000, 200, 1});
+    assert_all_requirements_and_equals(flat_multiset<int>(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});
     assert_all_requirements_and_equals(flat_set<int, gt, C>(sorted_unique, {30000, 200, 1}, gt()), {30000, 200, 1});

From da13b3094a16a7312442c461ad4cd7afa031996f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 9 Jan 2026 01:36:40 +0100
Subject: [PATCH 11/48] Fix typo

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

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index f2ec5613c4..1542ba7cbf 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -263,7 +263,7 @@ void test_construction() {
 
     {
         // Test flat_map() and flat_map(const key_compare&)
-        auto compare = less<int>();
+        const less<int> compare;
         {
             flat_map<int, int> fmap;
             flat_map<int, int> fmap1(compare);
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 06878768f2..31d0b22971 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -282,7 +282,7 @@ void test_constructors() {
     {
         // Test flat_set()
         // and  flat_set(const key_compare&)
-        const auto comp = std::less<int>;
+        const std::less<int> comp;
         {
             flat_set<int, lt, C> fs;
             flat_set<int, lt, C> fs1(comp);

From 70c9c335660f043d38fbc8910abf09919a3aa9d3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 9 Jan 2026 01:36:54 +0100
Subject: [PATCH 12/48] Test that heterogeneous lookup works with transparent
 comparator that does not satisfy strict_weak_order

---
 tests/std/tests/P0429R9_flat_map/test.cpp | 45 ++++++++++++++++++++---
 tests/std/tests/P1222R4_flat_set/test.cpp | 45 ++++++++++++++++++++---
 2 files changed, 78 insertions(+), 12 deletions(-)

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index 1542ba7cbf..d5dc22e38b 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -1277,6 +1277,7 @@ void test_key_mapped_cont_combinations() {
     test_erase_if<KeyCont, MappedCont>();
 }
 
+// Test heterogeneous lookup and erase operations when the compare object does not satisfy strict_weak_order (GH-5992)
 enum class strange_int {};
 
 // No overload divless::operator()(strange_int, strange_int), does not satisfy std::strict_weak_order
@@ -1299,14 +1300,46 @@ struct divless {
 static_assert(!strict_weak_order<divless, int, strange_int>);
 
 // ranges:: algorithms can't be called with divless compare, as it does not satisfy std::strict_weak_order
-void test_generic_count_gh_5992() {
+void test_non_strict_weak_order_compare() {
     {
-        flat_map<int, int, divless> m{{1, 0}, {2, 0}, {11, 0}, {12, 0}};
-        assert(2 == m.count(strange_int{0}));
+        flat_map<int, int, divless> cont{{1, 0}, {2, 0}, {11, 0}, {12, 0}};
+        assert(2 == cont.count(strange_int{0}));
+
+        assert(cont.contains(strange_int{0}));
+        assert(!cont.contains(strange_int{2}));
+
+        assert(cont.begin() + 2 == cont.lower_bound(strange_int{1}));
+        assert(cont.begin() + 2 == cont.upper_bound(strange_int{0}));
+
+        const auto [first, last] = cont.equal_range(strange_int{0});
+        assert(first == cont.begin());
+        assert(last == cont.begin() + 2);
+
+        assert(cont.end() != cont.find(strange_int{1}));
+        assert(cont.end() == cont.find(strange_int{3}));
+
+        assert(2 == cont.erase(strange_int{0}));
+        assert(assert_check_content(cont, {{11, 0}, {12, 0}}));
     }
     {
-        flat_multimap<int, int, divless> mm{{1, 0}, {2, 0}, {11, 0}, {12, 0}};
-        assert(2 == mm.count(strange_int{0}));
+        flat_multimap<int, int, divless> cont{{1, 0}, {2, 0}, {11, 0}, {12, 0}};
+        assert(2 == cont.count(strange_int{0}));
+
+        assert(cont.contains(strange_int{0}));
+        assert(!cont.contains(strange_int{2}));
+
+        assert(cont.begin() + 2 == cont.lower_bound(strange_int{1}));
+        assert(cont.begin() + 2 == cont.upper_bound(strange_int{0}));
+
+        const auto [first, last] = cont.equal_range(strange_int{0});
+        assert(first == cont.begin());
+        assert(last == cont.begin() + 2);
+
+        assert(cont.end() != cont.find(strange_int{1}));
+        assert(cont.end() == cont.find(strange_int{3}));
+
+        assert(2 == cont.erase(strange_int{0}));
+        assert(assert_check_content(cont, {{11, 0}, {12, 0}}));
     }
 }
 
@@ -1322,5 +1355,5 @@ int main() {
     test_insert_or_assign();
     test_comparison();
     test_lookup_call_on_temporaries();
-    test_generic_count_gh_5992();
+    test_non_strict_weak_order_compare();
 }
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 31d0b22971..45e0a8e850 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -1279,6 +1279,7 @@ void test_throwing_compare_swap() {
     test_throwing_compare_single<flat_multiset, deque>();
 }
 
+// Test heterogeneous lookup and erase operations when the compare object does not satisfy strict_weak_order (GH-5992)
 enum class strange_int {};
 
 // No overload divless::operator()(strange_int, strange_int), does not satisfy std::strict_weak_order
@@ -1301,14 +1302,46 @@ struct divless {
 static_assert(!strict_weak_order<divless, int, strange_int>);
 
 // ranges:: algorithms can't be called with divless compare, as it does not satisfy std::strict_weak_order
-void test_generic_count_gh_5992() {
+void test_non_strict_weak_order_compare() {
     {
-        flat_set<int, divless> s{1, 2, 11, 12};
-        assert(2 == s.count(strange_int{0}));
+        flat_set<int, divless> cont{1, 2, 11, 12};
+        assert(2 == cont.count(strange_int{0}));
+
+        assert(cont.contains(strange_int{0}));
+        assert(!cont.contains(strange_int{2}));
+
+        assert(cont.begin() + 2 == cont.lower_bound(strange_int{1}));
+        assert(cont.begin() + 2 == cont.upper_bound(strange_int{0}));
+
+        const auto [first, last] = cont.equal_range(strange_int{0});
+        assert(first == cont.begin());
+        assert(last == cont.begin() + 2);
+
+        assert(cont.end() != cont.find(strange_int{1}));
+        assert(cont.end() == cont.find(strange_int{3}));
+
+        assert(2 == cont.erase(strange_int{0}));
+        assert_all_requirements_and_equals(cont, {11, 12});
     }
     {
-        flat_multiset<int, divless> ms{1, 2, 11, 12};
-        assert(2 == ms.count(strange_int{0}));
+        flat_multiset<int, divless> cont{1, 2, 11, 12};
+        assert(2 == cont.count(strange_int{0}));
+
+        assert(cont.contains(strange_int{0}));
+        assert(!cont.contains(strange_int{2}));
+
+        assert(cont.begin() + 2 == cont.lower_bound(strange_int{1}));
+        assert(cont.begin() + 2 == cont.upper_bound(strange_int{0}));
+
+        const auto [first, last] = cont.equal_range(strange_int{0});
+        assert(first == cont.begin());
+        assert(last == cont.begin() + 2);
+
+        assert(cont.end() != cont.find(strange_int{1}));
+        assert(cont.end() == cont.find(strange_int{3}));
+
+        assert(2 == cont.erase(strange_int{0}));
+        assert_all_requirements_and_equals(cont, {11, 12});
     }
 }
 
@@ -1364,5 +1397,5 @@ int main() {
     test_set_operations_transparent<flat_multiset>();
 
     test_throwing_compare_swap();
-    test_generic_count_gh_5992();
+    test_non_strict_weak_order_compare();
 }

From f3b064226ed39d4a76c62f9ecefedc92c481c7fe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 9 Jan 2026 03:16:49 +0100
Subject: [PATCH 13/48] Don't optimize heterogeneous  when key is not of
 key_type.

---
 stl/inc/flat_set | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index d860535aae..dd714ed1c5 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -637,7 +637,7 @@ private:
     _NODISCARD size_type _Erase(const _Ty& _Val) {
         _STL_INTERNAL_STATIC_ASSERT(_Transparent<key_compare> || is_same_v<_Ty, _Kty>);
 
-        if constexpr (_IsUnique) {
+        if constexpr (_IsUnique && is_same_v<_Ty, key_type>) { // Optimization restricted due to GH-5992
             const const_iterator _Where = lower_bound(_Val);
             if (_Where != cend() && !_Compare(_Val, *_Where)) {
                 _Mycont.erase(_Where);

From 99d9892664597a02b407149d6e4f2e033ab7207a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 9 Jan 2026 02:38:38 +0100
Subject: [PATCH 14/48] Properly use flat_set deduction guides in tests.

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

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 45e0a8e850..381c939328 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -298,12 +298,12 @@ void test_constructors() {
         // Test flat_set(const container)
     }
 
-    assert_all_requirements_and_equals(flat_set<int>(C{3, 7, 1, 85, 222, 1}), {1, 3, 7, 85, 222});
-    assert_all_requirements_and_equals(flat_multiset<int>(C{3, 7, 1, 85, 7, 222, 1}), {1, 1, 3, 7, 7, 85, 222});
-    assert_all_requirements_and_equals(flat_set<int>(C{1, 2, 3, 3}, gt()), {3, 2, 1});
-    assert_all_requirements_and_equals(flat_multiset<int>(C{1, 1, 2, 3}, gt()), {3, 2, 1, 1});
-    assert_all_requirements_and_equals(flat_set<int>(sorted_unique, C{30000, 200, 1}, gt()), {30000, 200, 1});
-    assert_all_requirements_and_equals(flat_multiset<int>(sorted_equivalent, C{3, 3, -1}, gt()), {3, 3, -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});
+    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});
     assert_all_requirements_and_equals(flat_set<int, gt, C>(sorted_unique, {30000, 200, 1}, gt()), {30000, 200, 1});

From ee5e51023e3f6767e3d6aca1877b2a5165b60c1d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 9 Jan 2026 02:39:22 +0100
Subject: [PATCH 15/48] Reduce scope of previously-global type alias in
 flat_set tests.

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

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 381c939328..affce62952 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -1047,28 +1047,30 @@ concept can_erase_iterator_holder = requires(Cont c) {
 };
 // Note that std::less<T> is not transparent, std::less<> and ranges::less are
 
-using C = flat_set<int>;
-static_assert(same_as<C::iterator, decltype(std::declval<C>().erase(std::declval<C::iterator>()))>);
-static_assert(same_as<C::iterator, decltype(std::declval<C>().erase(std::declval<holder<C::iterator>>()))>);
-static_assert(same_as<C::iterator, decltype(std::declval<C>().erase(std::declval<C::const_iterator>()))>);
-static_assert(same_as<C::iterator, decltype(std::declval<C>().erase(std::declval<holder<C::const_iterator>>()))>);
-static_assert(
-    same_as<C::iterator, decltype(std::declval<C>().erase(std::declval<C::iterator>(), std::declval<C::iterator>()))>);
-static_assert(same_as<C::size_type, decltype(std::declval<C>().erase(std::declval<holder<int>>()))>);
-static_assert(same_as<C::size_type, decltype(std::declval<C>().erase(std::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, _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, _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, _RANGES less>>);
+namespace detail {
+    using C = flat_set<int>;
+    static_assert(same_as<C::iterator, decltype(std::declval<C>().erase(std::declval<C::iterator>()))>);
+    static_assert(same_as<C::iterator, decltype(std::declval<C>().erase(std::declval<holder<C::iterator>>()))>);
+    static_assert(same_as<C::iterator, decltype(std::declval<C>().erase(std::declval<C::const_iterator>()))>);
+    static_assert(same_as<C::iterator, decltype(std::declval<C>().erase(std::declval<holder<C::const_iterator>>()))>);
+    static_assert(same_as<C::iterator,
+        decltype(std::declval<C>().erase(std::declval<C::iterator>(), std::declval<C::iterator>()))>);
+    static_assert(same_as<C::size_type, decltype(std::declval<C>().erase(std::declval<holder<int>>()))>);
+    static_assert(same_as<C::size_type, decltype(std::declval<C>().erase(std::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, _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, _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, _RANGES less>>);
+} // namespace detail
 
 
 template <class C>

From a157e32882ab45ed0bb1939529fcfa167c26e959 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 9 Jan 2026 02:41:33 +0100
Subject: [PATCH 16/48] Add death tests for all asserts in <flat_set>

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

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index affce62952..f5d32cb4c0 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -19,6 +19,7 @@
 #include <utility>
 #include <vector>
 
+#include <test_death.hpp>
 #define TEST_ASSERT(...) assert((__VA_ARGS__))
 
 using namespace std;
@@ -1347,7 +1348,7 @@ void test_non_strict_weak_order_compare() {
     }
 }
 
-int main() {
+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>>>();
@@ -1401,3 +1402,150 @@ int main() {
     test_throwing_compare_swap();
     test_non_strict_weak_order_compare();
 }
+
+enum class cont_type { multi, unique };
+
+template <cont_type type>
+void test_death_construct_unsorted_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, {137, 42, 3337, 15});
+}
+
+template <cont_type type>
+void test_death_construct_unsorted_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{137, 42, 3337, 15};
+    C cont(sorted, values.begin(), values.end());
+}
+
+template <cont_type type>
+void test_death_construct_unsorted_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{137, 42, 3337, 15};
+    C cont(sorted, values);
+}
+
+template <cont_type type>
+void test_death_replace_unsorted_container() {
+    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
+    C cont;
+    cont.replace({137, 42, 3337, 15});
+}
+
+template <cont_type type>
+void test_death_insert_unsorted_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{137, 42, 3337, 15};
+    C cont;
+    cont.insert(sorted, values.begin(), values.end());
+}
+
+template <cont_type type>
+void test_death_insert_unsorted_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{137, 42, 3337, 15};
+    C cont;
+    cont.insert_range(sorted, values);
+}
+
+template <cont_type type>
+void test_death_insert_unsorted_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;
+    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});
+}
+
+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());
+}
+
+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);
+}
+
+template <cont_type type>
+void test_death_replace_duplicates_container() {
+    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<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};
+    C cont;
+    cont.insert(sorted, 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};
+    C cont;
+    cont.insert_range(sorted, 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;
+    C cont;
+    cont.insert(sorted, {42, 137, 137, 3337});
+}
+
+int main(int argc, char* argv[]) {
+    std_testing::death_test_executive exec([] { run_normal_tests(); });
+
+#if defined(_DEBUG)
+    exec.add_death_tests({
+        test_death_construct_unsorted_initializer_list<cont_type::unique>,
+        test_death_construct_unsorted_initializer_list<cont_type::multi>,
+        test_death_construct_unsorted_iter_iter<cont_type::unique>,
+        test_death_construct_unsorted_iter_iter<cont_type::multi>,
+        test_death_construct_unsorted_container<cont_type::unique>,
+        test_death_construct_unsorted_container<cont_type::multi>,
+        test_death_replace_unsorted_container<cont_type::unique>,
+        test_death_replace_unsorted_container<cont_type::multi>,
+        test_death_insert_unsorted_iter_iter<cont_type::unique>,
+        test_death_insert_unsorted_iter_iter<cont_type::multi>,
+        test_death_insert_unsorted_range<cont_type::unique>,
+        test_death_insert_unsorted_range<cont_type::multi>,
+        test_death_insert_unsorted_initializer_list<cont_type::unique>,
+        test_death_insert_unsorted_initializer_list<cont_type::multi>,
+
+        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>,
+    });
+#endif // defined(_DEBUG)
+
+    return exec.run(argc, argv);
+}

From c94b5e2c4674f3e75af95d51a5df4c67c411c8bb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 9 Jan 2026 03:11:29 +0100
Subject: [PATCH 17/48] Add death tests for all asserts in <flat_map>

---
 tests/std/tests/P0429R9_flat_map/test.cpp | 186 +++++++++++++++++++++-
 1 file changed, 185 insertions(+), 1 deletion(-)

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index d5dc22e38b..ef158fb486 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -15,6 +15,7 @@
 #include <type_traits>
 #include <vector>
 
+#include <test_death.hpp>
 using namespace std;
 
 // See GH-5965: Speculative resolution of LWG-3963 "Different flat_(multi)map specializations
@@ -1343,7 +1344,7 @@ void test_non_strict_weak_order_compare() {
     }
 }
 
-int main() {
+void run_normal_tests() {
     test_key_mapped_cont_combinations<vector, vector>();
     test_key_mapped_cont_combinations<vector, deque>();
     test_key_mapped_cont_combinations<deque, vector>();
@@ -1357,3 +1358,186 @@ int main() {
     test_lookup_call_on_temporaries();
     test_non_strict_weak_order_compare();
 }
+
+enum class cont_type { multi, unique };
+
+template <cont_type type>
+void test_death_construct_unsorted_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, {{137, 'a'}, {42, 'g'}, {3337, 'f'}, {15, 'r'}});
+}
+
+template <cont_type type>
+void test_death_construct_unsorted_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{{137, 'a'}, {42, 'g'}, {3337, 'f'}, {15, 'r'}};
+    C cont(sorted, values.begin(), values.end());
+}
+
+template <cont_type type>
+void test_death_construct_unsorted_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{137, 42, 3337, 15};
+    typename C::mapped_container_type mapped{'a', 'g', 'f', 'r'};
+    C cont(sorted, keys, mapped);
+}
+
+template <cont_type type>
+void test_death_replace_unsorted_container() {
+    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    C cont;
+    cont.replace({137, 42, 3337, 15}, {'a', 'g', 'f', 'r'});
+}
+
+template <cont_type type>
+void test_death_insert_unsorted_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{{137, 'a'}, {42, 'g'}, {3337, 'f'}, {15, 'r'}};
+    C cont;
+    cont.insert(sorted, values.begin(), values.end());
+}
+
+template <cont_type type>
+void test_death_insert_unsorted_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{{137, 'a'}, {42, 'g'}, {3337, 'f'}, {15, 'r'}};
+    C cont;
+    cont.insert_range(sorted, values);
+}
+
+template <cont_type type>
+void test_death_insert_unsorted_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;
+    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'}});
+}
+
+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());
+}
+
+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);
+}
+
+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>>;
+    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'}};
+    C cont;
+    cont.insert(sorted, 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'}};
+    C cont;
+    cont.insert_range(sorted, 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;
+    C cont;
+    cont.insert(sorted, {{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}});
+}
+
+template <cont_type type>
+void test_death_different_size_ctor() {
+    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    typename C::key_container_type keys{42, 137, 137, 3337, 0};
+    typename C::mapped_container_type mapped{'a'};
+    C cont(keys, mapped);
+}
+
+template <cont_type type>
+void test_death_different_size_ctor_sorted() {
+    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, 0};
+    typename C::mapped_container_type mapped{'a'};
+    C cont(sorted, keys, mapped);
+}
+
+template <cont_type type>
+void test_death_different_size_replace() {
+    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    C cont;
+    cont.replace({42, 137, 137, 3337, 0}, {'a'});
+}
+
+int main(int argc, char* argv[]) {
+    std_testing::death_test_executive exec([] { run_normal_tests(); });
+
+#if defined(_DEBUG)
+    exec.add_death_tests({
+
+        // Tests shared with flat_set - violation of sorted and unique
+        test_death_construct_unsorted_initializer_list<cont_type::unique>,
+        test_death_construct_unsorted_initializer_list<cont_type::multi>,
+        test_death_construct_unsorted_iter_iter<cont_type::unique>,
+        test_death_construct_unsorted_iter_iter<cont_type::multi>,
+        test_death_construct_unsorted_container<cont_type::unique>,
+        test_death_construct_unsorted_container<cont_type::multi>,
+        test_death_replace_unsorted_container<cont_type::unique>,
+        test_death_replace_unsorted_container<cont_type::multi>,
+        test_death_insert_unsorted_iter_iter<cont_type::unique>,
+        test_death_insert_unsorted_iter_iter<cont_type::multi>,
+        test_death_insert_unsorted_range<cont_type::unique>,
+        test_death_insert_unsorted_range<cont_type::multi>,
+        test_death_insert_unsorted_initializer_list<cont_type::unique>,
+        test_death_insert_unsorted_initializer_list<cont_type::multi>,
+
+        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>,
+
+        // Tests not present in flat_set - mismatch of length of key and mapped containers
+        test_death_different_size_ctor<cont_type::unique>,
+        test_death_different_size_ctor<cont_type::multi>,
+        test_death_different_size_ctor_sorted<cont_type::unique>,
+        test_death_different_size_ctor_sorted<cont_type::multi>,
+        test_death_different_size_replace<cont_type::unique>,
+        test_death_different_size_replace<cont_type::multi>,
+    });
+#endif // defined(_DEBUG)
+
+    return exec.run(argc, argv);
+}

From 3673606473cb484efca3a9e5455899b3c029648c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 9 Jan 2026 14:33:41 +0100
Subject: [PATCH 18/48] Separate death tests into logical groups by what type
 of violation they are testing.

---
 tests/std/tests/P0429R9_flat_map/test.cpp | 3 ++-
 tests/std/tests/P1222R4_flat_set/test.cpp | 3 +++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index ef158fb486..e630c8302a 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -1505,7 +1505,7 @@ int main(int argc, char* argv[]) {
 #if defined(_DEBUG)
     exec.add_death_tests({
 
-        // Tests shared with flat_set - violation of sorted and unique
+        // Tests shared between flat_set and flat_map - violation of sorted elements
         test_death_construct_unsorted_initializer_list<cont_type::unique>,
         test_death_construct_unsorted_initializer_list<cont_type::multi>,
         test_death_construct_unsorted_iter_iter<cont_type::unique>,
@@ -1521,6 +1521,7 @@ int main(int argc, char* argv[]) {
         test_death_insert_unsorted_initializer_list<cont_type::unique>,
         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>,
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index f5d32cb4c0..627e26b07d 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -1522,6 +1522,8 @@ int main(int argc, char* argv[]) {
 
 #if defined(_DEBUG)
     exec.add_death_tests({
+
+        // Tests shared between flat_set and flat_map - violation of sorted elements
         test_death_construct_unsorted_initializer_list<cont_type::unique>,
         test_death_construct_unsorted_initializer_list<cont_type::multi>,
         test_death_construct_unsorted_iter_iter<cont_type::unique>,
@@ -1537,6 +1539,7 @@ int main(int argc, char* argv[]) {
         test_death_insert_unsorted_initializer_list<cont_type::unique>,
         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>,

From 1c1e240753926784f7bf541bbd9ab4a39aecb7d7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 9 Jan 2026 14:45:28 +0100
Subject: [PATCH 19/48] Test that heterogeneous flat_map lookup operations
 don't attempt to convert their argument to key_type

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

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index e630c8302a..074d38ce9b 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -250,6 +250,22 @@ 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)
@@ -1109,6 +1125,29 @@ void test_comparison() {
     }
 }
 
+template <template <class...> class Map>
+void test_map_operations_transparent() {
+    struct shouldnt_convert {
+        int key;
+        /* implicit */ [[noreturn]] operator int() const {
+            abort();
+        }
+    };
+
+    Map<int, char, key_comparer> fm{{0, 'a'}, {3, 'g'}, {5, 't'}};
+    assert(check_key_content(fm, {0, 3, 5}));
+    assert(check_value_content(fm, {'a', 'g', 't'}));
+
+    assert(fm.find(shouldnt_convert{0}) != fm.end());
+    assert(fm.count(shouldnt_convert{3}) == 1);
+    assert(!fm.contains(shouldnt_convert{1}));
+    assert(fm.lower_bound(shouldnt_convert{-1}) == fm.begin());
+    assert(fm.lower_bound(shouldnt_convert{8}) == fm.end());
+    assert(fm.upper_bound(shouldnt_convert{2}) == fm.find(3));
+    auto [first, last] = fm.equal_range(shouldnt_convert{5});
+    assert(first + 1 == last);
+}
+
 namespace test_throwing_swap {
     struct unique_exception {};
 
@@ -1355,6 +1394,10 @@ void run_normal_tests() {
     test_gh_4344();
     test_insert_or_assign();
     test_comparison();
+
+    test_map_operations_transparent<flat_map>();
+    test_map_operations_transparent<flat_multimap>();
+
     test_lookup_call_on_temporaries();
     test_non_strict_weak_order_compare();
 }

From 2ff469aee283935bcb29f538d2e9a395124716fb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 9 Jan 2026 15:18:20 +0100
Subject: [PATCH 20/48] Extract code testing container requirements from
 flat_set test into a shared file.

---
 .../include/test_container_requirements.hpp   | 132 ++++++++++++++++++
 tests/std/tests/P1222R4_flat_set/test.cpp     | 110 +--------------
 2 files changed, 134 insertions(+), 108 deletions(-)
 create mode 100644 tests/std/include/test_container_requirements.hpp

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
new file mode 100644
index 0000000000..167f96b745
--- /dev/null
+++ b/tests/std/include/test_container_requirements.hpp
@@ -0,0 +1,132 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#pragma once
+
+#include <iterator>
+#include <print>
+#include <type_traits>
+
+using namespace std;
+
+// Extracted common functionality from flat_map and flat_set tests.
+// May be extended for other containers if needed
+
+template <class T>
+void assert_container_requirements(const T& s) {
+    T m = s;
+    assert(m == s);
+
+    static_assert(is_same_v<decltype(m = s), T&>);
+    static_assert(is_same_v<decltype(m = std::move(m)), T&>);
+    static_assert(is_same_v<decltype(m.begin()), typename T::iterator>);
+    static_assert(is_same_v<decltype(m.end()), typename T::iterator>);
+    static_assert(is_same_v<decltype(s.cbegin()), typename T::const_iterator>);
+    static_assert(is_same_v<decltype(m.cend()), typename T::const_iterator>);
+    static_assert(is_convertible_v<typename T::iterator, typename T::const_iterator>);
+    static_assert(is_same_v<decltype(m.begin() <=> m.end()), strong_ordering>);
+    static_assert(is_same_v<decltype(s.size()), typename T::size_type>);
+    static_assert(is_same_v<decltype(s.max_size()), typename T::size_type>);
+    static_assert(is_same_v<decltype(*m.begin()), const typename T::value_type&>);
+    static_assert(is_same_v<decltype(*m.cbegin()), const typename T::value_type&>);
+
+    T my_moved = std::move(m);
+    assert(!(my_moved != s));
+
+    T empty{};
+    assert(empty.empty());
+
+    T non_empty = s;
+    empty.swap(non_empty);
+    assert(non_empty.empty());
+    assert(empty == s);
+
+    std::swap(empty, non_empty);
+    assert(empty.empty());
+    assert(non_empty == s);
+
+    assert(s.cbegin() <= s.cend());
+    assert(s.cbegin() < s.cend() || s.empty());
+
+    assert(m.begin() <= m.end());
+    assert(m.begin() < m.end() || m.empty());
+
+    assert(static_cast<typename T::size_type>(s.cend() - s.cbegin()) == s.size());
+}
+
+template <class T>
+void assert_reversible_container_requirements(const T& s) {
+    static_assert(is_same_v<reverse_iterator<typename T::iterator>, typename T::reverse_iterator>);
+    static_assert(is_same_v<reverse_iterator<typename T::const_iterator>, typename T::const_reverse_iterator>);
+    static_assert(is_same_v<decltype(T{}.rbegin()), typename T::reverse_iterator>);
+    static_assert(is_same_v<decltype(T{}.rend()), typename T::reverse_iterator>);
+    static_assert(is_same_v<decltype(s.rbegin()), typename T::const_reverse_iterator>);
+    static_assert(is_same_v<decltype(s.rend()), typename T::const_reverse_iterator>);
+    static_assert(is_same_v<decltype(s.crbegin()), typename T::const_reverse_iterator>);
+    static_assert(is_same_v<decltype(s.crend()), typename T::const_reverse_iterator>);
+    static_assert(is_convertible_v<typename T::reverse_iterator, typename T::const_reverse_iterator>);
+}
+
+template <class T>
+void assert_noexcept_requirements(T& s) {
+    static_assert(noexcept(s.begin()));
+    static_assert(noexcept(s.end()));
+    static_assert(noexcept(s.cbegin()));
+    static_assert(noexcept(s.cend()));
+    static_assert(noexcept(s.rbegin()));
+    static_assert(noexcept(s.rend()));
+    static_assert(noexcept(s.crbegin()));
+    static_assert(noexcept(s.crend()));
+
+    static_assert(noexcept(s.empty()));
+    static_assert(noexcept(s.size()));
+    static_assert(noexcept(s.max_size()));
+
+    if constexpr (!is_const_v<T>) {
+        constexpr bool is_noexcept =
+            is_nothrow_swappable_v<typename T::container_type> && is_nothrow_swappable_v<typename T::key_compare>;
+        static_assert(noexcept(s.swap(s)) == is_noexcept);
+        static_assert(noexcept(ranges::swap(s, s)) == is_noexcept); // using ADL-swap
+        static_assert(noexcept(s.clear()));
+    }
+}
+
+template <bool ExpectedUnique, class T>
+void assert_is_sorted_maybe_unique(const T& s) {
+    const auto val_comp = s.value_comp();
+    auto begin_it       = s.cbegin();
+    const auto end_it   = s.cend();
+
+    // internal check by the container itself
+    assert(s._Is_sorted_and_unique());
+
+    // external check observable by the user
+    assert(is_sorted(begin_it, end_it, val_comp));
+    if constexpr (ExpectedUnique) {
+        if (!s.empty()) {
+            for (auto prev_it = begin_it, it = prev_it + 1; it != end_it; ++prev_it, ++it) {
+                if (!val_comp(*prev_it, *it)) {
+                    println("Container {} is not sorted-maybe-unique", s);
+                    assert(false);
+                }
+            }
+        }
+    }
+}
+
+
+template <class T>
+void assert_set_requirements() {
+    using iterator       = T::iterator;
+    using const_iterator = T::const_iterator;
+    using key_type       = T::key_type;
+    using value_type     = T::value_type;
+
+    static_assert(same_as<std::const_iterator<const_iterator>, const_iterator>);
+    static_assert(is_convertible_v<iterator, const_iterator>);
+
+    // additionally:
+    static_assert(is_same_v<key_type, value_type>);
+    static_assert(same_as<std::const_iterator<iterator>, iterator>);
+    static_assert(is_convertible_v<const_iterator, iterator>);
+}
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 627e26b07d..7d83ba206b 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -19,6 +19,7 @@
 #include <utility>
 #include <vector>
 
+#include <test_container_requirements.hpp>
 #include <test_death.hpp>
 #define TEST_ASSERT(...) assert((__VA_ARGS__))
 
@@ -129,101 +130,6 @@ class alternative_vector : private vector<T, Alloc> { // not allocator-aware, bu
     }
 };
 
-template <class T>
-void assert_container_requirements(const T& s) {
-    T m = s;
-    assert(m == s);
-
-    static_assert(is_same_v<decltype(m = s), T&>);
-    static_assert(is_same_v<decltype(m = std::move(m)), T&>);
-    static_assert(is_same_v<decltype(m.begin()), typename T::iterator>);
-    static_assert(is_same_v<decltype(m.end()), typename T::iterator>);
-    static_assert(is_same_v<decltype(s.cbegin()), typename T::const_iterator>);
-    static_assert(is_same_v<decltype(m.cend()), typename T::const_iterator>);
-    static_assert(is_convertible_v<typename T::iterator, typename T::const_iterator>);
-    static_assert(is_same_v<decltype(m.begin() <=> m.end()), strong_ordering>);
-    static_assert(is_same_v<decltype(s.size()), typename T::size_type>);
-    static_assert(is_same_v<decltype(s.max_size()), typename T::size_type>);
-    static_assert(is_same_v<decltype(*m.begin()), const typename T::value_type&>);
-    static_assert(is_same_v<decltype(*m.cbegin()), const typename T::value_type&>);
-
-    T my_moved = std::move(m);
-    assert(!(my_moved != s));
-
-    T empty{};
-    assert(empty.empty());
-
-    T non_empty = s;
-    empty.swap(non_empty);
-    assert(non_empty.empty());
-    assert(empty == s);
-
-    std::swap(empty, non_empty);
-    assert(empty.empty());
-    assert(non_empty == s);
-
-    assert(s.cbegin() <= s.cend());
-    assert(s.cbegin() < s.cend() || s.empty());
-
-    assert(m.begin() <= m.end());
-    assert(m.begin() < m.end() || m.empty());
-
-    assert(static_cast<typename T::size_type>(s.cend() - s.cbegin()) == s.size());
-}
-
-template <class T>
-void assert_reversible_container_requirements(const T& s) {
-    static_assert(is_same_v<reverse_iterator<typename T::iterator>, typename T::reverse_iterator>);
-    static_assert(is_same_v<reverse_iterator<typename T::const_iterator>, typename T::const_reverse_iterator>);
-    static_assert(is_same_v<decltype(T{}.rbegin()), typename T::reverse_iterator>);
-    static_assert(is_same_v<decltype(T{}.rend()), typename T::reverse_iterator>);
-    static_assert(is_same_v<decltype(s.rbegin()), typename T::const_reverse_iterator>);
-    static_assert(is_same_v<decltype(s.rend()), typename T::const_reverse_iterator>);
-    static_assert(is_same_v<decltype(s.crbegin()), typename T::const_reverse_iterator>);
-    static_assert(is_same_v<decltype(s.crend()), typename T::const_reverse_iterator>);
-    static_assert(is_convertible_v<typename T::reverse_iterator, typename T::const_reverse_iterator>);
-}
-
-template <class T>
-void assert_set_requirements() {
-    using iterator       = T::iterator;
-    using const_iterator = T::const_iterator;
-    using key_type       = T::key_type;
-    using value_type     = T::value_type;
-
-    static_assert(same_as<std::const_iterator<const_iterator>, const_iterator>);
-    static_assert(is_convertible_v<iterator, const_iterator>);
-
-    // additionally:
-    static_assert(is_same_v<key_type, value_type>);
-    static_assert(same_as<std::const_iterator<iterator>, iterator>);
-    static_assert(is_convertible_v<const_iterator, iterator>);
-}
-
-template <class T>
-void assert_noexcept_requirements(T& s) {
-    static_assert(noexcept(s.begin()));
-    static_assert(noexcept(s.end()));
-    static_assert(noexcept(s.cbegin()));
-    static_assert(noexcept(s.cend()));
-    static_assert(noexcept(s.rbegin()));
-    static_assert(noexcept(s.rend()));
-    static_assert(noexcept(s.crbegin()));
-    static_assert(noexcept(s.crend()));
-
-    static_assert(noexcept(s.empty()));
-    static_assert(noexcept(s.size()));
-    static_assert(noexcept(s.max_size()));
-
-    if constexpr (!is_const_v<T>) {
-        constexpr bool is_noexcept =
-            is_nothrow_swappable_v<typename T::container_type> && is_nothrow_swappable_v<typename T::key_compare>;
-        static_assert(noexcept(s.swap(s)) == is_noexcept);
-        static_assert(noexcept(ranges::swap(s, s)) == is_noexcept); // using ADL-swap
-        static_assert(noexcept(s.clear()));
-    }
-}
-
 template <class T>
 void assert_all_requirements(const T& s) {
     assert_container_requirements(s);
@@ -233,19 +139,7 @@ void assert_all_requirements(const T& s) {
     assert_noexcept_requirements(s);
     assert_noexcept_requirements(const_cast<T&>(s));
 
-    auto val_comp = s.value_comp();
-    auto begin_it = s.cbegin();
-    auto end_it   = s.cend();
-    assert(std::is_sorted(begin_it, end_it, val_comp));
-    if constexpr (!_Is_specialization_v<T, flat_multiset>) {
-        if (!s.empty()) {
-            auto it = begin_it;
-            while (++it != end_it) {
-                assert(val_comp(*(it - 1), *it));
-            }
-        }
-    }
-    assert(s._Is_sorted_and_unique());
+    assert_is_sorted_maybe_unique<_Is_specialization_v<T, flat_set>>(s);
 }
 
 template <class T>

From 72a79670cc6dd8a88c324a7aa0a1753983f4483b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 9 Jan 2026 15:33:52 +0100
Subject: [PATCH 21/48] Refactor requirements on flat_map to use checks shared
 with flat_set.

---
 .../include/test_container_requirements.hpp   | 17 ++++++++-
 tests/std/tests/P0429R9_flat_map/test.cpp     | 36 +++++--------------
 tests/std/tests/P1222R4_flat_set/test.cpp     |  1 +
 3 files changed, 26 insertions(+), 28 deletions(-)

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index 167f96b745..14c12f21d1 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <compare>
 #include <iterator>
 #include <print>
 #include <type_traits>
@@ -114,7 +115,6 @@ void assert_is_sorted_maybe_unique(const T& s) {
     }
 }
 
-
 template <class T>
 void assert_set_requirements() {
     using iterator       = T::iterator;
@@ -130,3 +130,18 @@ void assert_set_requirements() {
     static_assert(same_as<std::const_iterator<iterator>, iterator>);
     static_assert(is_convertible_v<const_iterator, iterator>);
 }
+
+template <class T>
+void assert_map_requirements() {
+    using iterator       = T::iterator;
+    using const_iterator = T::const_iterator;
+    using key_type       = T::key_type;
+    using value_type     = T::value_type;
+    using mapped_type    = T::mapped_type;
+
+    static_assert(same_as<std::const_iterator<const_iterator>, const_iterator>);
+    static_assert(is_convertible_v<iterator, const_iterator>);
+
+    // additionally:
+    static_assert(is_same_v<value_type, pair<key_type, mapped_type>>);
+}
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index 074d38ce9b..b3c2ac9b38 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -15,6 +15,7 @@
 #include <type_traits>
 #include <vector>
 
+#include <test_container_requirements.hpp>
 #include <test_death.hpp>
 using namespace std;
 
@@ -33,35 +34,16 @@ concept IsFlatMap =
     is_specialization_v<remove_cvref_t<T>, flat_map> || is_specialization_v<remove_cvref_t<T>, flat_multimap>;
 
 template <IsFlatMap T>
-bool check_container_requirements(T&&) {
-    return true;
-}
-
-template <IsFlatMap T>
-consteval bool check_reversible_container_requirements() {
-    using map_t = remove_cvref_t<T>;
-    return is_same_v<reverse_iterator<typename map_t::iterator>, typename map_t::reverse_iterator>
-        && is_same_v<reverse_iterator<typename map_t::const_iterator>, typename map_t::const_reverse_iterator>
-        && is_same_v<decltype(declval<map_t>().begin()), typename map_t::iterator>
-        && is_same_v<decltype(declval<map_t>().end()), typename map_t::iterator>
-        && is_same_v<decltype(declval<map_t>().cbegin()), typename map_t::const_iterator>
-        && is_same_v<decltype(declval<map_t>().cend()), typename map_t::const_iterator>
-        && is_same_v<decltype(declval<map_t>().rbegin()), typename map_t::reverse_iterator>
-        && is_same_v<decltype(declval<map_t>().rend()), typename map_t::reverse_iterator>
-        && is_same_v<decltype(declval<map_t>().crbegin()), typename map_t::const_reverse_iterator>
-        && is_same_v<decltype(declval<map_t>().crend()), typename map_t::const_reverse_iterator>
-        && is_convertible_v<typename map_t::iterator, typename map_t::const_iterator>
-        && is_convertible_v<typename map_t::reverse_iterator, typename map_t::const_reverse_iterator>;
-}
+void assert_all_requirements(const T& s) {
+    assert_container_requirements(s);
+    assert_reversible_container_requirements(s);
+    static_assert(three_way_comparable<T>);
+    assert_map_requirements<T>();
 
-template <IsFlatMap T>
-constexpr bool check_reversible_container_requirements(T&&) {
-    return check_reversible_container_requirements<T&&>();
-}
+    assert_noexcept_requirements(s);
+    assert_noexcept_requirements(const_cast<T&>(s));
 
-template <IsFlatMap T>
-bool check_requirements(T&& obj) {
-    return check_container_requirements(forward<T>(obj)) && check_reversible_container_requirements(forward<T>(obj));
+    assert_is_sorted_maybe_unique<_Is_specialization_v<T, flat_set>>(s);
 }
 
 template <IsFlatMap T>
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 7d83ba206b..4b65acf648 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -134,6 +134,7 @@ template <class T>
 void assert_all_requirements(const T& s) {
     assert_container_requirements(s);
     assert_reversible_container_requirements(s);
+    static_assert(three_way_comparable<T>);
     assert_set_requirements<T>();
 
     assert_noexcept_requirements(s);

From 652e37b922e9a0c99eb330a854ed5f485b5d2035 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 9 Jan 2026 16:23:00 +0100
Subject: [PATCH 22/48] Improve printing of causes of failing tests for
 containers that don't have printable elements.

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

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index 14c12f21d1..6968191fcd 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -106,10 +106,13 @@ void assert_is_sorted_maybe_unique(const T& s) {
     if constexpr (ExpectedUnique) {
         if (!s.empty()) {
             for (auto prev_it = begin_it, it = prev_it + 1; it != end_it; ++prev_it, ++it) {
-                if (!val_comp(*prev_it, *it)) {
-                    println("Container {} is not sorted-maybe-unique", s);
-                    assert(false);
+                const bool val_comp_ok = val_comp(*prev_it, *it);
+                if constexpr (std::formattable<T, char>) {
+                    if (!val_comp_ok) {
+                        std::println("Container {} is not sorted-maybe-unique", s);
+                    }
                 }
+                assert(val_comp_ok);
             }
         }
     }

From d8e6812a8635ebfb57330c2f6c47d65f455f5b63 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 9 Jan 2026 16:23:47 +0100
Subject: [PATCH 23/48] Fix three-way-comparability test

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

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index 6968191fcd..23740f8b7f 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -148,3 +148,11 @@ void assert_map_requirements() {
     // additionally:
     static_assert(is_same_v<value_type, pair<key_type, mapped_type>>);
 }
+
+template <typename T>
+void assert_three_way_comparability() {
+    using value_type = typename T::value_type;
+    if constexpr (std::three_way_comparable<value_type>) {
+        static_assert(std::three_way_comparable<T>);
+    }
+}
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index b3c2ac9b38..cb9dbb23b3 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -37,7 +37,7 @@ template <IsFlatMap T>
 void assert_all_requirements(const T& s) {
     assert_container_requirements(s);
     assert_reversible_container_requirements(s);
-    static_assert(three_way_comparable<T>);
+    assert_three_way_comparability<T>();
     assert_map_requirements<T>();
 
     assert_noexcept_requirements(s);
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 4b65acf648..2783f1edf2 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -134,7 +134,7 @@ template <class T>
 void assert_all_requirements(const T& s) {
     assert_container_requirements(s);
     assert_reversible_container_requirements(s);
-    static_assert(three_way_comparable<T>);
+    assert_three_way_comparability<T>();
     assert_set_requirements<T>();
 
     assert_noexcept_requirements(s);

From 047ee853d0601882d4fafda59f42e49d5f00265a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 9 Jan 2026 16:24:20 +0100
Subject: [PATCH 24/48] Check invariants and requirements of more flat_map
 objects in tests

---
 tests/std/tests/P0429R9_flat_map/test.cpp | 19 ++-----------------
 1 file changed, 2 insertions(+), 17 deletions(-)

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index cb9dbb23b3..9050ab43e9 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -48,6 +48,7 @@ void assert_all_requirements(const T& s) {
 
 template <IsFlatMap T>
 bool check_key_content(const T& obj, const typename T::key_container_type& expected) {
+    assert_all_requirements(obj);
     return ranges::equal(obj.keys(), expected);
 }
 
@@ -58,6 +59,7 @@ bool check_value_content(const T& obj, const typename T::mapped_container_type&
 
 template <IsFlatMap T>
 bool assert_check_content(const T& obj, const type_identity_t<T>& expected) {
+    assert_all_requirements(obj);
     if (!ranges::equal(obj, expected)) {
         println(stderr, "Unexpected content!\nExpected {}", expected);
         println(stderr, "Actual {}", obj);
@@ -267,7 +269,6 @@ void test_construction() {
             flat_map<int, int> fmap;
             flat_map<int, int> fmap1(compare);
 
-            assert(check_requirements(fmap));
             assert(check_key_content(fmap, {}));
             assert(check_value_content(fmap, {}));
             assert(fmap == fmap1);
@@ -276,7 +277,6 @@ void test_construction() {
             flat_multimap<int, int> fmmap;
             flat_multimap<int, int> fmmap1(compare);
 
-            assert(check_requirements(fmmap));
             assert(check_key_content(fmmap, {}));
             assert(check_value_content(fmmap, {}));
             assert(fmmap == fmmap1);
@@ -290,7 +290,6 @@ void test_construction() {
             flat_map fmap(keys, vals);
             flat_map fmap1(keys, vals, less<int>());
 
-            assert(check_requirements(fmap));
             assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
             assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
             assert(fmap == fmap1);
@@ -299,7 +298,6 @@ void test_construction() {
             flat_multimap fmmap(keys, vals);
             flat_multimap fmmap1(keys, vals, less<int>());
 
-            assert(check_requirements(fmmap));
             assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
             assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5},
                 {
@@ -352,7 +350,6 @@ void test_construction() {
             flat_map fmap(sorted_unique, keys, vals);
             flat_map fmap1(sorted_unique, keys, vals, less<int>());
 
-            assert(check_requirements(fmap));
             assert(check_key_content(fmap, {0, 1, 2, 3, 38, 242}));
             assert(check_value_content(fmap, {44, 2324, 635462, 433, 5, 7}));
             assert(fmap == fmap1);
@@ -682,7 +679,6 @@ void test_construction() {
             flat_map<Packaged<int>, int, PackagedCompare<int>> fmap;
             flat_map<Packaged<int>, int, PackagedCompare<int>> fmap1(comp);
 
-            assert(check_requirements(fmap));
             assert(check_key_content(fmap, {}));
             assert(check_value_content(fmap, {}));
             assert(fmap == fmap1);
@@ -691,7 +687,6 @@ void test_construction() {
             flat_multimap<Packaged<int>, int, PackagedCompare<int>> fmmap;
             flat_multimap<Packaged<int>, int, PackagedCompare<int>> fmmap1(comp);
 
-            assert(check_requirements(fmmap));
             assert(check_key_content(fmmap, {}));
             assert(check_value_content(fmmap, {}));
             assert(fmmap == fmmap1);
@@ -703,13 +698,11 @@ void test_construction() {
         flat_map<Packaged<int>, Packaged<int>, PackagedCompare<int>, KeyCont<Packaged<int>, MyAllocator<Packaged<int>>>,
             MappedCont<Packaged<int>, MyAllocator<Packaged<int>>>>
             fmap(comp, alloc);
-        assert(check_requirements(fmap));
         assert(check_key_content(fmap, {}));
         assert(check_value_content(fmap, {}));
         flat_multimap<Packaged<int>, Packaged<int>, PackagedCompare<int>,
             KeyCont<Packaged<int>, MyAllocator<Packaged<int>>>, MappedCont<Packaged<int>, MyAllocator<Packaged<int>>>>
             fmmap(comp, alloc);
-        assert(check_requirements(fmmap));
         assert(check_key_content(fmmap, {}));
         assert(check_value_content(fmmap, {}));
     }
@@ -718,13 +711,11 @@ void test_construction() {
         flat_map<Packaged<int>, Packaged<int>, PackagedCompare<int>, KeyCont<Packaged<int>, MyAllocator<Packaged<int>>>,
             MappedCont<Packaged<int>, MyAllocator<Packaged<int>>>>
             fmap(alloc);
-        assert(check_requirements(fmap));
         assert(check_key_content(fmap, {}));
         assert(check_value_content(fmap, {}));
         flat_multimap<Packaged<int>, Packaged<int>, PackagedCompare<int>,
             KeyCont<Packaged<int>, MyAllocator<Packaged<int>>>, MappedCont<Packaged<int>, MyAllocator<Packaged<int>>>>
             fmmap(alloc);
-        assert(check_requirements(fmmap));
         assert(check_key_content(fmmap, {}));
         assert(check_value_content(fmmap, {}));
     }
@@ -733,13 +724,11 @@ void test_construction() {
         flat_map<Packaged<int>, int, PackagedCompare<int>, KeyCont<Packaged<int>, MyAllocator<Packaged<int>>>,
             MappedCont<int, MyAllocator<int>>>
             fmap(alloc);
-        assert(check_requirements(fmap));
         assert(check_key_content(fmap, {}));
         assert(check_value_content(fmap, {}));
         flat_multimap<Packaged<int>, int, PackagedCompare<int>, KeyCont<Packaged<int>, MyAllocator<Packaged<int>>>,
             MappedCont<int, MyAllocator<int>>>
             fmmap(alloc);
-        assert(check_requirements(fmmap));
         assert(check_key_content(fmmap, {}));
         assert(check_value_content(fmmap, {}));
     }
@@ -749,11 +738,9 @@ void test_construction() {
         KeyCont<Packaged<int>, MyAllocator<Packaged<int>>> keys = {0, 1, 2, 3, 4, 2};
         MappedCont<int, MyAllocator<int>> vals                  = {44, 2324, 635462, 433, 5, 7};
         flat_map fmap(keys, vals, comp, alloc);
-        assert(check_requirements(fmap));
         assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
         assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
         flat_multimap fmmap(keys, vals, comp, alloc);
-        assert(check_requirements(fmmap));
         assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
         assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5},
             {
@@ -768,11 +755,9 @@ void test_construction() {
         KeyCont<Packaged<int>, MyAllocator<Packaged<int>>> keys = {0, 1, 2, 3, 4, 2};
         MappedCont<int, MyAllocator<int>> vals                  = {44, 2324, 635462, 433, 5, 7};
         flat_map fmap(keys, vals, comp, alloc);
-        assert(check_requirements(fmap));
         assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
         assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
         flat_multimap fmmap(keys, vals, comp, alloc);
-        assert(check_requirements(fmmap));
         assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
         assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5},
             {

From 513f799c2c47f39b4ed7d0cba1845b2a1f649f48 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 9 Jan 2026 16:24:49 +0100
Subject: [PATCH 25/48] Remove using namespace std from the shared test header,
 add std:: qualifications

---
 .../include/test_container_requirements.hpp   | 94 ++++++++++++-------
 1 file changed, 59 insertions(+), 35 deletions(-)

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index 23740f8b7f..6618a0bcb1 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -7,8 +7,7 @@
 #include <iterator>
 #include <print>
 #include <type_traits>
-
-using namespace std;
+#include <utility>
 
 // Extracted common functionality from flat_map and flat_set tests.
 // May be extended for other containers if needed
@@ -18,18 +17,18 @@ void assert_container_requirements(const T& s) {
     T m = s;
     assert(m == s);
 
-    static_assert(is_same_v<decltype(m = s), T&>);
-    static_assert(is_same_v<decltype(m = std::move(m)), T&>);
-    static_assert(is_same_v<decltype(m.begin()), typename T::iterator>);
-    static_assert(is_same_v<decltype(m.end()), typename T::iterator>);
-    static_assert(is_same_v<decltype(s.cbegin()), typename T::const_iterator>);
-    static_assert(is_same_v<decltype(m.cend()), typename T::const_iterator>);
-    static_assert(is_convertible_v<typename T::iterator, typename T::const_iterator>);
-    static_assert(is_same_v<decltype(m.begin() <=> m.end()), strong_ordering>);
-    static_assert(is_same_v<decltype(s.size()), typename T::size_type>);
-    static_assert(is_same_v<decltype(s.max_size()), typename T::size_type>);
-    static_assert(is_same_v<decltype(*m.begin()), const typename T::value_type&>);
-    static_assert(is_same_v<decltype(*m.cbegin()), const typename T::value_type&>);
+    static_assert(std::is_same_v<decltype(m = s), T&>);
+    static_assert(std::is_same_v<decltype(m = std::move(m)), T&>);
+    static_assert(std::is_same_v<decltype(m.begin()), typename T::iterator>);
+    static_assert(std::is_same_v<decltype(m.end()), typename T::iterator>);
+    static_assert(std::is_same_v<decltype(s.cbegin()), typename T::const_iterator>);
+    static_assert(std::is_same_v<decltype(m.cend()), typename T::const_iterator>);
+    static_assert(std::is_convertible_v<typename T::iterator, typename T::const_iterator>);
+    static_assert(std::is_same_v<decltype(m.begin() <=> m.end()), std::strong_ordering>);
+    static_assert(std::is_same_v<decltype(s.size()), typename T::size_type>);
+    static_assert(std::is_same_v<decltype(s.max_size()), typename T::size_type>);
+    static_assert(std::is_same_v<decltype(*m.begin()), typename T::reference>);
+    static_assert(std::is_same_v<decltype(*m.cbegin()), typename T::const_reference>);
 
     T my_moved = std::move(m);
     assert(!(my_moved != s));
@@ -57,17 +56,39 @@ void assert_container_requirements(const T& s) {
 
 template <class T>
 void assert_reversible_container_requirements(const T& s) {
-    static_assert(is_same_v<reverse_iterator<typename T::iterator>, typename T::reverse_iterator>);
-    static_assert(is_same_v<reverse_iterator<typename T::const_iterator>, typename T::const_reverse_iterator>);
-    static_assert(is_same_v<decltype(T{}.rbegin()), typename T::reverse_iterator>);
-    static_assert(is_same_v<decltype(T{}.rend()), typename T::reverse_iterator>);
-    static_assert(is_same_v<decltype(s.rbegin()), typename T::const_reverse_iterator>);
-    static_assert(is_same_v<decltype(s.rend()), typename T::const_reverse_iterator>);
-    static_assert(is_same_v<decltype(s.crbegin()), typename T::const_reverse_iterator>);
-    static_assert(is_same_v<decltype(s.crend()), typename T::const_reverse_iterator>);
-    static_assert(is_convertible_v<typename T::reverse_iterator, typename T::const_reverse_iterator>);
+    static_assert(std::is_same_v<std::reverse_iterator<typename T::iterator>, typename T::reverse_iterator>);
+    static_assert(
+        std::is_same_v<std::reverse_iterator<typename T::const_iterator>, typename T::const_reverse_iterator>);
+    static_assert(std::is_same_v<decltype(T{}.rbegin()), typename T::reverse_iterator>);
+    static_assert(std::is_same_v<decltype(T{}.rend()), typename T::reverse_iterator>);
+    static_assert(std::is_same_v<decltype(s.rbegin()), typename T::const_reverse_iterator>);
+    static_assert(std::is_same_v<decltype(s.rend()), typename T::const_reverse_iterator>);
+    static_assert(std::is_same_v<decltype(s.crbegin()), typename T::const_reverse_iterator>);
+    static_assert(std::is_same_v<decltype(s.crend()), typename T::const_reverse_iterator>);
+    static_assert(std::is_convertible_v<typename T::reverse_iterator, typename T::const_reverse_iterator>);
 }
 
+template <typename T>
+concept map_has_nothrow_swappable_containers = requires {
+    typename T::key_container_type;
+    typename T::mapped_container_type;
+    requires std::is_nothrow_swappable_v<typename T::mapped_container_type>;
+    requires std::is_nothrow_swappable_v<typename T::key_container_type>;
+};
+
+template <typename T>
+concept set_has_nothrow_swappable_containers = requires {
+    typename T::container_type;
+    requires std::is_nothrow_swappable_v<typename T::container_type>;
+};
+
+template <typename T>
+concept has_nothrow_swappable_containers =
+    set_has_nothrow_swappable_containers<T> || map_has_nothrow_swappable_containers<T>;
+
+template <typename T>
+struct is_nothrow_swappable {};
+
 template <class T>
 void assert_noexcept_requirements(T& s) {
     static_assert(noexcept(s.begin()));
@@ -83,11 +104,11 @@ void assert_noexcept_requirements(T& s) {
     static_assert(noexcept(s.size()));
     static_assert(noexcept(s.max_size()));
 
-    if constexpr (!is_const_v<T>) {
+    if constexpr (!std::is_const_v<T>) {
         constexpr bool is_noexcept =
-            is_nothrow_swappable_v<typename T::container_type> && is_nothrow_swappable_v<typename T::key_compare>;
+            has_nothrow_swappable_containers<T> && std::is_nothrow_swappable_v<typename T::key_compare>;
         static_assert(noexcept(s.swap(s)) == is_noexcept);
-        static_assert(noexcept(ranges::swap(s, s)) == is_noexcept); // using ADL-swap
+        static_assert(noexcept(std::ranges::swap(s, s)) == is_noexcept); // using ADL-swap
         static_assert(noexcept(s.clear()));
     }
 }
@@ -102,7 +123,7 @@ void assert_is_sorted_maybe_unique(const T& s) {
     assert(s._Is_sorted_and_unique());
 
     // external check observable by the user
-    assert(is_sorted(begin_it, end_it, val_comp));
+    assert(std::is_sorted(begin_it, end_it, val_comp));
     if constexpr (ExpectedUnique) {
         if (!s.empty()) {
             for (auto prev_it = begin_it, it = prev_it + 1; it != end_it; ++prev_it, ++it) {
@@ -125,13 +146,16 @@ void assert_set_requirements() {
     using key_type       = T::key_type;
     using value_type     = T::value_type;
 
-    static_assert(same_as<std::const_iterator<const_iterator>, const_iterator>);
-    static_assert(is_convertible_v<iterator, const_iterator>);
+    static_assert(std::same_as<std::const_iterator<const_iterator>, const_iterator>);
+    static_assert(std::is_convertible_v<iterator, const_iterator>);
 
     // additionally:
-    static_assert(is_same_v<key_type, value_type>);
-    static_assert(same_as<std::const_iterator<iterator>, iterator>);
-    static_assert(is_convertible_v<const_iterator, iterator>);
+    static_assert(std::is_same_v<key_type, value_type>);
+    static_assert(std::same_as<std::const_iterator<iterator>, iterator>);
+    static_assert(std::is_convertible_v<const_iterator, iterator>);
+    static_assert(std::is_same_v<decltype(*std::declval<T>().begin()), const typename T::value_type&>);
+    static_assert(std::is_same_v<typename T::reference, typename T::value_type&>);
+    static_assert(std::is_same_v<typename T::const_reference, const typename T::value_type&>);
 }
 
 template <class T>
@@ -142,11 +166,11 @@ void assert_map_requirements() {
     using value_type     = T::value_type;
     using mapped_type    = T::mapped_type;
 
-    static_assert(same_as<std::const_iterator<const_iterator>, const_iterator>);
-    static_assert(is_convertible_v<iterator, const_iterator>);
+    static_assert(std::same_as<std::const_iterator<const_iterator>, const_iterator>);
+    static_assert(std::is_convertible_v<iterator, const_iterator>);
 
     // additionally:
-    static_assert(is_same_v<value_type, pair<key_type, mapped_type>>);
+    static_assert(std::is_same_v<value_type, std::pair<key_type, mapped_type>>);
 }
 
 template <typename T>

From 65dc3c4c20167699da220d83dd5442245fc2ece9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 9 Jan 2026 16:25:21 +0100
Subject: [PATCH 26/48] Fix typo: Check invariants of correct container.
 Properly compare reference and value_type

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

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index 6618a0bcb1..1be24674af 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -154,7 +154,7 @@ void assert_set_requirements() {
     static_assert(std::same_as<std::const_iterator<iterator>, iterator>);
     static_assert(std::is_convertible_v<const_iterator, iterator>);
     static_assert(std::is_same_v<decltype(*std::declval<T>().begin()), const typename T::value_type&>);
-    static_assert(std::is_same_v<typename T::reference, typename T::value_type&>);
+    static_assert(std::is_same_v<std::remove_cvref_t<typename T::reference>, typename T::value_type>);
     static_assert(std::is_same_v<typename T::const_reference, const typename T::value_type&>);
 }
 
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index 9050ab43e9..c0311583f1 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -43,7 +43,7 @@ void assert_all_requirements(const T& s) {
     assert_noexcept_requirements(s);
     assert_noexcept_requirements(const_cast<T&>(s));
 
-    assert_is_sorted_maybe_unique<_Is_specialization_v<T, flat_set>>(s);
+    assert_is_sorted_maybe_unique<_Is_specialization_v<T, flat_map>>(s);
 }
 
 template <IsFlatMap T>

From c40204028312226eb3e987c31292f942f545db06 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 9 Jan 2026 16:45:48 +0100
Subject: [PATCH 27/48] flat_set::reference should not be mutable. Make it the
 same type as flat_set::const_reference

---
 stl/inc/flat_set | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index dd714ed1c5..533b823e07 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -99,8 +99,8 @@ public:
     using value_type             = _Kty;
     using key_compare            = _Keylt;
     using value_compare          = _Keylt;
-    using reference              = value_type&;
     using const_reference        = const value_type&;
+    using reference              = const_reference;
     using size_type              = _Container::size_type;
     using difference_type        = _Container::difference_type;
     using const_iterator         = _Container::const_iterator;

From 5b14ad24aaa995122606a08262d03cc20dd55955 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 9 Jan 2026 17:32:01 +0100
Subject: [PATCH 28/48] Revert "flat_set::reference should not be mutable. Make
 it the same type as flat_set::const_reference"

This reverts commit c40204028312226eb3e987c31292f942f545db06.
---
 stl/inc/flat_set | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index 533b823e07..dd714ed1c5 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -99,8 +99,8 @@ public:
     using value_type             = _Kty;
     using key_compare            = _Keylt;
     using value_compare          = _Keylt;
+    using reference              = value_type&;
     using const_reference        = const value_type&;
-    using reference              = const_reference;
     using size_type              = _Container::size_type;
     using difference_type        = _Container::difference_type;
     using const_iterator         = _Container::const_iterator;

From 2ab424fde7f53e4df47faf4391d4e9a85d285229 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vojt=C4=9Bch=20Michal?= <vojta.michall@email.cz>
Date: Fri, 9 Jan 2026 17:39:13 +0100
Subject: [PATCH 29/48] Container *begin() may return reference or
 const_reference (as is the case for flat_set).

---
 tests/std/include/test_container_requirements.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index 1be24674af..6f09e2a678 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -27,7 +27,8 @@ void assert_container_requirements(const T& s) {
     static_assert(std::is_same_v<decltype(m.begin() <=> m.end()), std::strong_ordering>);
     static_assert(std::is_same_v<decltype(s.size()), typename T::size_type>);
     static_assert(std::is_same_v<decltype(s.max_size()), typename T::size_type>);
-    static_assert(std::is_same_v<decltype(*m.begin()), typename T::reference>);
+    static_assert(std::is_same_v<decltype(*m.begin()), typename T::reference>
+                  || std::is_same_v<decltype(*m.begin()), typename T::const_reference>);
     static_assert(std::is_same_v<decltype(*m.cbegin()), typename T::const_reference>);
 
     T my_moved = std::move(m);

From e51799eadbfe6577ca4f2b1a87d27cfbdaedbcc5 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Fri, 9 Jan 2026 10:02:08 -0800
Subject: [PATCH 30/48] Improve comments.

---
 tests/std/include/test_container_requirements.hpp | 2 +-
 tests/std/tests/P0429R9_flat_map/test.cpp         | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index 6f09e2a678..9dfd454434 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -10,7 +10,7 @@
 #include <utility>
 
 // Extracted common functionality from flat_map and flat_set tests.
-// May be extended for other containers if needed
+// May be extended for other containers if needed.
 
 template <class T>
 void assert_container_requirements(const T& s) {
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index c0311583f1..f51b3d7f7c 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -256,7 +256,7 @@ void test_construction() {
     // directly accepts KeyContainer and MappedContainer or using two deduction guides:
     //      flat_map(from_range_t, _Rng&&, _Compare, _Allocator)
     //      flat_map(from_range_t, _Rng&&, _Allocator)
-    // In other cases we have to fully specify template arguments, such as for  flat_map(_Iter, _Iter, _Allocator)
+    // In other cases we have to fully specify template arguments, such as for flat_map(_Iter, _Iter, _Allocator)
     using flat_map_my_allocator =
         flat_map<int, int, less<int>, KeyCont<int, MyAllocator<int>>, MappedCont<int, MyAllocator<int>>>;
     using flat_multimap_my_allocator =
@@ -283,7 +283,7 @@ void test_construction() {
         }
     }
     {
-        // Test flat_map(key_cont, mapped_cont, comp = key_comp()())
+        // Test flat_map(key_cont, mapped_cont, comp = key_comp())
         KeyCont<int> keys    = {0, 1, 2, 3, 4, 2};
         MappedCont<int> vals = {44, 2324, 635462, 433, 5, 7};
         {
@@ -342,7 +342,7 @@ void test_construction() {
         }
     }
     {
-        // Test flat_map(_Sorted_t, key_cont, mapped_cont, comp = key_comp()())
+        // Test flat_map(_Sorted_t, key_cont, mapped_cont, comp = key_comp())
         {
             KeyCont<int> keys    = {0, 1, 2, 3, 38, 242};
             MappedCont<int> vals = {44, 2324, 635462, 433, 5, 7};
@@ -487,7 +487,7 @@ void test_construction() {
     {
         // Test flat_map(from_range_t, _Rng &&, const key_compare&, const alloc&)
         // and  flat_map(from_range_t, _Rng &&, const alloc&)
-        // These constructors with allocators have a corresponding deduction guide -  can rely on CTAD
+        // These constructors with allocators have a corresponding deduction guide - can rely on CTAD
         almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}};
 
         {

From 637ab36f488a439755973eb55d27c8b2fc4e3ee0 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Fri, 9 Jan 2026 10:14:52 -0800
Subject: [PATCH 31/48] Include more headers.

---
 tests/std/include/test_container_requirements.hpp | 3 +++
 tests/std/tests/P0429R9_flat_map/test.cpp         | 1 +
 2 files changed, 4 insertions(+)

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index 9dfd454434..91479966d6 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -3,7 +3,10 @@
 
 #pragma once
 
+#include <algorithm>
+#include <cassert>
 #include <compare>
+#include <format>
 #include <iterator>
 #include <print>
 #include <type_traits>
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index f51b3d7f7c..483f5ebce7 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -6,6 +6,7 @@
 #include <cassert>
 #include <concepts>
 #include <cstddef>
+#include <cstdlib>
 #include <deque>
 #include <flat_map>
 #include <functional>

From 62f38a3effce518f811fe4230bb22d8623567e76 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Fri, 9 Jan 2026 11:24:17 -0800
Subject: [PATCH 32/48] Down with typename.

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

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index 91479966d6..dce6e4d1eb 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -55,7 +55,7 @@ void assert_container_requirements(const T& s) {
     assert(m.begin() <= m.end());
     assert(m.begin() < m.end() || m.empty());
 
-    assert(static_cast<typename T::size_type>(s.cend() - s.cbegin()) == s.size());
+    assert(static_cast<T::size_type>(s.cend() - s.cbegin()) == s.size());
 }
 
 template <class T>
@@ -179,7 +179,7 @@ void assert_map_requirements() {
 
 template <typename T>
 void assert_three_way_comparability() {
-    using value_type = typename T::value_type;
+    using value_type = T::value_type;
     if constexpr (std::three_way_comparable<value_type>) {
         static_assert(std::three_way_comparable<T>);
     }

From 14f0159645bf6ef100afae17b190d93e69e62ffa Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Fri, 9 Jan 2026 11:40:04 -0800
Subject: [PATCH 33/48] Remove unused and shadowing `struct
 is_nothrow_swappable`.

---
 tests/std/include/test_container_requirements.hpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index dce6e4d1eb..6f4c88d997 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -90,9 +90,6 @@ template <typename T>
 concept has_nothrow_swappable_containers =
     set_has_nothrow_swappable_containers<T> || map_has_nothrow_swappable_containers<T>;
 
-template <typename T>
-struct is_nothrow_swappable {};
-
 template <class T>
 void assert_noexcept_requirements(T& s) {
     static_assert(noexcept(s.begin()));

From 3d87da6263ca8c761f8959e2826135e810ce40a0 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Fri, 9 Jan 2026 11:44:39 -0800
Subject: [PATCH 34/48] Use aliases.

---
 .../std/include/test_container_requirements.hpp  | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index 6f4c88d997..dea7078bf3 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -142,10 +142,12 @@ void assert_is_sorted_maybe_unique(const T& s) {
 
 template <class T>
 void assert_set_requirements() {
-    using iterator       = T::iterator;
-    using const_iterator = T::const_iterator;
-    using key_type       = T::key_type;
-    using value_type     = T::value_type;
+    using iterator        = T::iterator;
+    using const_iterator  = T::const_iterator;
+    using key_type        = T::key_type;
+    using value_type      = T::value_type;
+    using reference       = T::reference;
+    using const_reference = T::const_reference;
 
     static_assert(std::same_as<std::const_iterator<const_iterator>, const_iterator>);
     static_assert(std::is_convertible_v<iterator, const_iterator>);
@@ -154,9 +156,9 @@ void assert_set_requirements() {
     static_assert(std::is_same_v<key_type, value_type>);
     static_assert(std::same_as<std::const_iterator<iterator>, iterator>);
     static_assert(std::is_convertible_v<const_iterator, iterator>);
-    static_assert(std::is_same_v<decltype(*std::declval<T>().begin()), const typename T::value_type&>);
-    static_assert(std::is_same_v<std::remove_cvref_t<typename T::reference>, typename T::value_type>);
-    static_assert(std::is_same_v<typename T::const_reference, const typename T::value_type&>);
+    static_assert(std::is_same_v<decltype(*std::declval<T>().begin()), const value_type&>);
+    static_assert(std::is_same_v<std::remove_cvref_t<reference>, value_type>);
+    static_assert(std::is_same_v<const_reference, const value_type&>);
 }
 
 template <class T>

From 3e2958c9c7588863df460ddcd1529d092b7977ea Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Fri, 9 Jan 2026 12:05:00 -0800
Subject: [PATCH 35/48] Avoid shadowing: `empty` => `my_empty`

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

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index dea7078bf3..24d778e151 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -37,16 +37,16 @@ void assert_container_requirements(const T& s) {
     T my_moved = std::move(m);
     assert(!(my_moved != s));
 
-    T empty{};
-    assert(empty.empty());
+    T my_empty{};
+    assert(my_empty.empty());
 
     T non_empty = s;
-    empty.swap(non_empty);
+    my_empty.swap(non_empty);
     assert(non_empty.empty());
-    assert(empty == s);
+    assert(my_empty == s);
 
-    std::swap(empty, non_empty);
-    assert(empty.empty());
+    std::swap(my_empty, non_empty);
+    assert(my_empty.empty());
     assert(non_empty == s);
 
     assert(s.cbegin() <= s.cend());

From 15dc457039142849326da70cf04c8782ae1a7e5f Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Fri, 9 Jan 2026 12:07:40 -0800
Subject: [PATCH 36/48] `template <typename T>` => `template <class T>`

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

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index 24d778e151..0547c953a9 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -72,7 +72,7 @@ void assert_reversible_container_requirements(const T& s) {
     static_assert(std::is_convertible_v<typename T::reverse_iterator, typename T::const_reverse_iterator>);
 }
 
-template <typename T>
+template <class T>
 concept map_has_nothrow_swappable_containers = requires {
     typename T::key_container_type;
     typename T::mapped_container_type;
@@ -80,13 +80,13 @@ concept map_has_nothrow_swappable_containers = requires {
     requires std::is_nothrow_swappable_v<typename T::key_container_type>;
 };
 
-template <typename T>
+template <class T>
 concept set_has_nothrow_swappable_containers = requires {
     typename T::container_type;
     requires std::is_nothrow_swappable_v<typename T::container_type>;
 };
 
-template <typename T>
+template <class T>
 concept has_nothrow_swappable_containers =
     set_has_nothrow_swappable_containers<T> || map_has_nothrow_swappable_containers<T>;
 
@@ -176,7 +176,7 @@ void assert_map_requirements() {
     static_assert(std::is_same_v<value_type, std::pair<key_type, mapped_type>>);
 }
 
-template <typename T>
+template <class T>
 void assert_three_way_comparability() {
     using value_type = T::value_type;
     if constexpr (std::three_way_comparable<value_type>) {

From 7ee5304ce1cf50d87132f92c3493a55b8e82c00c Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Fri, 9 Jan 2026 15:43:41 -0800
Subject: [PATCH 37/48] Increase strictness.

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

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index 0547c953a9..09eb634734 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -50,10 +50,10 @@ void assert_container_requirements(const T& s) {
     assert(non_empty == s);
 
     assert(s.cbegin() <= s.cend());
-    assert(s.cbegin() < s.cend() || s.empty());
+    assert((s.cbegin() < s.cend()) == !s.empty());
 
     assert(m.begin() <= m.end());
-    assert(m.begin() < m.end() || m.empty());
+    assert((m.begin() < m.end()) == !m.empty());
 
     assert(static_cast<T::size_type>(s.cend() - s.cbegin()) == s.size());
 }

From 0877fbc111f2ae5302298730235959a0d5bd1cc8 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Fri, 9 Jan 2026 15:45:16 -0800
Subject: [PATCH 38/48] Add const.

---
 tests/std/include/test_container_requirements.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index 09eb634734..8f49a7cab4 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -117,7 +117,7 @@ void assert_noexcept_requirements(T& s) {
 template <bool ExpectedUnique, class T>
 void assert_is_sorted_maybe_unique(const T& s) {
     const auto val_comp = s.value_comp();
-    auto begin_it       = s.cbegin();
+    const auto begin_it = s.cbegin();
     const auto end_it   = s.cend();
 
     // internal check by the container itself

From da4b643f2ec177393a1e9911f10781d91c97833c Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Sat, 10 Jan 2026 14:11:45 -0800
Subject: [PATCH 39/48] Test const overloading.

---
 tests/std/include/test_container_requirements.hpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index 8f49a7cab4..17fd1cb58d 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -24,8 +24,12 @@ void assert_container_requirements(const T& s) {
     static_assert(std::is_same_v<decltype(m = std::move(m)), T&>);
     static_assert(std::is_same_v<decltype(m.begin()), typename T::iterator>);
     static_assert(std::is_same_v<decltype(m.end()), typename T::iterator>);
-    static_assert(std::is_same_v<decltype(s.cbegin()), typename T::const_iterator>);
+    static_assert(std::is_same_v<decltype(s.begin()), typename T::const_iterator>);
+    static_assert(std::is_same_v<decltype(s.end()), typename T::const_iterator>);
+    static_assert(std::is_same_v<decltype(m.cbegin()), typename T::const_iterator>);
     static_assert(std::is_same_v<decltype(m.cend()), typename T::const_iterator>);
+    static_assert(std::is_same_v<decltype(s.cbegin()), typename T::const_iterator>);
+    static_assert(std::is_same_v<decltype(s.cend()), typename T::const_iterator>);
     static_assert(std::is_convertible_v<typename T::iterator, typename T::const_iterator>);
     static_assert(std::is_same_v<decltype(m.begin() <=> m.end()), std::strong_ordering>);
     static_assert(std::is_same_v<decltype(s.size()), typename T::size_type>);
@@ -67,6 +71,8 @@ void assert_reversible_container_requirements(const T& s) {
     static_assert(std::is_same_v<decltype(T{}.rend()), typename T::reverse_iterator>);
     static_assert(std::is_same_v<decltype(s.rbegin()), typename T::const_reverse_iterator>);
     static_assert(std::is_same_v<decltype(s.rend()), typename T::const_reverse_iterator>);
+    static_assert(std::is_same_v<decltype(T{}.crbegin()), typename T::const_reverse_iterator>);
+    static_assert(std::is_same_v<decltype(T{}.crend()), typename T::const_reverse_iterator>);
     static_assert(std::is_same_v<decltype(s.crbegin()), typename T::const_reverse_iterator>);
     static_assert(std::is_same_v<decltype(s.crend()), typename T::const_reverse_iterator>);
     static_assert(std::is_convertible_v<typename T::reverse_iterator, typename T::const_reverse_iterator>);

From 615f456ec463d55fc934f24911f6e6f0536017e0 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Sat, 10 Jan 2026 14:12:52 -0800
Subject: [PATCH 40/48] Consistently order key_container_type before
 mapped_container_type.

---
 tests/std/include/test_container_requirements.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index 17fd1cb58d..828f5f94f5 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -82,8 +82,8 @@ template <class T>
 concept map_has_nothrow_swappable_containers = requires {
     typename T::key_container_type;
     typename T::mapped_container_type;
-    requires std::is_nothrow_swappable_v<typename T::mapped_container_type>;
     requires std::is_nothrow_swappable_v<typename T::key_container_type>;
+    requires std::is_nothrow_swappable_v<typename T::mapped_container_type>;
 };
 
 template <class T>

From a01e68255920b95c629aa06377cd6c75a6321690 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Sat, 10 Jan 2026 14:45:50 -0800
Subject: [PATCH 41/48] Use `adjacent_find()` to check uniqueness.

---
 .../std/include/test_container_requirements.hpp  | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index 828f5f94f5..cebe64d3ab 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -132,17 +132,15 @@ void assert_is_sorted_maybe_unique(const T& s) {
     // external check observable by the user
     assert(std::is_sorted(begin_it, end_it, val_comp));
     if constexpr (ExpectedUnique) {
-        if (!s.empty()) {
-            for (auto prev_it = begin_it, it = prev_it + 1; it != end_it; ++prev_it, ++it) {
-                const bool val_comp_ok = val_comp(*prev_it, *it);
-                if constexpr (std::formattable<T, char>) {
-                    if (!val_comp_ok) {
-                        std::println("Container {} is not sorted-maybe-unique", s);
-                    }
-                }
-                assert(val_comp_ok);
+        const auto not_comp  = [&](const auto& left, const auto& right) { return !val_comp(left, right); };
+        const bool is_unique = std::adjacent_find(begin_it, end_it, not_comp) == end_it;
+
+        if constexpr (std::formattable<T, char>) {
+            if (!is_unique) {
+                std::println("Container {} is not unique", s);
             }
         }
+        assert(is_unique);
     }
 }
 

From 0a78e60bb053ee730f6ab9068f1fb69ad171807c Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Sun, 11 Jan 2026 12:23:29 -0800
Subject: [PATCH 42/48] `std::declval` => `declval`

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

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 2783f1edf2..d03f798c12 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -945,14 +945,13 @@ concept can_erase_iterator_holder = requires(Cont c) {
 
 namespace detail {
     using C = flat_set<int>;
-    static_assert(same_as<C::iterator, decltype(std::declval<C>().erase(std::declval<C::iterator>()))>);
-    static_assert(same_as<C::iterator, decltype(std::declval<C>().erase(std::declval<holder<C::iterator>>()))>);
-    static_assert(same_as<C::iterator, decltype(std::declval<C>().erase(std::declval<C::const_iterator>()))>);
-    static_assert(same_as<C::iterator, decltype(std::declval<C>().erase(std::declval<holder<C::const_iterator>>()))>);
-    static_assert(same_as<C::iterator,
-        decltype(std::declval<C>().erase(std::declval<C::iterator>(), std::declval<C::iterator>()))>);
-    static_assert(same_as<C::size_type, decltype(std::declval<C>().erase(std::declval<holder<int>>()))>);
-    static_assert(same_as<C::size_type, decltype(std::declval<C>().erase(std::declval<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>>()))>);
+    static_assert(same_as<C::iterator, decltype(declval<C>().erase(declval<C::const_iterator>()))>);
+    static_assert(same_as<C::iterator, decltype(declval<C>().erase(declval<holder<C::const_iterator>>()))>);
+    static_assert(same_as<C::iterator, decltype(declval<C>().erase(declval<C::iterator>(), declval<C::iterator>()))>);
+    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>()))>);
 
     // erase key_type
     static_assert(can_erase_key<flat_set<int, _STD less<int>>, int>);

From cf5a3f88fe0242f6956cb6bac9014529cbb80355 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Sun, 11 Jan 2026 12:27:30 -0800
Subject: [PATCH 43/48] Use `lt` alias.

---
 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 d03f798c12..b9daf3053f 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -178,7 +178,7 @@ void test_constructors() {
     {
         // Test flat_set()
         // and  flat_set(const key_compare&)
-        const std::less<int> comp;
+        const lt comp;
         {
             flat_set<int, lt, C> fs;
             flat_set<int, lt, C> fs1(comp);

From 5510f60e70e91f0b6b1c6efa87c7ba73a8a8b770 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Sun, 11 Jan 2026 12:32:18 -0800
Subject: [PATCH 44/48] West const.

---
 tests/std/tests/P0429R9_flat_map/test.cpp | 4 ++--
 tests/std/tests/P1222R4_flat_set/test.cpp | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index 483f5ebce7..793632c558 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -1219,7 +1219,7 @@ void test_insert_hint_is_respected() {
     {
         flat_multimap<int, char, lt, KeyC<int>, ValueC<char>> a{{-1, 'x'}, {-1, 'x'}, {1, 'x'}, {1, 'x'}};
         bool problem_seen                      = false;
-        auto const assert_inserted_at_position = [&a, &problem_seen](
+        const auto assert_inserted_at_position = [&a, &problem_seen](
                                                      const int expected_index, const auto insert_position) {
             const auto expected_position = a.begin() + expected_index;
             if (expected_position != insert_position) {
@@ -1239,7 +1239,7 @@ void test_insert_hint_is_respected() {
         };
 
         pair pair0c{0, 'c'};
-        pair const pair0f{0, 'f'};
+        const pair pair0f{0, 'f'};
         // hint is greater
         assert(assert_check_content(a, {{-1, 'x'}, {-1, 'x'}, {1, 'x'}, {1, 'x'}}));
         assert_inserted_at_position(2, a.emplace_hint(a.end(), 0, 'a'));
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index b9daf3053f..bdeb39b974 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -423,7 +423,7 @@ void test_insert_hint_is_respected() {
     {
         flat_multiset<int, lt, C> a{-1, -1, 1, 1};
         bool problem_seen                      = false;
-        auto const assert_inserted_at_position = [&a, &problem_seen](
+        const auto assert_inserted_at_position = [&a, &problem_seen](
                                                      const int expected_index, const auto insert_position) {
             const auto expected_position = a.begin() + expected_index;
             if (expected_position != insert_position) {

From 5c584eca434027004ff66ec68e8715743a17cf70 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Sun, 11 Jan 2026 12:35:58 -0800
Subject: [PATCH 45/48] `_STD` => `std::`, `_RANGES` => `ranges::`

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

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index bdeb39b974..41f46e7c87 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -954,17 +954,17 @@ 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, _RANGES less>, int>);
+    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, 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, _RANGES less>, holder<int>>);
+    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, 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, _RANGES less>>);
+    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, ranges::less>>);
 } // namespace detail
 
 

From f2a00498efefb11215f25e3fa911883106f3f21f Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Sun, 11 Jan 2026 12:52:17 -0800
Subject: [PATCH 46/48] `assert_check_content` => `check_content`, mark check
 functions as `[[nodiscard]]`

---
 tests/std/tests/P0429R9_flat_map/test.cpp | 42 +++++++++++------------
 1 file changed, 20 insertions(+), 22 deletions(-)

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index 793632c558..6b6e3af015 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -48,18 +48,18 @@ void assert_all_requirements(const T& s) {
 }
 
 template <IsFlatMap T>
-bool check_key_content(const T& obj, const typename T::key_container_type& expected) {
+[[nodiscard]] bool check_key_content(const T& obj, const typename T::key_container_type& expected) {
     assert_all_requirements(obj);
     return ranges::equal(obj.keys(), expected);
 }
 
 template <IsFlatMap T>
-bool check_value_content(const T& obj, const typename T::mapped_container_type& expected) {
+[[nodiscard]] bool check_value_content(const T& obj, const typename T::mapped_container_type& expected) {
     return ranges::equal(obj.values(), expected);
 }
 
 template <IsFlatMap T>
-bool assert_check_content(const T& obj, const type_identity_t<T>& expected) {
+[[nodiscard]] bool check_content(const T& obj, const type_identity_t<T>& expected) {
     assert_all_requirements(obj);
     if (!ranges::equal(obj, expected)) {
         println(stderr, "Unexpected content!\nExpected {}", expected);
@@ -86,7 +86,7 @@ struct subrange_t { // represents a closed subrange [first_index, last_index]
 };
 
 template <IsFlatMap T>
-bool check_value_content(
+[[nodiscard]] bool check_value_content(
     const T& obj, const typename T::mapped_container_type& expected, const vector<subrange_t>& subranges) {
     const auto& actual = obj.values();
     if (actual.size() != expected.size()) {
@@ -226,7 +226,7 @@ struct TransparentPackagedCompare : PackagedCompare<T> {
 struct MyAllocatorCounter {
     MyAllocatorCounter() : activeAllocations{MyAllocator<int>::getActiveAllocationCount()} {}
 
-    bool check_then_reset() {
+    [[nodiscard]] bool check_then_reset() {
         const bool allocated_some = MyAllocator<int>::getActiveAllocationCount() > activeAllocations;
         activeAllocations         = MyAllocator<int>::getActiveAllocationCount();
         return allocated_some;
@@ -1241,38 +1241,36 @@ void test_insert_hint_is_respected() {
         pair pair0c{0, 'c'};
         const pair pair0f{0, 'f'};
         // hint is greater
-        assert(assert_check_content(a, {{-1, 'x'}, {-1, 'x'}, {1, 'x'}, {1, 'x'}}));
+        assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {1, 'x'}, {1, 'x'}}));
         assert_inserted_at_position(2, a.emplace_hint(a.end(), 0, 'a'));
-        assert(assert_check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {1, 'x'}, {1, 'x'}}));
+        assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {1, 'x'}, {1, 'x'}}));
         assert_inserted_at_position(3, a.emplace_hint(a.find(1), pair{0, 'b'}));
-        assert(assert_check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {0, 'b'}, {1, 'x'}, {1, 'x'}}));
+        assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {0, 'b'}, {1, 'x'}, {1, 'x'}}));
         assert_inserted_at_position(4, a.insert(a.upper_bound(0), std::move(pair0c)));
-        assert(assert_check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {0, 'b'}, {0, 'c'}, {1, 'x'}, {1, 'x'}}));
+        assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {0, 'b'}, {0, 'c'}, {1, 'x'}, {1, 'x'}}));
         // hint is correct
         assert_inserted_at_position(4, a.emplace_hint(a.upper_bound(0) - 1, 0, 'd'));
-        assert(assert_check_content(
-            a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {0, 'b'}, {0, 'd'}, {0, 'c'}, {1, 'x'}, {1, 'x'}}));
+        assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {0, 'b'}, {0, 'd'}, {0, 'c'}, {1, 'x'}, {1, 'x'}}));
         assert_inserted_at_position(3, a.emplace_hint(a.begin() + 3, pseudopair{0, 'e'}));
-        assert(assert_check_content(
+        assert(check_content(
             a, {{-1, 'x'}, {-1, 'x'}, {0, 'a'}, {0, 'e'}, {0, 'b'}, {0, 'd'}, {0, 'c'}, {1, 'x'}, {1, 'x'}}));
         assert_inserted_at_position(2, a.insert(a.lower_bound(0), pair0f));
-        assert(assert_check_content(
+        assert(check_content(
             a, {{-1, 'x'}, {-1, 'x'}, {0, 'f'}, {0, 'a'}, {0, 'e'}, {0, 'b'}, {0, 'd'}, {0, 'c'}, {1, 'x'}, {1, 'x'}}));
         // hint is less
         assert_inserted_at_position(2, a.emplace_hint(a.lower_bound(0) - 1, pair{0, 'g'}));
-        assert(assert_check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'g'}, {0, 'f'}, {0, 'a'}, {0, 'e'}, {0, 'b'},
-                                           {0, 'd'}, {0, 'c'}, {1, 'x'}, {1, 'x'}}));
+        assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'g'}, {0, 'f'}, {0, 'a'}, {0, 'e'}, {0, 'b'}, {0, 'd'},
+                                    {0, 'c'}, {1, 'x'}, {1, 'x'}}));
         assert_inserted_at_position(2, a.insert(a.begin(), pseudopair{0, 'h'}));
-        assert(assert_check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'h'}, {0, 'g'}, {0, 'f'}, {0, 'a'}, {0, 'e'},
-                                           {0, 'b'}, {0, 'd'}, {0, 'c'}, {1, 'x'}, {1, 'x'}}));
+        assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'h'}, {0, 'g'}, {0, 'f'}, {0, 'a'}, {0, 'e'}, {0, 'b'},
+                                    {0, 'd'}, {0, 'c'}, {1, 'x'}, {1, 'x'}}));
 
         assert(!problem_seen);
 
         assert(4 == erase_if(a, [](const auto pair) { return pair.second <= 'd'; }));
-        assert(assert_check_content(
-            a, {{-1, 'x'}, {-1, 'x'}, {0, 'h'}, {0, 'g'}, {0, 'f'}, {0, 'e'}, {1, 'x'}, {1, 'x'}}));
+        assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {0, 'h'}, {0, 'g'}, {0, 'f'}, {0, 'e'}, {1, 'x'}, {1, 'x'}}));
         assert(4 == a.erase(0));
-        assert(assert_check_content(a, {{-1, 'x'}, {-1, 'x'}, {1, 'x'}, {1, 'x'}}));
+        assert(check_content(a, {{-1, 'x'}, {-1, 'x'}, {1, 'x'}, {1, 'x'}}));
     }
 }
 
@@ -1327,7 +1325,7 @@ void test_non_strict_weak_order_compare() {
         assert(cont.end() == cont.find(strange_int{3}));
 
         assert(2 == cont.erase(strange_int{0}));
-        assert(assert_check_content(cont, {{11, 0}, {12, 0}}));
+        assert(check_content(cont, {{11, 0}, {12, 0}}));
     }
     {
         flat_multimap<int, int, divless> cont{{1, 0}, {2, 0}, {11, 0}, {12, 0}};
@@ -1347,7 +1345,7 @@ void test_non_strict_weak_order_compare() {
         assert(cont.end() == cont.find(strange_int{3}));
 
         assert(2 == cont.erase(strange_int{0}));
-        assert(assert_check_content(cont, {{11, 0}, {12, 0}}));
+        assert(check_content(cont, {{11, 0}, {12, 0}}));
     }
 }
 

From d7af0bd078c7e0e3c53238119f09929998fe5848 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Sun, 11 Jan 2026 12:55:01 -0800
Subject: [PATCH 47/48] Drop bogus commented-out tuple_size specialization.

---
 tests/std/tests/P0429R9_flat_map/test.cpp | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index 6b6e3af015..6b59201b80 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -167,12 +167,6 @@ namespace std {
     struct tuple_element<N, almost_pair<T, U>> {
         using type = conditional_t<N == 1, T, U>;
     };
-
-    // template<class T, class U>
-    // struct tuple_size<almost_pair<T, U>> {
-    //     using type = conditional_t<N == 1, T, U>;
-    // };
-
 } // namespace std
 
 template <typename T>

From 96ca5f71d58b1ea1cb84d6f8044c455bc17a6708 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Sun, 11 Jan 2026 12:30:10 -0800
Subject: [PATCH 48/48] Construct temporaries with braces.

---
 tests/std/tests/P0429R9_flat_map/test.cpp | 68 +++++++++++------------
 tests/std/tests/P1222R4_flat_set/test.cpp | 16 +++---
 2 files changed, 42 insertions(+), 42 deletions(-)

diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index 6b59201b80..c7e0aba31d 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -283,7 +283,7 @@ void test_construction() {
         MappedCont<int> vals = {44, 2324, 635462, 433, 5, 7};
         {
             flat_map fmap(keys, vals);
-            flat_map fmap1(keys, vals, less<int>());
+            flat_map fmap1(keys, vals, less<int>{});
 
             assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
             assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
@@ -291,7 +291,7 @@ void test_construction() {
         }
         {
             flat_multimap fmmap(keys, vals);
-            flat_multimap fmmap1(keys, vals, less<int>());
+            flat_multimap fmmap1(keys, vals, less<int>{});
 
             assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
             assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5},
@@ -310,9 +310,9 @@ void test_construction() {
         MappedCont<int, MyAllocator<int>> vals = {44, 2324, 635462, 433, 5, 7};
         {
             MyAllocatorCounter allocation_counter;
-            flat_map fmap(keys, vals, MyAllocator<int>());
+            flat_map fmap(keys, vals, MyAllocator<int>{});
             assert(allocation_counter.check_then_reset());
-            flat_map fmap1(keys, vals, less<int>(), MyAllocator<int>());
+            flat_map fmap1(keys, vals, less<int>{}, MyAllocator<int>{});
             assert(allocation_counter.check_then_reset());
 
             assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
@@ -321,9 +321,9 @@ void test_construction() {
         }
         {
             MyAllocatorCounter allocation_counter;
-            flat_multimap fmmap(keys, vals, MyAllocator<int>());
+            flat_multimap fmmap(keys, vals, MyAllocator<int>{});
             assert(allocation_counter.check_then_reset());
-            flat_multimap fmmap1(keys, vals, less<int>(), MyAllocator<int>());
+            flat_multimap fmmap1(keys, vals, less<int>{}, MyAllocator<int>{});
             assert(allocation_counter.check_then_reset());
 
             assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
@@ -343,7 +343,7 @@ void test_construction() {
             MappedCont<int> vals = {44, 2324, 635462, 433, 5, 7};
 
             flat_map fmap(sorted_unique, keys, vals);
-            flat_map fmap1(sorted_unique, keys, vals, less<int>());
+            flat_map fmap1(sorted_unique, keys, vals, less<int>{});
 
             assert(check_key_content(fmap, {0, 1, 2, 3, 38, 242}));
             assert(check_value_content(fmap, {44, 2324, 635462, 433, 5, 7}));
@@ -354,7 +354,7 @@ void test_construction() {
             MappedCont<int> vals = {44, 2324, 635462, 7, 433, 5};
 
             flat_multimap fmmap(sorted_equivalent, keys, vals);
-            flat_multimap fmmap1(sorted_equivalent, keys, vals, less<int>());
+            flat_multimap fmmap1(sorted_equivalent, keys, vals, less<int>{});
 
             assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
             assert(check_value_content(
@@ -378,9 +378,9 @@ void test_construction() {
             MappedCont<int, MyAllocator<int>> vals = {44, 2324, 635462, 433, 5};
 
             MyAllocatorCounter allocation_counter;
-            flat_map fmap(sorted_unique, keys, vals, MyAllocator<int>());
+            flat_map fmap(sorted_unique, keys, vals, MyAllocator<int>{});
             assert(allocation_counter.check_then_reset());
-            flat_map fmap1(sorted_unique, keys, vals, less<int>(), MyAllocator<int>());
+            flat_map fmap1(sorted_unique, keys, vals, less<int>{}, MyAllocator<int>{});
             assert(allocation_counter.check_then_reset());
 
             assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
@@ -392,9 +392,9 @@ void test_construction() {
             MappedCont<int, MyAllocator<int>> vals = {44, 2324, 635462, 7, 433, 5};
 
             MyAllocatorCounter allocation_counter;
-            flat_multimap fmmap(sorted_equivalent, keys, vals, MyAllocator<int>());
+            flat_multimap fmmap(sorted_equivalent, keys, vals, MyAllocator<int>{});
             assert(allocation_counter.check_then_reset());
-            flat_multimap fmmap1(sorted_equivalent, keys, vals, less<int>(), MyAllocator<int>());
+            flat_multimap fmmap1(sorted_equivalent, keys, vals, less<int>{}, MyAllocator<int>{});
             assert(allocation_counter.check_then_reset());
 
             assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
@@ -434,10 +434,10 @@ void test_construction() {
         almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}};
         {
             MyAllocatorCounter allocation_counter;
-            flat_map_my_allocator fmap{ranges::begin(value_types), ranges::end(value_types), MyAllocator<int>()};
+            flat_map_my_allocator fmap{ranges::begin(value_types), ranges::end(value_types), MyAllocator<int>{}};
             assert(allocation_counter.check_then_reset());
             flat_map_my_allocator fmap1{
-                ranges::begin(value_types), ranges::end(value_types), less<int>(), MyAllocator<int>()};
+                ranges::begin(value_types), ranges::end(value_types), less<int>{}, MyAllocator<int>{}};
             assert(allocation_counter.check_then_reset());
 
             assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
@@ -446,10 +446,10 @@ void test_construction() {
         }
         {
             MyAllocatorCounter allocation_counter;
-            flat_multimap_my_allocator fmmap{ranges::begin(value_types), ranges::end(value_types), MyAllocator<int>()};
+            flat_multimap_my_allocator fmmap{ranges::begin(value_types), ranges::end(value_types), MyAllocator<int>{}};
             assert(allocation_counter.check_then_reset());
             flat_multimap_my_allocator fmmap1{
-                ranges::begin(value_types), ranges::end(value_types), less<int>(), MyAllocator<int>()};
+                ranges::begin(value_types), ranges::end(value_types), less<int>{}, MyAllocator<int>{}};
             assert(allocation_counter.check_then_reset());
 
             assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
@@ -463,7 +463,7 @@ void test_construction() {
         almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}};
         {
             flat_map fmap{from_range, value_types};
-            flat_map fmap1{from_range, value_types, less<int>()};
+            flat_map fmap1{from_range, value_types, less<int>{}};
 
             assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
             assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
@@ -472,7 +472,7 @@ void test_construction() {
 
         {
             flat_multimap fmmap{from_range, value_types};
-            flat_multimap fmmap1{from_range, value_types, less<int>()};
+            flat_multimap fmmap1{from_range, value_types, less<int>{}};
 
             assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
             assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
@@ -487,9 +487,9 @@ void test_construction() {
 
         {
             MyAllocatorCounter allocation_counter;
-            flat_map fmap{from_range, value_types, MyAllocator<int>()};
+            flat_map fmap{from_range, value_types, MyAllocator<int>{}};
             assert(allocation_counter.check_then_reset());
-            flat_map fmap1{from_range, value_types, less<int>(), MyAllocator<int>()};
+            flat_map fmap1{from_range, value_types, less<int>{}, MyAllocator<int>{}};
             assert(allocation_counter.check_then_reset());
 
             assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
@@ -498,9 +498,9 @@ void test_construction() {
         }
         {
             MyAllocatorCounter allocation_counter;
-            flat_multimap fmmap{from_range, value_types, MyAllocator<int>()};
+            flat_multimap fmmap{from_range, value_types, MyAllocator<int>{}};
             assert(allocation_counter.check_then_reset());
-            flat_multimap fmmap1{from_range, value_types, less<int>(), MyAllocator<int>()};
+            flat_multimap fmmap1{from_range, value_types, less<int>{}, MyAllocator<int>{}};
             assert(allocation_counter.check_then_reset());
 
             assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
@@ -539,10 +539,10 @@ void test_construction() {
 
             MyAllocatorCounter allocation_counter;
             flat_map_my_allocator fmap{
-                sorted_unique, ranges::begin(value_types), ranges::end(value_types), MyAllocator<int>()};
+                sorted_unique, ranges::begin(value_types), ranges::end(value_types), MyAllocator<int>{}};
             assert(allocation_counter.check_then_reset());
             flat_map_my_allocator fmap1{
-                sorted_unique, ranges::begin(value_types), ranges::end(value_types), less<int>(), MyAllocator<int>()};
+                sorted_unique, ranges::begin(value_types), ranges::end(value_types), less<int>{}, MyAllocator<int>{}};
             assert(allocation_counter.check_then_reset());
 
             assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
@@ -554,10 +554,10 @@ void test_construction() {
 
             MyAllocatorCounter allocation_counter;
             flat_multimap_my_allocator fmmap{
-                sorted_equivalent, ranges::begin(value_types), ranges::end(value_types), MyAllocator<int>()};
+                sorted_equivalent, ranges::begin(value_types), ranges::end(value_types), MyAllocator<int>{}};
             assert(allocation_counter.check_then_reset());
             flat_multimap_my_allocator fmmap1{sorted_equivalent, ranges::begin(value_types), ranges::end(value_types),
-                less<int>(), MyAllocator<int>()};
+                less<int>{}, MyAllocator<int>{}};
             assert(allocation_counter.check_then_reset());
 
             assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
@@ -591,10 +591,10 @@ void test_construction() {
         // and  flat_map(initializer_list, const alloc&)
         {
             MyAllocatorCounter allocation_counter;
-            flat_map_my_allocator fmap{{{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, MyAllocator<int>()};
+            flat_map_my_allocator fmap{{{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, MyAllocator<int>{}};
             assert(allocation_counter.check_then_reset());
             flat_map_my_allocator fmap1{
-                {{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, less<int>(), MyAllocator<int>()};
+                {{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, less<int>{}, MyAllocator<int>{}};
             assert(allocation_counter.check_then_reset());
 
             assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
@@ -604,10 +604,10 @@ void test_construction() {
         {
             MyAllocatorCounter allocation_counter;
             flat_multimap_my_allocator fmmap{
-                {{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, MyAllocator<int>()};
+                {{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, MyAllocator<int>{}};
             assert(allocation_counter.check_then_reset());
             flat_multimap_my_allocator fmmap1{
-                {{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, less<int>(), MyAllocator<int>()};
+                {{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, less<int>{}, MyAllocator<int>{}};
             assert(allocation_counter.check_then_reset());
 
             assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
@@ -643,10 +643,10 @@ void test_construction() {
         {
             MyAllocatorCounter allocation_counter;
             flat_map_my_allocator fmap{
-                sorted_unique, {{0, 44}, {1, 2324}, {2, 635462}, {3, 433}, {4, 5}}, MyAllocator<int>()};
+                sorted_unique, {{0, 44}, {1, 2324}, {2, 635462}, {3, 433}, {4, 5}}, MyAllocator<int>{}};
             assert(allocation_counter.check_then_reset());
             flat_map_my_allocator fmap1{
-                sorted_unique, {{0, 44}, {1, 2324}, {2, 635462}, {3, 433}, {4, 5}}, less<int>(), MyAllocator<int>()};
+                sorted_unique, {{0, 44}, {1, 2324}, {2, 635462}, {3, 433}, {4, 5}}, less<int>{}, MyAllocator<int>{}};
             assert(allocation_counter.check_then_reset());
 
             assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
@@ -656,10 +656,10 @@ void test_construction() {
         {
             MyAllocatorCounter allocation_counter;
             flat_multimap_my_allocator fmmap{
-                sorted_equivalent, {{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, MyAllocator<int>()};
+                sorted_equivalent, {{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, MyAllocator<int>{}};
             assert(allocation_counter.check_then_reset());
             flat_multimap_my_allocator fmmap1{sorted_equivalent,
-                {{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, less<int>(), MyAllocator<int>()};
+                {{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}}, less<int>{}, MyAllocator<int>{}};
             assert(allocation_counter.check_then_reset());
 
             assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 41f46e7c87..f18ebbaf78 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -196,14 +196,14 @@ void test_constructors() {
 
     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});
-    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});
-    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});
+    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});
+    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});
+    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};