diff --git a/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp b/tests/std/tests/P0896R4_ranges_range_machinery/test.cpp
index 83bdb64bc35..3d8dd469fe1 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:
@@ -836,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&>);
@@ -899,6 +908,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>());
@@ -907,6 +917,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>());
+// 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.
 template <class T>
 struct fancy_pointer {
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>();
 }
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>();
 }
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);
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);
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..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,19 @@
 #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>
+#endif // _HAS_CXX23
+
 using namespace std;
 
 #define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
@@ -31,10 +39,20 @@ 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 +170,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);