From 81f687e29ae066b56c64405367fedc0b914d04c0 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Thu, 22 Jan 2026 17:21:45 +0100
Subject: [PATCH 1/9] `P0896R4_ranges_range_machinery`: test `flat_meow`

---
 .../tests/P0896R4_ranges_range_machinery/test.cpp   | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp b/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp
index 83bdb64bc35..e29d6d99a7b 100644
--- a/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp
+++ b/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp
@@ -27,6 +27,11 @@
 #include <valarray>
 #include <vector>
 
+#if _HAS_CXX23
+#include <flat_map>
+#include <flat_set>
+#endif // _HAS_CXX23
+
 #include <range_algorithm_support.hpp>
 
 // Note that many tests herein assume:
@@ -907,6 +912,14 @@ static_assert(test_std_container<std::vector<int>, std::contiguous_iterator_tag>
 static_assert(test_std_container<std::vector<bool>, std::random_access_iterator_tag>());
 static_assert(test_std_container<std::wstring, std::contiguous_iterator_tag>());
 
+#if _HAS_CXX23
+static_assert(test_std_container<std::flat_map<int, int>, std::random_access_iterator_tag>());
+static_assert(test_std_container<std::flat_multimap<int, int>, std::random_access_iterator_tag>());
+// FIXME: Should `flat_(multi)set` iterators model `contiguous_iterator` concept when underlying does?
+// static_assert(test_std_container<std::flat_set<int>, std::random_access_iterator_tag>());
+// static_assert(test_std_container<std::flat_multiset<int>, std::random_access_iterator_tag>());
+#endif // _HAS_CXX23
+
 // Validate that "old" fancy pointers that fail to model contiguous_iterator don't break contiguity of containers.
 template <class T>
 struct fancy_pointer {

From 714a6c136aa2e2f0d85438f4d893cd1f547a9f57 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Thu, 22 Jan 2026 15:56:00 +0100
Subject: [PATCH 2/9] `P1206R7_ranges_to_mappish`: Test `flat_map` and
 `flat_multimap`

---
 .../tests/P1206R7_ranges_to_mappish/test.cpp  | 60 +++++++++++++++++--
 1 file changed, 56 insertions(+), 4 deletions(-)

diff --git a/tests/std/tests/P1206R7_ranges_to_mappish/test.cpp b/tests/std/tests/P1206R7_ranges_to_mappish/test.cpp
index 6ba6e3fa3bb..7c15710ded9 100644
--- a/tests/std/tests/P1206R7_ranges_to_mappish/test.cpp
+++ b/tests/std/tests/P1206R7_ranges_to_mappish/test.cpp
@@ -4,11 +4,15 @@
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
+#include <flat_map>
+#include <functional>
 #include <map>
+#include <memory>
 #include <ranges>
 #include <string_view>
 #include <unordered_map>
 #include <utility>
+#include <vector>
 
 #include <range_algorithm_support.hpp>
 
@@ -71,6 +75,20 @@ struct mappish_instantiator {
         template <class Key, class Val, class... Args>
         using apply = std::unordered_multimap<Key, Val, std::hash<Key>, std::equal_to<Key>, Args...>;
     };
+    template <>
+    struct deduce_container_impl<std::flat_map> {
+        template <class Key, class Val, class... Args>
+        using apply = std::flat_map<Key, Val, std::less<Key>,
+            std::vector<Key, typename std::allocator_traits<Args>::template rebind_alloc<Key>...>,
+            std::vector<Val, typename std::allocator_traits<Args>::template rebind_alloc<Val>...>>;
+    };
+    template <>
+    struct deduce_container_impl<std::flat_multimap> {
+        template <class Key, class Val, class... Args>
+        using apply = std::flat_multimap<Key, Val, std::less<Key>,
+            std::vector<Key, typename std::allocator_traits<Args>::template rebind_alloc<Key>...>,
+            std::vector<Val, typename std::allocator_traits<Args>::template rebind_alloc<Val>...>>;
+    };
 
     template <template <class...> class C, class Key, class Val, class... Args>
     using deduce_container = deduce_container_impl<C>::template apply<Key, Val, Args...>;
@@ -145,26 +163,56 @@ struct mappish_instantiator {
 
         using Alloc = myalloc<std::pair<const int, std::string_view>>;
         using T     = deduce_container<C, int, std::string_view, Alloc>;
+        constexpr bool is_flat =
+            std::_Is_specialization_v<T, std::flat_map> || std::_Is_specialization_v<T, std::flat_multimap>;
 
         {
             std::same_as<T> auto c4 = ranges::to<T>(R{some_pairs}, Alloc{13});
-            assert(c4.get_allocator().state == 13);
             assert(ranges::is_permutation(c4, expected, any_pair_eq));
+
+            if constexpr (is_flat) {
+                const auto containers = std::move(c4).extract();
+                assert(containers.keys.get_allocator().state == 13);
+                assert(containers.values.get_allocator().state == 13);
+            } else {
+                assert(c4.get_allocator().state == 13);
+            }
         }
         {
             std::same_as<T> auto c5 = ranges::to<C>(R{some_pairs}, Alloc{13});
-            assert(c5.get_allocator().state == 13);
             assert(ranges::is_permutation(c5, expected, any_pair_eq));
+
+            if constexpr (is_flat) {
+                const auto containers = std::move(c5).extract();
+                assert(containers.keys.get_allocator().state == 13);
+                assert(containers.values.get_allocator().state == 13);
+            } else {
+                assert(c5.get_allocator().state == 13);
+            }
         }
         {
             std::same_as<T> auto c6 = R{some_pairs} | ranges::to<T>(Alloc{13});
-            assert(c6.get_allocator().state == 13);
             assert(ranges::is_permutation(c6, expected, any_pair_eq));
+
+            if constexpr (is_flat) {
+                const auto containers = std::move(c6).extract();
+                assert(containers.keys.get_allocator().state == 13);
+                assert(containers.values.get_allocator().state == 13);
+            } else {
+                assert(c6.get_allocator().state == 13);
+            }
         }
         {
             std::same_as<T> auto c7 = R{some_pairs} | ranges::to<C>(Alloc{13});
-            assert(c7.get_allocator().state == 13);
             assert(ranges::is_permutation(c7, expected, any_pair_eq));
+
+            if constexpr (is_flat) {
+                const auto containers = std::move(c7).extract();
+                assert(containers.keys.get_allocator().state == 13);
+                assert(containers.values.get_allocator().state == 13);
+            } else {
+                assert(c7.get_allocator().state == 13);
+            }
         }
     }
 
@@ -176,6 +224,8 @@ struct mappish_instantiator {
             test_mappish<R, std::multimap, is_multi::yes>();
             test_mappish<R, std::unordered_map, is_multi::no>();
             test_mappish<R, std::unordered_multimap, is_multi::yes>();
+            test_mappish<R, std::flat_map, is_multi::no>();
+            test_mappish<R, std::flat_multimap, is_multi::yes>();
         }
     }
 };
