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);
diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
new file mode 100644
index 0000000000..cebe64d3ab
--- /dev/null
+++ b/tests/std/include/test_container_requirements.hpp
@@ -0,0 +1,189 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#pragma once
+
+#include <algorithm>
+#include <cassert>
+#include <compare>
+#include <format>
+#include <iterator>
+#include <print>
+#include <type_traits>
+#include <utility>
+
+// 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(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.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>);
+    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>
+                  || 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);
+    assert(!(my_moved != s));
+
+    T my_empty{};
+    assert(my_empty.empty());
+
+    T non_empty = s;
+    my_empty.swap(non_empty);
+    assert(non_empty.empty());
+    assert(my_empty == s);
+
+    std::swap(my_empty, non_empty);
+    assert(my_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<T::size_type>(s.cend() - s.cbegin()) == s.size());
+}
+
+template <class T>
+void assert_reversible_container_requirements(const T& s) {
+    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(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>);
+}
+
+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::key_container_type>;
+    requires std::is_nothrow_swappable_v<typename T::mapped_container_type>;
+};
+
+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 <class T>
+concept has_nothrow_swappable_containers =
+    set_has_nothrow_swappable_containers<T> || map_has_nothrow_swappable_containers<T>;
+
+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 (!std::is_const_v<T>) {
+        constexpr bool is_noexcept =
+            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(std::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();
+    const 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(std::is_sorted(begin_it, end_it, val_comp));
+    if constexpr (ExpectedUnique) {
+        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);
+    }
+}
+
+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 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>);
+
+    // additionally:
+    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 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>
+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(std::same_as<std::const_iterator<const_iterator>, const_iterator>);
+    static_assert(std::is_convertible_v<iterator, const_iterator>);
+
+    // additionally:
+    static_assert(std::is_same_v<value_type, std::pair<key_type, mapped_type>>);
+}
+
+template <class T>
+void assert_three_way_comparability() {
+    using value_type = 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 3cc8cff261..c7e0aba31d 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -6,14 +6,18 @@
 #include <cassert>
 #include <concepts>
 #include <cstddef>
+#include <cstdlib>
 #include <deque>
 #include <flat_map>
 #include <functional>
 #include <memory>
+#include <print>
 #include <ranges>
 #include <type_traits>
 #include <vector>
 
+#include <test_container_requirements.hpp>
+#include <test_death.hpp>
 using namespace std;
 
 // See GH-5965: Speculative resolution of LWG-3963 "Different flat_(multi)map specializations
@@ -31,45 +35,38 @@ 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;
-}
+void assert_all_requirements(const T& s) {
+    assert_container_requirements(s);
+    assert_reversible_container_requirements(s);
+    assert_three_way_comparability<T>();
+    assert_map_requirements<T>();
 
-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>;
-}
+    assert_noexcept_requirements(s);
+    assert_noexcept_requirements(const_cast<T&>(s));
 
-template <IsFlatMap T>
-constexpr bool check_reversible_container_requirements(T&&) {
-    return check_reversible_container_requirements<T&&>();
+    assert_is_sorted_maybe_unique<_Is_specialization_v<T, flat_map>>(s);
 }
 
 template <IsFlatMap T>
-bool check_requirements(T&& obj) {
-    return check_container_requirements(forward<T>(obj)) && check_reversible_container_requirements(forward<T>(obj));
+[[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_key_content(const T& obj, const typename T::key_container_type& expected) {
-    return ranges::equal(obj.keys(), 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 check_value_content(const T& obj, const typename T::mapped_container_type& expected) {
-    return ranges::equal(obj.values(), 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);
+        println(stderr, "Actual {}", obj);
+        return false;
+    }
+    return true;
 }
 
 enum class subrange_type : bool {
@@ -89,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()) {
@@ -152,6 +149,26 @@ 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>;
+    };
+} // namespace std
+
 template <typename T>
 class Packaged {
 private:
@@ -200,141 +217,525 @@ struct TransparentPackagedCompare : PackagedCompare<T> {
     }
 };
 
+struct MyAllocatorCounter {
+    MyAllocatorCounter() : activeAllocations{MyAllocator<int>::getActiveAllocationCount()} {}
+
+    [[nodiscard]] bool check_then_reset() {
+        const bool allocated_some = MyAllocator<int>::getActiveAllocationCount() > activeAllocations;
+        activeAllocations         = MyAllocator<int>::getActiveAllocationCount();
+        return allocated_some;
+    }
+
+    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)
+    // 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>, KeyCont<int, MyAllocator<int>>, MappedCont<int, MyAllocator<int>>>;
+    using flat_multimap_my_allocator =
+        flat_multimap<int, int, less<int>, KeyCont<int, MyAllocator<int>>, MappedCont<int, MyAllocator<int>>>;
+
     {
-        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&)
+        const less<int> compare;
+        {
+            flat_map<int, int> fmap;
+            flat_map<int, int> fmap1(compare);
+
+            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_key_content(fmmap, {}));
+            assert(check_value_content(fmmap, {}));
+            assert(fmmap == fmmap1);
+        }
     }
     {
-        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},
-            }));
+        // 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};
+        {
+            flat_map fmap(keys, vals);
+            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}));
+            assert(fmap == fmap1);
+        }
+        {
+            flat_multimap fmmap(keys, vals);
+            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},
+                {
+                    {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};
-        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);
+        // 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&)
+        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>{});
+            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);
+        }
     }
     {
-        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())
+        {
+            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>{});
+
+            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);
+        }
+        {
+            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>{});
+
+            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);
+        }
+        {
+            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>>);
+        }
     }
     {
-        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
+        // 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&)
+        {
+            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>{});
+            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);
+        }
+        {
+            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>{});
+            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);
+        }
     }