@@ -186,4 +236,6 @@ int main() {
     mappish_instantiator::test_copy_move<std::multimap>();
     mappish_instantiator::test_copy_move<std::unordered_map>();
     mappish_instantiator::test_copy_move<std::unordered_multimap>();
+    mappish_instantiator::test_copy_move<std::flat_map>();
+    mappish_instantiator::test_copy_move<std::flat_multimap>();
 }

From b736b3b81a6fb18c8103663824977ebcab3ac992 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Thu, 22 Jan 2026 15:57:19 +0100
Subject: [PATCH 3/9] `P1206R7_ranges_to_settish`: Test `flat_set` and
 `flat_multiset`

---
 .../tests/P1206R7_ranges_to_settish/test.cpp  | 49 +++++++++++++++++--
 1 file changed, 45 insertions(+), 4 deletions(-)

diff --git a/tests/std/tests/P1206R7_ranges_to_settish/test.cpp b/tests/std/tests/P1206R7_ranges_to_settish/test.cpp
index df56e6fccc5..9a0371ceec8 100644
--- a/tests/std/tests/P1206R7_ranges_to_settish/test.cpp
+++ b/tests/std/tests/P1206R7_ranges_to_settish/test.cpp
@@ -4,6 +4,9 @@
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
+#include <flat_set>
+#include <functional>
+#include <memory>
 #include <ranges>
 #include <set>
 #include <unordered_set>
@@ -65,6 +68,18 @@ struct settish_instantiator {
         template <class Key, class... Args>
         using apply = std::unordered_multiset<Key, std::hash<Key>, std::equal_to<Key>, Args...>;
     };
+    template <>
+    struct deduce_container_impl<std::flat_set> {
+        template <class Key, class... Args>
+        using apply = std::flat_set<Key, std::less<Key>,
+            std::vector<Key, typename std::allocator_traits<Args>::template rebind_alloc<Key>...>>;
+    };
+    template <>
+    struct deduce_container_impl<std::flat_multiset> {
+        template <class Key, class... Args>
+        using apply = std::flat_multiset<Key, std::less<Key>,
+            std::vector<Key, typename std::allocator_traits<Args>::template rebind_alloc<Key>...>>;
+    };
 
     template <template <class...> class C, class Key, class... Args>
     using deduce_container = deduce_container_impl<C>::template apply<Key, Args...>;
@@ -139,26 +154,48 @@ struct settish_instantiator {
 
         using Alloc = myalloc<int>;
         using T     = deduce_container<C, int, Alloc>;
+        constexpr bool is_flat =
+            std::_Is_specialization_v<T, std::flat_set> || std::_Is_specialization_v<T, std::flat_multiset>;
 
         {
             std::same_as<T> auto c4 = ranges::to<T>(R{some_ints}, Alloc{13});
-            assert(c4.get_allocator().state == 13);
             assert(ranges::is_permutation(c4, expected));
+
+            if constexpr (is_flat) {
+                assert(std::move(c4).extract().get_allocator().state == 13);
+            } else {
+                assert(c4.get_allocator().state == 13);
+            }
         }
         {
             std::same_as<T> auto c5 = ranges::to<C>(R{some_ints}, Alloc{13});
-            assert(c5.get_allocator().state == 13);
             assert(ranges::is_permutation(c5, expected));
+
+            if constexpr (is_flat) {
+                assert(std::move(c5).extract().get_allocator().state == 13);
+            } else {
+                assert(c5.get_allocator().state == 13);
+            }
         }
         {
             std::same_as<T> auto c6 = R{some_ints} | ranges::to<T>(Alloc{13});
-            assert(c6.get_allocator().state == 13);
             assert(ranges::is_permutation(c6, expected));
+
+            if constexpr (is_flat) {
+                assert(std::move(c6).extract().get_allocator().state == 13);
+            } else {
+                assert(c6.get_allocator().state == 13);
+            }
         }
         {
             std::same_as<T> auto c7 = R{some_ints} | ranges::to<C>(Alloc{13});
-            assert(c7.get_allocator().state == 13);
             assert(ranges::is_permutation(c7, expected));
+
+            if constexpr (is_flat) {
+                assert(std::move(c7).extract().get_allocator().state == 13);
+            } else {
+                assert(c7.get_allocator().state == 13);
+            }
         }
     }
 
@@ -168,6 +205,8 @@ struct settish_instantiator {
         test_settish<R, std::multiset, is_multi::yes>();
         test_settish<R, std::unordered_set, is_multi::no>();
         test_settish<R, std::unordered_multiset, is_multi::yes>();
+        test_settish<R, std::flat_set, is_multi::no>();
+        test_settish<R, std::flat_multiset, is_multi::yes>();
     }
 };
 
@@ -177,4 +216,6 @@ int main() {
     settish_instantiator::test_copy_move<std::multiset>();
     settish_instantiator::test_copy_move<std::unordered_set>();
     settish_instantiator::test_copy_move<std::unordered_multiset>();
+    settish_instantiator::test_copy_move<std::flat_set>();
+    settish_instantiator::test_copy_move<std::flat_multiset>();
 }

From a4224e4b097b50b7a24554a060161b0570d26b25 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Thu, 22 Jan 2026 17:14:11 +0100
Subject: [PATCH 4/9] `P2286R8_text_formatting_range_map`: test `flat_map` and
 `flat_multimap`