-    // FIXME, test more flat_map and flat_multimap constructors
+    {
+        // 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, verify that all flat_map and flat_multimap constructors are tested
     {
         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_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_key_content(fmmap, {}));
+            assert(check_value_content(fmmap, {}));
+            assert(fmmap == fmmap1);
+        }
     }
     {
         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, {}));
         assert(check_value_content(fmmap, {}));
     }
     {
         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, {}));
         assert(check_value_content(fmmap, {}));
     }
     {
         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, {}));
         assert(check_value_content(fmmap, {}));
     }
     {
         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}));
         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},
             {
@@ -346,14 +747,12 @@ 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}));
         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},
             {
@@ -366,14 +765,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);
@@ -382,10 +781,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);
@@ -687,6 +1087,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 {};
 
@@ -759,18 +1182,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() {
@@ -794,6 +1205,79 @@ 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;
+        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) {
+                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'};
+        const pair pair0f{0, 'f'};
+        // hint is greater
+        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(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(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(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(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(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(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(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(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(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(check_content(a, {{-1, 'x'}, {-1, 'x'}, {1, 'x'}, {1, 'x'}}));
+    }
+}
+
+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>();
+    test_throwing_compare_swap_single<flat_map, KeyCont, MappedCont>();
+    test_throwing_compare_swap_single<flat_multimap, KeyCont, MappedCont>();
+    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
@@ -816,27 +1300,248 @@ 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(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(check_content(cont, {{11, 0}, {12, 0}}));
     }
 }
 
-int main() {
-    test_construction();
+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>();
+    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_map_operations_transparent<flat_map>();
+    test_map_operations_transparent<flat_multimap>();
+
     test_lookup_call_on_temporaries();
-    test_generic_count_gh_5992();
+    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 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>,
+        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>,
+
+        // Tests shared between flat_set and flat_map - violation of unique elements
+        test_death_construct_duplicates_initializer_list<cont_type::unique>,
+        test_death_construct_duplicates_iter_iter<cont_type::unique>,
+        test_death_construct_duplicates_container<cont_type::unique>,
+        test_death_replace_duplicates_container<cont_type::unique>,
+        test_death_insert_duplicates_iter_iter<cont_type::unique>,
+        test_death_insert_duplicates_range<cont_type::unique>,
+        test_death_insert_duplicates_initializer_list<cont_type::unique>,
+
+        // 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);
 }
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index f3f0fc6eee..f18ebbaf78 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>
@@ -18,6 +19,8 @@
 #include <utility>
 #include <vector>
 
+#include <test_container_requirements.hpp>
+#include <test_death.hpp>
 #define TEST_ASSERT(...) assert((__VA_ARGS__))
 
 using namespace std;
@@ -127,123 +130,17 @@ 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);
     assert_reversible_container_requirements(s);
+    assert_three_way_comparability<T>();
     assert_set_requirements<T>();
 
     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>
@@ -265,23 +162,48 @@ 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});
-    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});
+    {
+        // Test flat_set()
+        // and  flat_set(const key_compare&)
+        const lt comp;
+        {
+            flat_set<int, lt, C> fs;
+            flat_set<int, lt, C> fs1(comp);
+            assert_all_requirements_and_equals(fs, fs1, {});
+        }
+        {
+            flat_multiset<int, lt, C> fms;
+            flat_multiset<int, lt, C> fms1(comp);
+            assert_all_requirements_and_equals(fms, fms1, {});
+        }
+    }
+    {
+        // Test flat_set(const container)
+    }
+
+    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});
 
     flat_set<int> a{};
     a = {1, 7, 7, 7, 2, 100, -1};
@@ -493,6 +415,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;
+        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) {
+                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; }) {
@@ -908,11 +889,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>
@@ -923,6 +917,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};
@@ -937,6 +933,41 @@ 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
+
+namespace detail {
+    using C = flat_set<int>;
+    static_assert(same_as<C::iterator, decltype(declval<C>().erase(declval<C::iterator>()))>);
+    static_assert(same_as<C::iterator, decltype(declval<C>().erase(declval<holder<C::iterator>>()))>);
+    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>);
+    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>
 void test_erase_if() {
     constexpr int erased_result[]{1, 3};
@@ -1145,6 +1176,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
@@ -1167,18 +1199,50 @@ 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});
     }
 }
 
-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>>>();
@@ -1200,6 +1264,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();
@@ -1228,5 +1294,155 @@ int main() {
     test_set_operations_transparent<flat_multiset>();
 
     test_throwing_compare_swap();
-    test_generic_count_gh_5992();
+    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({
+
+        // 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>,
+        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>,
+
+        // Tests shared between flat_set and flat_map - violation of unique elements
+        test_death_construct_duplicates_initializer_list<cont_type::unique>,
+        test_death_construct_duplicates_iter_iter<cont_type::unique>,
+        test_death_construct_duplicates_container<cont_type::unique>,
+        test_death_replace_duplicates_container<cont_type::unique>,
+        test_death_insert_duplicates_iter_iter<cont_type::unique>,
+        test_death_insert_duplicates_range<cont_type::unique>,
+        test_death_insert_duplicates_initializer_list<cont_type::unique>,
+    });
+#endif // defined(_DEBUG)
+
+    return exec.run(argc, argv);
 }