---
 .../test.cpp                                  | 53 ++++++++++---------
 1 file changed, 27 insertions(+), 26 deletions(-)

diff --git a/tests/std/tests/P2286R8_text_formatting_range_map/test.cpp b/tests/std/tests/P2286R8_text_formatting_range_map/test.cpp
index baa2115b514..216a663cbca 100644
--- a/tests/std/tests/P2286R8_text_formatting_range_map/test.cpp
+++ b/tests/std/tests/P2286R8_text_formatting_range_map/test.cpp
@@ -20,6 +20,7 @@
 #include <concepts>
 #include <cstddef>
 #include <cstring>
+#include <flat_map>
 #include <format>
 #include <iterator>
 #include <map>
@@ -325,7 +326,7 @@ void test_char(TestFunction check, ExceptionTest check_exception) {
 
 template <class TestFunction, class ExceptionTest>
 void test_char_to_wchar(TestFunction check, ExceptionTest check_exception) {
-    map<char, char> input{{'a', 'A'}, {'c', 'C'}, {'b', 'B'}};
+    flat_map<char, char> input{{'a', 'A'}, {'c', 'C'}, {'b', 'B'}};
 
     using CharT = wchar_t;
     check(SV("{'a': 'A', 'b': 'B', 'c': 'C'}"), SV("{}"), input);
@@ -646,24 +647,24 @@ void test_int(TestFunction check, ExceptionTest check_exception) {
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_floating_point(TestFunction check, ExceptionTest check_exception) {
-    map<double, double> input{{1.0, -1.0}, {-42, 42}};
+    flat_multimap<double, double> input{{11.0, 42.0}, {11.0, -1.0}};
 
-    check(SV("{-42: 42, 1: -1}"), SV("{}"), input);
-    check(SV("{-42: 42, 1: -1}^42"), SV("{}^42"), input);
-    check(SV("{-42: 42, 1: -1}^42"), SV("{:}^42"), input);
+    check(SV("{11: 42, 11: -1}"), SV("{}"), input);
+    check(SV("{11: 42, 11: -1}^42"), SV("{}^42"), input);
+    check(SV("{11: 42, 11: -1}^42"), SV("{:}^42"), input);
 
     // ***** underlying has no format-spec
 
     // *** align-fill & width ***
-    check(SV("{-42: 42, 1: -1}     "), SV("{:21}"), input);
-    check(SV("{-42: 42, 1: -1}*****"), SV("{:*<21}"), input);
-    check(SV("__{-42: 42, 1: -1}___"), SV("{:_^21}"), input);
-    check(SV("#####{-42: 42, 1: -1}"), SV("{:#>21}"), input);
+    check(SV("{11: 42, 11: -1}     "), SV("{:21}"), input);
+    check(SV("{11: 42, 11: -1}*****"), SV("{:*<21}"), input);
+    check(SV("__{11: 42, 11: -1}___"), SV("{:_^21}"), input);
+    check(SV("#####{11: 42, 11: -1}"), SV("{:#>21}"), input);
 
-    check(SV("{-42: 42, 1: -1}     "), SV("{:{}}"), input, 21);
-    check(SV("{-42: 42, 1: -1}*****"), SV("{:*<{}}"), input, 21);
-    check(SV("__{-42: 42, 1: -1}___"), SV("{:_^{}}"), input, 21);
-    check(SV("#####{-42: 42, 1: -1}"), SV("{:#>{}}"), input, 21);
+    check(SV("{11: 42, 11: -1}     "), SV("{:{}}"), input, 21);
+    check(SV("{11: 42, 11: -1}*****"), SV("{:*<{}}"), input, 21);
+    check(SV("__{11: 42, 11: -1}___"), SV("{:_^{}}"), input, 21);
+    check(SV("#####{11: 42, 11: -1}"), SV("{:#>{}}"), input, 21);
 
     check_exception("The format string contains an invalid escape sequence", SV("{:}<}"), input);
     check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
@@ -686,10 +687,10 @@ void test_floating_point(TestFunction check, ExceptionTest check_exception) {
     check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 
     // *** n
-    check(SV("__-42: 42, 1: -1___"), SV("{:_^19n}"), input);
+    check(SV("__11: 42, 11: -1___"), SV("{:_^19n}"), input);
 
     // *** type ***
-    check(SV("__{-42: 42, 1: -1}___"), SV("{:_^21m}"), input); // the m type does the same as the default.
+    check(SV("__{11: 42, 11: -1}___"), SV("{:_^21m}"), input); // the m type does the same as the default.
     check_exception("Type s requires character type as formatting argument", SV("{:s}"), input);
     check_exception("Type ?s requires character type as formatting argument", SV("{:?s}"), input);
 
@@ -698,15 +699,15 @@ void test_floating_point(TestFunction check, ExceptionTest check_exception) {
     }
 
     // ***** Only underlying has a format-spec
-    check(SV("{-42: 42   , 1: -1     }"), SV("{::10}"), input);
-    check(SV("{-42: 42***, 1: -1*****}"), SV("{::*<10}"), input);
-    check(SV("{_-42: 42__, __1: -1___}"), SV("{::_^10}"), input);
-    check(SV("{###-42: 42, #####1: -1}"), SV("{::#>10}"), input);
+    check(SV("{11: 42    , 11: -1    }"), SV("{::10}"), input);
+    check(SV("{11: 42****, 11: -1****}"), SV("{::*<10}"), input);
+    check(SV("{__11: 42__, __11: -1__}"), SV("{::_^10}"), input);
+    check(SV("{####11: 42, ####11: -1}"), SV("{::#>10}"), input);
 
-    check(SV("{-42: 42   , 1: -1     }"), SV("{::{}}"), input, 10);
-    check(SV("{-42: 42***, 1: -1*****}"), SV("{::*<{}}"), input, 10);
-    check(SV("{_-42: 42__, __1: -1___}"), SV("{::_^{}}"), input, 10);
-    check(SV("{###-42: 42, #####1: -1}"), SV("{::#>{}}"), input, 10);
+    check(SV("{11: 42    , 11: -1    }"), SV("{::{}}"), input, 10);
+    check(SV("{11: 42****, 11: -1****}"), SV("{::*<{}}"), input, 10);
+    check(SV("{__11: 42__, __11: -1__}"), SV("{::_^{}}"), input, 10);
+    check(SV("{####11: 42, ####11: -1}"), SV("{::#>{}}"), input, 10);
 
     check_exception("The format string contains an invalid escape sequence", SV("{::}<}"), input);
     check_exception("The fill option contains an invalid value", SV("{::{<}"), input);
@@ -734,9 +735,9 @@ void test_floating_point(TestFunction check, ExceptionTest check_exception) {
     }
 
     // ***** Both have a format-spec
-    check(SV("^^{###-42: 42, #####1: -1}^^^"), SV("{:^^29:#>10}"), input);
-    check(SV("^^{###-42: 42, #####1: -1}^^^"), SV("{:^^{}:#>10}"), input, 29);
-    check(SV("^^{###-42: 42, #####1: -1}^^^"), SV("{:^^{}:#>{}}"), input, 29, 10);
+    check(SV("^^{####11: 42, ####11: -1}^^^"), SV("{:^^29:#>10}"), input);
+    check(SV("^^{####11: 42, ####11: -1}^^^"), SV("{:^^{}:#>10}"), input, 29);
+    check(SV("^^{####11: 42, ####11: -1}^^^"), SV("{:^^{}:#>{}}"), input, 29, 10);
 
     check_exception(
         "The argument index value is too large for the number of arguments supplied", SV("{:^^{}:#>10}"), input);

From 6a8410bd8d9370f6958733674e0d2190525168f5 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Thu, 22 Jan 2026 17:20:48 +0100
Subject: [PATCH 5/9] `P2286R8_text_formatting_range_set`: test `flat_set` and
 `flat_multiset`

---
 .../P2286R8_text_formatting_range_set/test.cpp   | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/tests/std/tests/P2286R8_text_formatting_range_set/test.cpp b/tests/std/tests/P2286R8_text_formatting_range_set/test.cpp
index 98c7e9b8ea0..07d57e1b359 100644
--- a/tests/std/tests/P2286R8_text_formatting_range_set/test.cpp
+++ b/tests/std/tests/P2286R8_text_formatting_range_set/test.cpp
@@ -20,6 +20,7 @@
 #include <concepts>
 #include <cstddef>
 #include <cstring>
+#include <flat_set>
 #include <format>
 #include <iterator>
 #include <ranges>
@@ -329,7 +330,7 @@ void test_char_default(TestFunction check, ExceptionTest check_exception) {
 // This does not seem very useful, but it is allowed.
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_char_string(TestFunction check, [[maybe_unused]] ExceptionTest check_exception) {
-    set input{CharT('a'), CharT('c'), CharT('b')}; // input not sorted.
+    flat_set input{CharT('a'), CharT('c'), CharT('b')}; // input not sorted.
 
     check(SV("abc"), SV("{:s}"), input);
 
@@ -454,7 +455,7 @@ void test_char(TestFunction check, ExceptionTest check_exception) {
 
 template <class TestFunction, class ExceptionTest>
 void test_char_to_wchar(TestFunction check, ExceptionTest check_exception) {
-    set input{'a', 'c', 'b'}; // input not sorted.
+    flat_set input{'a', 'c', 'b'}; // input not sorted.
 
     using CharT = wchar_t;
 
@@ -901,6 +902,8 @@ template <class CharT, class TestFunction, class ExceptionTest>
 void test_int(TestFunction check, ExceptionTest check_exception) {
     test_int<CharT>(check, check_exception, set{1, 42, 2, -42}); // unsorted
     test_int<CharT>(check, check_exception, multiset{1, 42, 2, -42}); // unsorted
+    test_int<CharT>(check, check_exception, flat_set{1, 42, 2, -42}); // unsorted
+    test_int<CharT>(check, check_exception, flat_multiset{1, 42, 2, -42}); // unsorted
 }
 
 //
@@ -1025,6 +1028,9 @@ void test_floating_point(TestFunction check, ExceptionTest check_exception) {
     test_floating_point<CharT>(check, check_exception, set{-42.5f, 0.0f, 1.25f, 42.5f});
     test_floating_point<CharT>(check, check_exception, multiset{-42.5, 0.0, 1.25, 42.5});
     test_floating_point<CharT>(check, check_exception, set{-42.5l, 0.0l, 1.25l, 42.5l});
+    test_floating_point<CharT>(check, check_exception, flat_set{-42.5f, 0.0f, 1.25f, 42.5f});
+    test_floating_point<CharT>(check, check_exception, flat_multiset{-42.5, 0.0, 1.25, 42.5});
+    test_floating_point<CharT>(check, check_exception, flat_set{-42.5l, 0.0l, 1.25l, 42.5l});
 }
 
 //
@@ -1248,6 +1254,8 @@ template <class CharT, class TestFunction, class ExceptionTest>
 void test_string(TestFunction check, ExceptionTest check_exception) {
     test_string<CharT>(check, check_exception, set{STR("Hello"), STR("world")});
     test_string<CharT>(check, check_exception, set{SV("Hello"), SV("world")});
+    test_string<CharT>(check, check_exception, flat_set{STR("Hello"), STR("world")});
+    test_string<CharT>(check, check_exception, flat_set{SV("Hello"), SV("world")});
 }
 
 //
@@ -1440,6 +1448,8 @@ template <class CharT, class TestFunction, class ExceptionTest>
 void test_pair_tuple(TestFunction check, ExceptionTest check_exception) {
     test_pair_tuple<CharT>(check, check_exception, set{make_pair(1, CharT('a')), make_pair(42, CharT('*'))});
     test_pair_tuple<CharT>(check, check_exception, set{make_tuple(1, CharT('a')), make_tuple(42, CharT('*'))});
+    test_pair_tuple<CharT>(check, check_exception, flat_set{make_pair(1, CharT('a')), make_pair(42, CharT('*'))});
+    test_pair_tuple<CharT>(check, check_exception, flat_set{make_tuple(1, CharT('a')), make_tuple(42, CharT('*'))});
 }
 
 //
@@ -1558,7 +1568,7 @@ void test_tuple_int(TestFunction check, ExceptionTest check_exception) {
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void test_tuple_int_int_int(TestFunction check, ExceptionTest check_exception) {
-    set input{make_tuple(42, 99, 0), make_tuple(1, 10, 100)}; // unordered
+    flat_set input{make_tuple(42, 99, 0), make_tuple(1, 10, 100)}; // unsorted
 
     check(SV("{(1, 10, 100), (42, 99, 0)}"), SV("{}"), input);
     check(SV("{(1, 10, 100), (42, 99, 0)}^42"), SV("{}^42"), input);

From 41b353996d3682371d39840c166870dfd5812371 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Thu, 22 Jan 2026 16:19:44 +0100
Subject: [PATCH 6/9] `VSO_0429900_fast_debug_range_based_for`: test
 `flat_meow`

---
 .../test.cpp                                  | 31 ++++++++++++++++---
 1 file changed, 26 insertions(+), 5 deletions(-)

diff --git a/tests/std/tests/VSO_0429900_fast_debug_range_based_for/test.cpp b/tests/std/tests/VSO_0429900_fast_debug_range_based_for/test.cpp
index 644b6b2066b..cec16c90c34 100644
--- a/tests/std/tests/VSO_0429900_fast_debug_range_based_for/test.cpp
+++ b/tests/std/tests/VSO_0429900_fast_debug_range_based_for/test.cpp
@@ -16,6 +16,11 @@
 #include <unordered_set>
 #include <vector>
 
+#if _HAS_CXX23
+#include <flat_map>
+#include <flat_set>
+#endif // _HAS_CXX23
+
 using namespace std;
 
 #define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
@@ -31,11 +36,19 @@ void assert_range_for_impl(Range& c) {
     for (auto&& val : c) {
         STATIC_ASSERT(is_same_v<remove_reference_t<decltype(val)>, remove_reference_t<decltype(*b)>>);
         assert(b != c.end());
-        if (is_same_v<remove_const_t<Range>, vector<bool>>) {
-            assert(*b == val);
-        } else {
-            assert_same_address(*b, val);
-        }
+
+        using RC = remove_const_t<Range>;
+#if _HAS_CXX23
+        if constexpr (_Is_specialization_v<RC, flat_map> || _Is_specialization_v<RC, flat_multimap>) {
+            assert_same_address(b->first, val.first);
+            assert_same_address(b->second, val.second);
+        } else
+#endif // _HAS_CXX23
+            if (is_same_v<RC, vector<bool>>) {
+                assert(*b == val);
+            } else {
+                assert_same_address(*b, val);
+            }
 
         ++b;
     }
@@ -152,11 +165,19 @@ int main() {
     test_case_set_container<set>();
     test_case_set_container<unordered_multiset>();
     test_case_set_container<unordered_set>();
+#if _HAS_CXX23
+    test_case_set_container<flat_set>();
+    test_case_set_container<flat_multiset>();
+#endif // _HAS_CXX23
 
     test_case_map_container<map>();
     test_case_map_container<multimap>();
     test_case_map_container<unordered_map>();
     test_case_map_container<unordered_multimap>();
+#if _HAS_CXX23
+    test_case_map_container<flat_map>();
+    test_case_map_container<flat_multimap>();
+#endif // _HAS_CXX23
 
     cmatch matchResults;
     assert_range_for(matchResults);

From dd273017a08cf5767dfa9fb89af243d99bc1db22 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Thu, 29 Jan 2026 05:06:42 -0800
Subject: [PATCH 7/9] Comment implementation-specific iterator strengths.

---
 tests/std/tests/P0896R4_ranges_range_machinery/test.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp b/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp
index e29d6d99a7b..9fa2ba9176e 100644
--- a/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp
+++ b/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp
@@ -904,6 +904,7 @@ static_assert(test_std_container<std::multimap<int, int>, std::bidirectional_ite
 static_assert(test_std_container<std::multiset<int>, std::bidirectional_iterator_tag>());
 static_assert(test_std_container<std::set<int>, std::bidirectional_iterator_tag>());
 static_assert(test_std_container<std::string, std::contiguous_iterator_tag>());
+// Implementation-specific: unordered_meow uses list's iterators, so they're bidirectional instead of forward.
 static_assert(test_std_container<std::unordered_map<int, int>, std::bidirectional_iterator_tag>());
 static_assert(test_std_container<std::unordered_multimap<int, int>, std::bidirectional_iterator_tag>());
 static_assert(test_std_container<std::unordered_multiset<int>, std::bidirectional_iterator_tag>());
@@ -915,9 +916,9 @@ static_assert(test_std_container<std::wstring, std::contiguous_iterator_tag>());
 #if _HAS_CXX23
 static_assert(test_std_container<std::flat_map<int, int>, std::random_access_iterator_tag>());
 static_assert(test_std_container<std::flat_multimap<int, int>, std::random_access_iterator_tag>());
-// FIXME: Should `flat_(multi)set` iterators model `contiguous_iterator` concept when underlying does?
-// static_assert(test_std_container<std::flat_set<int>, std::random_access_iterator_tag>());
-// static_assert(test_std_container<std::flat_multiset<int>, std::random_access_iterator_tag>());
+// Implementation-specific: flat_set uses the underlying container's iterators, so they're contiguous here.
+static_assert(test_std_container<std::flat_set<int>, std::contiguous_iterator_tag>());
+static_assert(test_std_container<std::flat_multiset<int>, std::contiguous_iterator_tag>());
 #endif // _HAS_CXX23
 
 // Validate that "old" fancy pointers that fail to model contiguous_iterator don't break contiguity of containers.

From 2e320172c37147de7b16d563969c0534a19e5834 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Thu, 29 Jan 2026 05:15:02 -0800
Subject: [PATCH 8/9] Add braces. Pre-existing: Guard `<string_view>`.

---
 .../tests/VSO_0429900_fast_debug_range_based_for/test.cpp  | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/tests/std/tests/VSO_0429900_fast_debug_range_based_for/test.cpp b/tests/std/tests/VSO_0429900_fast_debug_range_based_for/test.cpp
index cec16c90c34..9197cd235c5 100644
--- a/tests/std/tests/VSO_0429900_fast_debug_range_based_for/test.cpp
+++ b/tests/std/tests/VSO_0429900_fast_debug_range_based_for/test.cpp
@@ -11,11 +11,14 @@
 #include <regex>
 #include <set>
 #include <string>
-#include <string_view>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
+#if _HAS_CXX17
+#include <string_view>
+#endif // _HAS_CXX17
+
 #if _HAS_CXX23
 #include <flat_map>
 #include <flat_set>
@@ -44,11 +47,13 @@ void assert_range_for_impl(Range& c) {
             assert_same_address(b->second, val.second);
         } else
 #endif // _HAS_CXX23
+        {
             if (is_same_v<RC, vector<bool>>) {
                 assert(*b == val);
             } else {
                 assert_same_address(*b, val);
             }
+        }
 
         ++b;
     }

From 8ead6193ea14815940af8cdd06b88033092fa489 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Thu, 29 Jan 2026 05:32:57 -0800
Subject: [PATCH 9/9] Teach P0896R4_ranges_range_machinery about contiguous
 set-like containers.

---
 tests/std/tests/P0896R4_ranges_range_machinery/test.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp b/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp
index 9fa2ba9176e..3d8dd469fe1 100644
--- a/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp
+++ b/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp
@@ -841,7 +841,11 @@ constexpr bool test_std_container() {
     }
     static_assert(test_empty<T&, true>());
     if constexpr (std::contiguous_iterator<I>) {
-        static_assert(test_data<T&, V*>());
+        if constexpr (std::is_same_v<I, CI>) {
+            static_assert(test_data<T&, V const*>());
+        } else {
+            static_assert(test_data<T&, V*>());
+        }
         static_assert(test_cdata<T&, V const*>());
     }
     static_assert(!ranges::view<T&>);