diff --git a/tests/std/include/test_container_requirements.hpp b/tests/std/include/test_container_requirements.hpp
index cebe64d3ab1..be234339777 100644
--- a/tests/std/include/test_container_requirements.hpp
+++ b/tests/std/include/test_container_requirements.hpp
@@ -187,3 +187,21 @@ void assert_three_way_comparability() {
         static_assert(std::three_way_comparable<T>);
     }
 }
+
+class key_comparator {
+private:
+    static const auto& extract_key(const auto& obj) {
+        if constexpr (requires { obj.key; }) {
+            return obj.key;
+        } else {
+            return obj;
+        }
+    }
+
+public:
+    bool operator()(const auto& lhs, const auto& rhs) const {
+        return extract_key(lhs) < extract_key(rhs);
+    }
+
+    using is_transparent = int;
+};
diff --git a/tests/std/tests/Dev11_0437519_container_requirements/test.compile.pass.cpp b/tests/std/tests/Dev11_0437519_container_requirements/test.compile.pass.cpp
index 4cfa84a262e..d391f30b16c 100644
--- a/tests/std/tests/Dev11_0437519_container_requirements/test.compile.pass.cpp
+++ b/tests/std/tests/Dev11_0437519_container_requirements/test.compile.pass.cpp
@@ -13,7 +13,7 @@
 // A brief overview of the contents of this file:
 //
 // The first 650 lines or so of this file (everything up to the first use of DEFINE_TEST) are test
-// utilities:  stub allocators, comparers, and other kinds of types with which we can instantiate
+// utilities:  stub allocators, comparators, and other kinds of types with which we can instantiate
 // containers; test types that define a restricted set of operations; and a set of container traits
 // classes that unify the interfaces for the containers so we can use a common set of tests for
 // them (these traits also define a few useful properties for each container so we know what to
@@ -1678,7 +1678,7 @@ NOT_SUPPORTED_SPECIALIZATION(test_ordered_associative_typedefs_for_maps, tag_mul
 NOT_SUPPORTED_SPECIALIZATION(test_ordered_associative_typedefs_for_maps, tag_set);
 
 
-DEFINE_TEST(test_ordered_associative_default_constructor_with_comparer,
+DEFINE_TEST(test_ordered_associative_default_constructor_with_comparator,
 {
     // X(c) and X a(c);
     // Requires:  key_compare is CopyConstructible
@@ -1710,13 +1710,13 @@ DEFINE_TEST(test_ordered_associative_default_constructor_with_comparer,
 });
 
 
-DEFINE_TEST(test_ordered_associative_range_constructor_with_comparer, {
+DEFINE_TEST(test_ordered_associative_range_constructor_with_comparator, {
     // SPEC:  These are the only two operations for which traits are specified for key_compare, but
     // there are many other operations for which key_compare must meet other requirements (e.g. a
     // call to a.key_comp() necessitates that the key_comp type is move constructible.
     //
-    // In the rest of the tests, I have assumed std::less for the comparer, which meets any possible
-    // requirements, but it should be considered whether the comparer requirements should be more
+    // In the rest of the tests, I have assumed std::less for the comparator, which meets any possible
+    // requirements, but it should be considered whether the comparator requirements should be more
     // thoroughly specified.
 
     std::move_iterator<input_iterator<typename Traits::emplace_argument_type>> i;
@@ -1746,7 +1746,7 @@ DEFINE_TEST(test_ordered_associative_initializer_list_assign, {
 });
 
 
-DEFINE_TEST(test_ordered_associative_comparers, {
+DEFINE_TEST(test_ordered_associative_comparators, {
     // a.key_comp()
     // [No Requires clause]
     c_of_erasable const a;
@@ -1926,10 +1926,10 @@ struct check_all_ordered_associative_requirements {
     check_all_ordered_associative_requirements() {
         test_ordered_associative_typedefs<Tag>();
         test_ordered_associative_typedefs_for_maps<Tag>();
-        test_ordered_associative_default_constructor_with_comparer<Tag>();
-        test_ordered_associative_range_constructor_with_comparer<Tag>();
+        test_ordered_associative_default_constructor_with_comparator<Tag>();
+        test_ordered_associative_range_constructor_with_comparator<Tag>();
         test_ordered_associative_initializer_list_assign<Tag>();
-        test_ordered_associative_comparers<Tag>();
+        test_ordered_associative_comparators<Tag>();
         test_ordered_associative_emplace<Tag>();
         test_ordered_associative_insert<Tag>();
         test_ordered_associative_erase<Tag>();
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index fbd797b28be..54ac624422c 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -233,22 +233,6 @@ struct MyAllocatorCounter {
     size_t activeAllocations;
 };
 
-struct key_comparer {
-    const auto& extract_key(const auto& obj) const {
-        if constexpr (requires { obj.key; }) {
-            return obj.key;
-        } else {
-            return obj;
-        }
-    }
-
-    bool operator()(const auto& lhs, const auto& rhs) const {
-        return extract_key(lhs) < extract_key(rhs);
-    }
-
-    using is_transparent = int;
-};
-
 template <template <class...> class KeyCont, template <class...> class MappedCont>
 void test_construction() {
     // Using CTAD, the given MyAllocator is only used by the container when the constructor (deduction guide)
@@ -1188,7 +1172,7 @@ void test_map_operations_transparent() {
         }
     };
 
-    Map<int, char, key_comparer> fm{{0, 'a'}, {3, 'g'}, {5, 't'}};
+    Map<int, char, key_comparator> fm{{0, 'a'}, {3, 'g'}, {5, 't'}};
     assert(check_key_content(fm, {0, 3, 5}));
     assert(check_value_content(fm, {'a', 'g', 't'}));
 
@@ -1511,61 +1495,48 @@ void test_death_insert_unsorted_initializer_list() {
     cont.insert(sorted, {{137, 'a'}, {42, 'g'}, {3337, 'f'}, {15, 'r'}});
 }
 
-template <cont_type type>
 void test_death_construct_duplicates_initializer_list() {
-    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    C cont(sorted, {{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}});
+    using C = flat_map<int, char>;
+    C cont(sorted_unique, {{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}});
 }
 
-template <cont_type type>
 void test_death_construct_duplicates_iter_iter() {
-    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    vector<typename C::value_type> values{{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}};
-    C cont(sorted, values.begin(), values.end());
+    using C = flat_map<int, char>;
+    vector<C::value_type> values{{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}};
+    C cont(sorted_unique, values.begin(), values.end());
 }
 
-template <cont_type type>
 void test_death_construct_duplicates_container() {
-    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    typename C::key_container_type keys{42, 137, 137, 3337};
-    typename C::mapped_container_type mapped{'a', 'g', 'f', 'r'};
-    C cont(sorted, keys, mapped);
+    using C = flat_map<int, char>;
+    C::key_container_type keys{42, 137, 137, 3337};
+    C::mapped_container_type mapped{'a', 'g', 'f', 'r'};
+    C cont(sorted_unique, keys, mapped);
 }
 
-template <cont_type type>
 void test_death_replace_duplicates_container() {
-    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
+    using C = flat_map<int, char>;
     C cont;
     cont.replace({42, 137, 137, 3337}, {'a', 'g', 'f', 'r'});
 }
 
-template <cont_type type>
 void test_death_insert_duplicates_iter_iter() {
-    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    vector<typename C::value_type> values{{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}};
+    using C = flat_map<int, char>;
+    vector<C::value_type> values{{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}};
     C cont;
-    cont.insert(sorted, values.begin(), values.end());
+    cont.insert(sorted_unique, values.begin(), values.end());
 }
 
-template <cont_type type>
 void test_death_insert_duplicates_range() {
-    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    vector<typename C::value_type> values{{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}};
+    using C = flat_map<int, char>;
+    vector<C::value_type> values{{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}};
     C cont;
-    cont.insert_range(sorted, values);
+    cont.insert_range(sorted_unique, values);
 }
 
-template <cont_type type>
 void test_death_insert_duplicates_initializer_list() {
-    using C = conditional_t<type == cont_type::unique, flat_map<int, char>, flat_multimap<int, char>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    using C = flat_map<int, char>;
     C cont;
-    cont.insert(sorted, {{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}});
+    cont.insert(sorted_unique, {{42, 'a'}, {137, 'g'}, {137, 'f'}, {3337, 'r'}});
 }
 
 template <cont_type type>
@@ -1640,13 +1611,13 @@ int main(int argc, char* argv[]) {
         test_death_insert_unsorted_initializer_list<cont_type::multi>,
 
         // Tests shared between flat_set and flat_map - violation of unique elements
-        test_death_construct_duplicates_initializer_list<cont_type::unique>,
-        test_death_construct_duplicates_iter_iter<cont_type::unique>,
-        test_death_construct_duplicates_container<cont_type::unique>,
-        test_death_replace_duplicates_container<cont_type::unique>,
-        test_death_insert_duplicates_iter_iter<cont_type::unique>,
-        test_death_insert_duplicates_range<cont_type::unique>,
-        test_death_insert_duplicates_initializer_list<cont_type::unique>,
+        test_death_construct_duplicates_initializer_list,
+        test_death_construct_duplicates_iter_iter,
+        test_death_construct_duplicates_container,
+        test_death_replace_duplicates_container,
+        test_death_insert_duplicates_iter_iter,
+        test_death_insert_duplicates_range,
+        test_death_insert_duplicates_initializer_list,
 
         // Tests not present in flat_set - mismatch of length of key and mapped containers
         test_death_different_size_ctor<cont_type::unique>,
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index f18ebbaf78e..242a27d47ea 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -3,13 +3,12 @@
 
 #include <algorithm>
 #include <cassert>
-#include <climits>
 #include <concepts>
 #include <cstdlib>
 #include <deque>
 #include <flat_set>
 #include <functional>
-#include <iostream>
+#include <limits>
 #include <memory>
 #include <print>
 #include <random>
@@ -24,12 +23,11 @@
 #define TEST_ASSERT(...) assert((__VA_ARGS__))
 
 using namespace std;
-using namespace ranges;
 
 enum class iterator_pair_construction : bool { no_allocator, with_allocator };
 
 template <class R, class T>
-concept container_compatible_range = input_range<R> && convertible_to<range_reference_t<R>, T>;
+concept container_compatible_range = ranges::input_range<R> && convertible_to<ranges::range_reference_t<R>, T>;
 
 template <class T, class Alloc = allocator<T>,
     iterator_pair_construction Choice = iterator_pair_construction::with_allocator>
@@ -68,7 +66,7 @@ class alternative_vector : private vector<T, Alloc> { // not allocator-aware, bu
     constexpr alternative_vector(allocator_arg_t, const type_identity_t<Alloc>& a, const alternative_vector& other)
         : base_type(other, a) {}
     constexpr alternative_vector(allocator_arg_t, const type_identity_t<Alloc>& a, alternative_vector&& other)
-        : base_type(std::move(other), a) {}
+        : base_type(move(other), a) {}
     constexpr explicit alternative_vector(initializer_list<T> il) : base_type(il) {}
 
     alternative_vector(const alternative_vector&) = default;
@@ -143,98 +141,120 @@ void assert_all_requirements(const T& s) {
     assert_is_sorted_maybe_unique<_Is_specialization_v<T, flat_set>>(s);
 }
 
-template <class T>
-void assert_all_requirements_and_equals(const T& s, const initializer_list<typename T::value_type>& il) {
+template <class T, class U = initializer_list<typename T::value_type>>
+void assert_all_requirements_and_equals(const T& s, const U& correct) {
     assert_all_requirements(s);
 
-    if (!std::equal(s.begin(), s.end(), il.begin(), il.end())) {
-        cout << "Expected: {";
-        for (auto&& e : il) {
-            cout << e << ", ";
-        }
-        cout << "}" << endl;
-        cout << "Got:      {";
-        for (auto&& e : s) {
-            cout << e << ", ";
-        }
-        cout << "}" << endl;
+    if (!ranges::equal(s, correct)) {
+        println("Unexpected content!\nExpected {}\nActual {}", correct, s);
         assert(false);
     }
 }
 
-template <class T, class U>
-void assert_all_requirements_and_equals(
-    const T& first, const U& second, const initializer_list<typename T::value_type>& il) {
-    assert_all_requirements_and_equals(first, il);
-    assert_all_requirements_and_equals(second, il);
-    assert(first == second);
-}
-
 template <class C>
 void test_constructors() {
-    using lt = std::less<int>;
-    using gt = std::greater<int>;
+    using lt = less<int>;
+    using gt = greater<int>;
+
+    // Test flat_set()
+    // and  flat_set(const key_compare&)
+    assert_all_requirements_and_equals(flat_set<int, lt, C>(), {});
+    assert_all_requirements_and_equals(flat_multiset<int, lt, C>(), {});
+    assert_all_requirements_and_equals(flat_set<int, lt, C>(lt{}), {});
+    assert_all_requirements_and_equals(flat_multiset<int, lt, C>(lt{}), {});
 
     {
-        // Test flat_set()
-        // and  flat_set(const key_compare&)
-        const lt comp;
-        {
-            flat_set<int, lt, C> fs;
-            flat_set<int, lt, C> fs1(comp);
-            assert_all_requirements_and_equals(fs, fs1, {});
-        }
-        {
-            flat_multiset<int, lt, C> fms;
-            flat_multiset<int, lt, C> fms1(comp);
-            assert_all_requirements_and_equals(fms, fms1, {});
-        }
-    }
-    {
-        // Test flat_set(const container)
+        // Test flat_set(container_type, const key_compare& = key_compare())
+        flat_set fs1(C{3, 7, 1, 85, 222, 1});
+        flat_multiset fms1(C{3, 7, 1, 85, 7, 222, 1});
+        flat_set fs2(C{1, 2, 3, 3}, gt{});
+        flat_multiset fms2(C{1, 1, 2, 3}, gt{});
+        assert_all_requirements_and_equals(fs1, {1, 3, 7, 85, 222});
+        assert_all_requirements_and_equals(fms1, {1, 1, 3, 7, 7, 85, 222});
+        assert_all_requirements_and_equals(fs2, {3, 2, 1});
+        assert_all_requirements_and_equals(fms2, {3, 2, 1, 1});
+
+        // Test flat_set(const flat_set&)
+        // and  flat_set(flat_set&&)
+        flat_set fs3(fs1);
+        flat_multiset fms3(fms1);
+        flat_set fs4(move(fs2));
+        flat_multiset fms4(move(fms2));
+        assert_all_requirements_and_equals(fs3, {1, 3, 7, 85, 222});
+        assert_all_requirements_and_equals(fms3, {1, 1, 3, 7, 7, 85, 222});
+        assert_all_requirements_and_equals(fs4, {3, 2, 1});
+        assert_all_requirements_and_equals(fms4, {3, 2, 1, 1});
     }
 
-    assert_all_requirements_and_equals(flat_set(C{3, 7, 1, 85, 222, 1}), {1, 3, 7, 85, 222});
-    assert_all_requirements_and_equals(flat_multiset(C{3, 7, 1, 85, 7, 222, 1}), {1, 1, 3, 7, 7, 85, 222});
-    assert_all_requirements_and_equals(flat_set(C{1, 2, 3, 3}, gt{}), {3, 2, 1});
-    assert_all_requirements_and_equals(flat_multiset(C{1, 1, 2, 3}, gt{}), {3, 2, 1, 1});
+    // Test flat_set(sorted_unique_t, container_type, const key_compare& = key_compare())
+    assert_all_requirements_and_equals(flat_set(sorted_unique, C{1, 200, 30000}), {1, 200, 30000});
+    assert_all_requirements_and_equals(flat_multiset(sorted_equivalent, C{-1, 3, 3}), {-1, 3, 3});
     assert_all_requirements_and_equals(flat_set(sorted_unique, C{30000, 200, 1}, gt{}), {30000, 200, 1});
     assert_all_requirements_and_equals(flat_multiset(sorted_equivalent, C{3, 3, -1}, gt{}), {3, 3, -1});
-    assert_all_requirements_and_equals(flat_set<int, gt, C>({30000, 200, 1}, gt{}), {30000, 200, 1});
-    assert_all_requirements_and_equals(flat_multiset<int, gt, C>({3, 3, -1}, gt{}), {3, 3, -1});
+
+    const int arr[] = {2, 7, 18, 28, 18, 28, 45, 90, 45, 23};
+
+    // Test flat_set(InIt, InIt, const key_compare& = key_compare())
+    assert_all_requirements_and_equals(flat_set<int, lt, C>(begin(arr), end(arr)), {2, 7, 18, 23, 28, 45, 90});
+    assert_all_requirements_and_equals(
+        flat_multiset<int, lt, C>(begin(arr), end(arr)), {2, 7, 18, 18, 23, 28, 28, 45, 45, 90});
+    assert_all_requirements_and_equals(flat_set<int, gt, C>(begin(arr), end(arr), gt{}), {90, 45, 28, 23, 18, 7, 2});
+    assert_all_requirements_and_equals(
+        flat_multiset<int, gt, C>(begin(arr), end(arr), gt{}), {90, 45, 45, 28, 28, 23, 18, 18, 7, 2});
+
+    {
+        // Test flat_set(sorted_unique_t, InIt, InIt, const key_compare& = key_compare())
+        const int ua[] = {10, 20, 30}; // unique ascending
+        const int ea[] = {40, 50, 50, 60, 60, 60}; // equivalent ascending
+        const int ud[] = {66, 55, 44}; // unique descending
+        const int ed[] = {33, 22, 22, 11, 11, 11}; // equivalent descending
+        assert_all_requirements_and_equals(flat_set<int, lt, C>(sorted_unique, begin(ua), end(ua)), ua);
+        assert_all_requirements_and_equals(flat_multiset<int, lt, C>(sorted_equivalent, begin(ea), end(ea)), ea);
+        assert_all_requirements_and_equals(flat_set<int, gt, C>(sorted_unique, begin(ud), end(ud), gt{}), ud);
+        assert_all_requirements_and_equals(flat_multiset<int, gt, C>(sorted_equivalent, begin(ed), end(ed), gt{}), ed);
+    }
+
+    // Test flat_set(from_range_t, R&&)
+    // and  flat_set(from_range_t, R&&, const key_compare&)
+    assert_all_requirements_and_equals(flat_set<int, lt, C>(from_range, arr), {2, 7, 18, 23, 28, 45, 90});
+    assert_all_requirements_and_equals(
+        flat_multiset<int, lt, C>(from_range, arr), {2, 7, 18, 18, 23, 28, 28, 45, 45, 90});
+    assert_all_requirements_and_equals(flat_set<int, gt, C>(from_range, arr, gt{}), {90, 45, 28, 23, 18, 7, 2});
+    assert_all_requirements_and_equals(
+        flat_multiset<int, gt, C>(from_range, arr, gt{}), {90, 45, 45, 28, 28, 23, 18, 18, 7, 2});
+
+    // Test flat_set(initializer_list<value_type>, const key_compare& = key_compare())
+    assert_all_requirements_and_equals(flat_set<int, lt, C>({3, 7, 1, 85, 222, 1}), {1, 3, 7, 85, 222});
+    assert_all_requirements_and_equals(flat_multiset<int, lt, C>({3, 7, 1, 85, 7, 222, 1}), {1, 1, 3, 7, 7, 85, 222});
+    assert_all_requirements_and_equals(flat_set<int, gt, C>({1, 2, 3, 3}, gt{}), {3, 2, 1});
+    assert_all_requirements_and_equals(flat_multiset<int, gt, C>({1, 1, 2, 3}, gt{}), {3, 2, 1, 1});
+
+    // Test flat_set(sorted_unique_t, initializer_list<value_type>, const key_compare& = key_compare())
+    assert_all_requirements_and_equals(flat_set<int, lt, C>(sorted_unique, {1, 200, 30000}), {1, 200, 30000});
+    assert_all_requirements_and_equals(flat_multiset<int, lt, C>(sorted_equivalent, {-1, 3, 3}), {-1, 3, 3});
     assert_all_requirements_and_equals(flat_set<int, gt, C>(sorted_unique, {30000, 200, 1}, gt{}), {30000, 200, 1});
     assert_all_requirements_and_equals(flat_multiset<int, gt, C>(sorted_equivalent, {3, 3, -1}, gt{}), {3, 3, -1});
-
-    flat_set<int> a{};
-    a = {1, 7, 7, 7, 2, 100, -1};
-    assert_all_requirements_and_equals(a, {-1, 1, 2, 7, 100});
-    assert_all_requirements_and_equals(flat_set<int>(a, allocator<int>{}), {-1, 1, 2, 7, 100});
-    assert_all_requirements_and_equals(flat_set<int>(std::move(a), allocator<int>{}), {-1, 1, 2, 7, 100});
-    flat_multiset<int> b{};
-    b = {1, 7, 7, 7, 2, 100, -1};
-    assert_all_requirements_and_equals(b, {-1, 1, 2, 7, 7, 7, 100});
-    assert_all_requirements_and_equals(flat_multiset<int>(b, allocator<int>{}), {-1, 1, 2, 7, 7, 7, 100});
-    assert_all_requirements_and_equals(flat_multiset<int>(std::move(b), allocator<int>{}), {-1, 1, 2, 7, 7, 7, 100});
 }
 
 template <iterator_pair_construction Choice>
 void test_allocator_extended_constructors() {
     using vec = alternative_vector<int, allocator<int>, Choice>;
     constexpr allocator<int> ator;
-    constexpr std::less<int> comp;
+    constexpr less<int> comp;
     {
-        using fs = flat_set<int, std::less<int>, vec>;
+        using fs = flat_set<int, less<int>, vec>;
 
         fs s{3, 7, 1, 85, 222, 1};
         fs s_expected{1, 3, 7, 85, 222};
         vec v_raw{3, 7, 1, 85, 222, 1};
         vec v_sorted_unique{1, 3, 7, 85, 222};
 
+        TEST_ASSERT(fs{ator} == fs{});
         TEST_ASSERT(fs{comp, ator} == fs{});
 
         TEST_ASSERT(fs{s, ator} == s_expected);
         TEST_ASSERT(fs{s_expected, ator} == s_expected);
-        TEST_ASSERT(fs{std::move(s), ator} == s_expected);
+        TEST_ASSERT(fs{move(s), ator} == s_expected);
         TEST_ASSERT(fs{fs{s_expected}, ator} == s_expected);
 
         TEST_ASSERT(fs{v_raw, ator} == s_expected);
@@ -258,18 +278,19 @@ void test_allocator_extended_constructors() {
         }
     }
     {
-        using fms = flat_multiset<int, std::less<int>, vec>;
+        using fms = flat_multiset<int, less<int>, vec>;
 
         fms s{3, 7, 1, 85, 222, 1};
         fms s_expected{1, 1, 3, 7, 85, 222};
         vec v_raw{3, 7, 1, 85, 222, 1};
         vec v_sorted_eq{1, 1, 3, 7, 85, 222};
 
+        TEST_ASSERT(fms{ator} == fms{});
         TEST_ASSERT(fms{comp, ator} == fms{});
 
         TEST_ASSERT(fms{s, ator} == s_expected);
         TEST_ASSERT(fms{s_expected, ator} == s_expected);
-        TEST_ASSERT(fms{std::move(s), ator} == s_expected);
+        TEST_ASSERT(fms{move(s), ator} == s_expected);
         TEST_ASSERT(fms{fms{s_expected}, ator} == s_expected);
 
         TEST_ASSERT(fms{v_raw, ator} == s_expected);
@@ -294,6 +315,48 @@ void test_allocator_extended_constructors() {
     }
 }
 
+template <class T>
+void test_iterators_and_capacity() {
+    T t{11, 22, 33, 44};
+    const T& c = t;
+
+    {
+        const int arr[]{11, 22, 33, 44};
+        assert(equal(t.begin(), t.end(), begin(arr), end(arr)));
+        assert(equal(c.begin(), c.end(), begin(arr), end(arr)));
+        assert(equal(t.cbegin(), t.cend(), begin(arr), end(arr)));
+        assert(equal(c.cbegin(), c.cend(), begin(arr), end(arr)));
+    }
+    {
+        const int rev[]{44, 33, 22, 11};
+        assert(equal(t.rbegin(), t.rend(), begin(rev), end(rev)));
+        assert(equal(c.rbegin(), c.rend(), begin(rev), end(rev)));
+        assert(equal(t.crbegin(), t.crend(), begin(rev), end(rev)));
+        assert(equal(c.crbegin(), c.crend(), begin(rev), end(rev)));
+    }
+
+    {
+        const T zero;
+
+        assert(!t.empty());
+        assert(zero.empty());
+
+        assert(t.size() == 4);
+        assert(zero.size() == 0);
+
+        assert(t.max_size() > 10);
+        assert(zero.max_size() > 10);
+    }
+
+    // Finally, test replace() and clear().
+    typename T::container_type primes{17, 29, 47};
+    t.replace(move(primes));
+    assert(t.size() == 3);
+    assert(*t.begin() == 17);
+    t.clear();
+    assert(t.empty());
+}
+
 template <template <class...> class Set>
 void test_always_reversible() {
     // Test that flat_meow is unconditionally reversible.
@@ -312,7 +375,7 @@ void test_always_reversible() {
         using base::base;
     };
 
-    Set<int, std::greater<int>, not_reversible> fs({1, 2, 3});
+    Set<int, greater<int>, not_reversible> fs({1, 2, 3});
     assert_all_requirements_and_equals(fs, {3, 2, 1});
     assert(fs.rbegin() + 3 == fs.rend());
     assert(fs.crend() - fs.crbegin() == 3);
@@ -320,7 +383,7 @@ void test_always_reversible() {
 
 template <class C>
 void test_insert_1() {
-    using lt = std::less<int>;
+    using lt = less<int>;
 
     const vector<int> vec{0, 1, 2};
     {
@@ -375,7 +438,7 @@ void test_insert_1() {
 
 template <class C>
 void test_insert_2() {
-    using lt = std::less<int>;
+    using lt = less<int>;
 
     const int val = 1;
     {
@@ -403,22 +466,37 @@ void test_insert_2() {
         assert_all_requirements_and_equals(a, {0, 0, 0, 1, 5, 6});
     }
 
-    // TRANSITION, too simple
-    using gt = std::greater<int>;
+    using gt = greater<int>;
+    {
+        flat_set<int, gt, C> a{5, 7, 9};
+        assert_all_requirements_and_equals(a, {9, 7, 5});
+        a.emplace_hint(a.end());
+        assert_all_requirements_and_equals(a, {9, 7, 5, 0});
+        a.emplace_hint(a.begin() + 1, 8);
+        assert_all_requirements_and_equals(a, {9, 8, 7, 5, 0});
+        a.insert(a.begin() + 3, 6);
+        assert_all_requirements_and_equals(a, {9, 8, 7, 6, 5, 0});
+        a.insert(a.end() - 1, val);
+        assert_all_requirements_and_equals(a, {9, 8, 7, 6, 5, 1, 0});
+    }
     {
-        flat_set<int, gt, C> a{0, 5};
-        assert_all_requirements_and_equals(a, {5, 0});
-        a.insert(a.begin(), 3);
-        assert_all_requirements_and_equals(a, {5, 3, 0});
-        a.insert(a.end(), 4);
-        assert_all_requirements_and_equals(a, {5, 4, 3, 0});
+        flat_multiset<int, gt, C> a{3, 1, 4, 1, 5, 9};
+        assert_all_requirements_and_equals(a, {9, 5, 4, 3, 1, 1});
+        a.emplace_hint(a.end());
+        assert_all_requirements_and_equals(a, {9, 5, 4, 3, 1, 1, 0});
+        a.emplace_hint(a.begin() + 2, 4);
+        assert_all_requirements_and_equals(a, {9, 5, 4, 4, 3, 1, 1, 0});
+        a.insert(a.begin() + 1, 6);
+        assert_all_requirements_and_equals(a, {9, 6, 5, 4, 4, 3, 1, 1, 0});
+        a.insert(a.end() - 3, val);
+        assert_all_requirements_and_equals(a, {9, 6, 5, 4, 4, 3, 1, 1, 1, 0});
     }
 }
 
 // Test that hint to emplace/insert is respected, when possible; check returned iterator
 template <class C>
 void test_insert_hint_is_respected() {
-    using lt = std::less<int>;
+    using lt = less<int>;
 
     {
         flat_multiset<int, lt, C> a{-1, -1, 1, 1};
@@ -473,32 +551,15 @@ void test_insert_hint_is_respected() {
     }
 }
 
-
-struct key_comparer {
-    const auto& extract_key(const auto& obj) const {
-        if constexpr (requires { obj.key; }) {
-            return obj.key;
-        } else {
-            return obj;
-        }
-    }
-
-    bool operator()(const auto& lhs, const auto& rhs) const {
-        return extract_key(lhs) < extract_key(rhs);
-    }
-
-    using is_transparent = int;
-};
-
-void test_comparer_application() {
-    // The set must rely on its comparer to do the comparisons.
+void test_comparator_application() {
+    // The set must rely on its comparator to do the comparisons.
     struct incomparable {
         int key;
         bool operator<(const incomparable&) const  = delete;
         bool operator==(const incomparable&) const = delete;
     };
 
-    flat_set<incomparable, key_comparer> fs{{0}, {3}, {1}, {0}, {5}};
+    flat_set<incomparable, key_comparator> fs{{0}, {3}, {1}, {0}, {5}};
     assert(fs.contains(0));
     assert(!fs.contains(2));
     fs.insert(fs.begin(), incomparable{4});
@@ -524,7 +585,7 @@ void test_insert_transparent() {
         }
     };
 
-    flat_set<int, key_comparer> fs{0, 3, 5};
+    flat_set<int, key_comparator> fs{0, 3, 5};
     assert_all_requirements_and_equals(fs, {0, 3, 5});
     detect_conversion detector{3};
 
@@ -555,20 +616,20 @@ void test_insert_transparent() {
     assert(detector.converted);
 }
 
-void test_insert_using_invalid_hint() {
-    mt19937 eng(42);
-
-    uniform_int_distribution<int> dist_seq(0, 20);
-
+void test_insert_using_invalid_hint(mt19937_64& eng) {
     vector<int> seq(200);
-    for (int& val : seq) {
-        val = dist_seq(eng);
+
+    {
+        uniform_int_distribution<int> dist_seq(0, 20);
+        for (auto& val : seq) {
+            val = dist_seq(eng);
+        }
     }
 
     {
         flat_multiset<int> with_hint;
         flat_multiset<int> no_hint;
-        for (const int val : seq) {
+        for (const auto& val : seq) {
             uniform_int_distribution<int> dist_idx(0, static_cast<int>(with_hint.size()));
             auto random_hint = with_hint.begin() + dist_idx(eng);
             with_hint.insert(random_hint, val);
@@ -581,7 +642,7 @@ void test_insert_using_invalid_hint() {
     {
         flat_set<int> with_hint;
         flat_set<int> no_hint;
-        for (const int val : seq) {
+        for (const auto& val : seq) {
             uniform_int_distribution<int> dist_idx(0, static_cast<int>(with_hint.size()));
             auto random_hint = with_hint.begin() + dist_idx(eng);
             with_hint.insert(random_hint, val);
@@ -592,7 +653,7 @@ void test_insert_using_invalid_hint() {
     }
 }
 
-void test_insert_upper_bound() {
+void test_insert_upper_bound(mt19937_64& eng) {
     // For flat_multiset's single-element insertion, the key should be inserted before the upper_bound.
     struct test_position {
         int key;
@@ -600,7 +661,6 @@ void test_insert_upper_bound() {
         bool operator==(const test_position&) const = default;
     };
 
-    mt19937 eng(24);
     uniform_int_distribution<int> dist_seq(0, 20);
 
     vector<test_position> seq(200);
@@ -609,20 +669,20 @@ void test_insert_upper_bound() {
         extra = e++;
     }
 
-    flat_multiset<test_position, key_comparer> fs;
+    flat_multiset<test_position, key_comparator> fs;
     for (const auto& val : seq) {
         fs.insert(val);
     }
 
     // The result should be identical to as if doing stable_sort on seq.
-    ranges::stable_sort(seq, key_comparer{});
+    ranges::stable_sort(seq, key_comparator{});
     assert(ranges::equal(fs, seq));
 }
 
 template <class T>
 void test_spaceship_operator() {
     static constexpr bool multi  = _Is_specialization_v<T, flat_multiset>;
-    static constexpr bool invert = is_same_v<typename T::key_compare, std::greater<typename T::key_type>>;
+    static constexpr bool invert = is_same_v<typename T::key_compare, greater<typename T::key_type>>;
 
     T a{3, 2, 2, 1};
     T b{1, 2, 3};
@@ -637,10 +697,16 @@ void test_spaceship_operator() {
 
     T f{1, 2, 3, 4};
     assert((f <=> a) == strong_ordering::greater);
+
+    // also test equality
+    assert(f == f);
+    assert(!(f != f));
+    assert(!(f == a));
+    assert(f != a);
 }
 
 template <class T>
-struct proxy_comparer {
+struct proxy_comparator {
     bool operator()(const T& lhs, const T& rhs) const {
         return m_less ? (lhs < rhs) : (lhs > rhs);
     }
@@ -648,10 +714,10 @@ struct proxy_comparer {
     bool m_less = true;
 };
 
-void test_non_static_comparer() {
-    flat_set<int, proxy_comparer<int>> a{3, 2, 2, 1};
+void test_non_static_comparator() {
+    flat_set<int, proxy_comparator<int>> a{3, 2, 2, 1};
     assert_all_requirements_and_equals(a, {1, 2, 3});
-    auto b = flat_set<int, proxy_comparer<int>>({-1, 5, 9, 9, 9, 9, 9}, proxy_comparer<int>{.m_less = false});
+    flat_set<int, proxy_comparator<int>> b({-1, 5, 9, 9, 9, 9, 9}, proxy_comparator<int>{.m_less = false});
     assert_all_requirements_and_equals(b, {9, 5, -1});
 
     auto aBackup = a;
@@ -660,7 +726,7 @@ void test_non_static_comparer() {
     a.insert_range(vector{7, 7, 3, 3, 2});
     assert_all_requirements_and_equals(a, {9, 7, 5, 3, 2, -1});
 
-    a = std::move(aBackup);
+    a = move(aBackup);
     assert_all_requirements_and_equals(a, {1, 2, 3});
 
     a.insert(-100);
@@ -697,9 +763,9 @@ void test_extract_1() {
     };
 
     will_throw = false;
-    Set<int, std::less<int>, test_exception> fs{4, 3, 2, 1};
+    Set<int, less<int>, test_exception> fs{4, 3, 2, 1};
     assert_all_requirements_and_equals(fs, {1, 2, 3, 4});
-    auto extr = std::move(fs).extract();
+    auto extr = move(fs).extract();
     assert(ranges::equal(extr, vector{1, 2, 3, 4}));
     assert_all_requirements_and_equals(fs, {}); // assert empty
 
@@ -707,7 +773,7 @@ void test_extract_1() {
     assert_all_requirements_and_equals(fs, {1, 2, 3, 4});
     try {
         will_throw = true;
-        (void) std::move(fs).extract();
+        (void) move(fs).extract();
     } catch (...) {
         will_throw = false;
         assert_all_requirements_and_equals(fs, {}); // assert empty
@@ -737,16 +803,16 @@ void test_extract_2() {
         }
     };
 
-    Set<int, std::less<int>, always_copy> fs{4, 3, 2, 1};
+    Set<int, less<int>, always_copy> fs{4, 3, 2, 1};
     assert_all_requirements_and_equals(fs, {1, 2, 3, 4});
-    auto extr = std::move(fs).extract();
+    auto extr = move(fs).extract();
     assert(ranges::equal(extr, vector{1, 2, 3, 4}));
     assert_all_requirements_and_equals(fs, {}); // assert empty
 }
 
 void test_invariant_robustness() {
     static int copy_limit   = 2;
-    constexpr int unlimited = INT_MAX;
+    constexpr int unlimited = (numeric_limits<int>::max)();
 
     struct odd_key {
         static void countdown() {
@@ -796,34 +862,34 @@ void test_invariant_robustness() {
         using base::base;
         odd_container(const odd_container&) = default;
 
-        // this copy-assignment cannot provide strong-guarantee for `this`:
+        // this copy assignment operator cannot provide the strong guarantee for `this`:
         odd_container& operator=(const odd_container& other) {
             resize(other.size());
-            std::copy(other.begin(), other.end(), begin());
+            copy(other.begin(), other.end(), begin());
             return *this;
         }
 
-        // this move-ctor cannot provide strong-guarantee for `other`, and even successful, will leave elements of
-        // `other` in moved-from state:
+        // this move ctor cannot provide the strong guarantee for `other`,
+        // and even if it is successful, it will leave the elements of `other` in a moved-from state:
         odd_container(odd_container&& other) {
             reserve(other.size());
             for (auto& e : other) {
-                push_back(std::move(e));
+                push_back(move(e));
             }
         }
 
-        // this move-assignment cannot provide strong-guarantee for `this` and `other`, and even successful, will leave
-        // elements of `other` in moved-from state:
+        // this move assignment operator cannot provide the strong guarantee for `this` and `other`,
+        // and even if it is successful, it will leave the elements of `other` in a moved-from state:
         odd_container& operator=(odd_container&& other) {
             resize(other.size());
-            std::move(other.begin(), other.end(), begin());
+            move(other.begin(), other.end(), begin());
             return *this;
         }
     };
 
-    using SetT = flat_set<odd_key, key_comparer, odd_container>;
+    using SetT = flat_set<odd_key, key_comparator, odd_container>;
 
-    // copy-assignment
+    // copy assignment
     {
         copy_limit = unlimited;
         SetT fs1{0, 1, 2, 3, 4};
@@ -843,11 +909,12 @@ void test_invariant_robustness() {
         }
         assert(caught);
     }
-    // move-ctor
+
+    // move ctor
     {
         copy_limit = unlimited;
         SetT fs1{0, 1, 2, 3, 4};
-        SetT fs2{std::move(fs1)};
+        SetT fs2{move(fs1)};
 
         assert_all_requirements(fs1);
         assert(ranges::equal(fs2, vector{0, 1, 2, 3, 4}, {}, &odd_key::key));
@@ -855,7 +922,7 @@ void test_invariant_robustness() {
         bool caught = false;
         try {
             copy_limit = 2;
-            SetT fs3{std::move(fs2)}; // will throw after moving 2 odd_key.
+            SetT fs3{move(fs2)}; // will throw after moving 2 odd_key.
         } catch (...) {
             copy_limit = unlimited;
             assert_all_requirements(fs2);
@@ -863,13 +930,14 @@ void test_invariant_robustness() {
         }
         assert(caught);
     }
-    // move-assignment
+
+    // move assignment
     {
         copy_limit = unlimited;
         SetT fs1{0, 1, 2, 3, 4};
         SetT fs2;
         SetT fs3{5, 6, 7, 8, 9};
-        fs2 = std::move(fs1);
+        fs2 = move(fs1);
 
         assert_all_requirements(fs1);
         assert(ranges::equal(fs2, vector{0, 1, 2, 3, 4}, {}, &odd_key::key));
@@ -878,7 +946,7 @@ void test_invariant_robustness() {
         bool caught = false;
         try {
             copy_limit = 2;
-            fs2        = std::move(fs3); // will throw after moving 2 odd_key.
+            fs2        = move(fs3); // will throw after moving 2 odd_key.
         } catch (...) {
             copy_limit = unlimited;
             assert_all_requirements(fs2);
@@ -893,7 +961,7 @@ void test_erase_1() {
     flat_set<int> fs{1};
     assert(1 == fs.erase(1));
     assert_all_requirements_and_equals(fs, {});
-    int numbers[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+    const int numbers[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
     fs.insert_range(numbers);
     assert_all_requirements_and_equals(fs, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
     fs.insert_range(numbers);
@@ -913,17 +981,17 @@ template <class T>
 struct holder {
     T t;
     operator T() && {
-        return std::move(t);
+        return move(t);
     }
 };
 
 static_assert(is_convertible_v<holder<flat_set<int>::const_iterator>, flat_set<int>::const_iterator>);
 
 void test_erase_2() {
-    using C = flat_set<int, std::less<>>;
+    using C = flat_set<int, less<>>;
     C fs{0, 1, 2, 3};
     assert_all_requirements_and_equals(fs, {0, 1, 2, 3});
-    // this should be allowed per P2077R3:
+    // this should be allowed per N5032 [associative.reqmts.general]/7.23.2 and /122-125:
     fs.erase(holder<C::const_iterator>{fs.cbegin()});
     assert_all_requirements_and_equals(fs, {1, 2, 3});
     fs.erase(holder<C::iterator>{fs.begin()});
@@ -933,17 +1001,16 @@ void test_erase_2() {
     assert_all_requirements_and_equals(fs, {3});
 }
 
-template <class Cont, class OtherKey>
-concept can_erase_key = requires(Cont c, OtherKey key) {
-    { c.erase(key) } -> same_as<typename Cont::size_type>;
-};
-template <class Cont>
-concept can_erase_iterator_holder = requires(Cont c) {
-    { c.erase(holder<typename Cont::const_iterator>{c.begin()}) } -> same_as<typename Cont::iterator>;
-};
-// Note that std::less<T> is not transparent, std::less<> and ranges::less are
+namespace test_erase_compile_time {
+    template <class Cont, class OtherKey>
+    concept can_erase_key = requires(Cont c, OtherKey key) {
+        { c.erase(key) } -> same_as<typename Cont::size_type>;
+    };
+    template <class Cont>
+    concept can_erase_iterator_holder = requires(Cont c) {
+        { c.erase(holder<typename Cont::const_iterator>{c.begin()}) } -> same_as<typename Cont::iterator>;
+    };
 
-namespace detail {
     using C = flat_set<int>;
     static_assert(same_as<C::iterator, decltype(declval<C>().erase(declval<C::iterator>()))>);
     static_assert(same_as<C::iterator, decltype(declval<C>().erase(declval<holder<C::iterator>>()))>);
@@ -953,20 +1020,23 @@ namespace detail {
     static_assert(same_as<C::size_type, decltype(declval<C>().erase(declval<holder<int>>()))>);
     static_assert(same_as<C::size_type, decltype(declval<C>().erase(declval<int>()))>);
 
+    // Note that std::less<T> is not transparent, while std::less<> and ranges::less are
+
     // erase key_type
-    static_assert(can_erase_key<flat_set<int, std::less<int>>, int>);
-    static_assert(can_erase_key<flat_set<int, std::less<>>, int>);
+    static_assert(can_erase_key<flat_set<int, less<int>>, int>);
+    static_assert(can_erase_key<flat_set<int, less<>>, int>);
     static_assert(can_erase_key<flat_set<int, ranges::less>, int>);
+
     // erase wrapped key_type
-    static_assert(!can_erase_key<flat_set<int, std::less<int>>, holder<int>>);
-    static_assert(can_erase_key<flat_set<int, std::less<>>, holder<int>>);
+    static_assert(!can_erase_key<flat_set<int, less<int>>, holder<int>>);
+    static_assert(can_erase_key<flat_set<int, less<>>, holder<int>>);
     static_assert(can_erase_key<flat_set<int, ranges::less>, holder<int>>);
+
     // erase wrapped iterator - the member function template returning size_type must not be selected
-    static_assert(can_erase_iterator_holder<flat_set<int, std::less<int>>>);
-    static_assert(can_erase_iterator_holder<flat_set<int, std::less<>>>);
+    static_assert(can_erase_iterator_holder<flat_set<int, less<int>>>);
+    static_assert(can_erase_iterator_holder<flat_set<int, less<>>>);
     static_assert(can_erase_iterator_holder<flat_set<int, ranges::less>>);
-} // namespace detail
-
+} // namespace test_erase_compile_time
 
 template <class C>
 void test_erase_if() {
@@ -1026,7 +1096,7 @@ void test_set_operations() {
         // flat_set:
         assert_all_requirements_and_equals(fs, {2, 3, 8, 11, 20});
 
-        assert(fs.find(3) != fs.end());
+        assert(fs.find(3) == fs.begin() + 1);
         assert(fs.find(4) == fs.end());
 
         assert(fs.count(1) == 0);
@@ -1052,7 +1122,7 @@ void test_set_operations() {
         // flat_multiset:
         assert_all_requirements_and_equals(fs, {2, 3, 3, 8, 11, 11, 11, 20});
 
-        assert(fs.find(3) != fs.end());
+        assert(fs.find(3) == fs.begin() + 1);
         assert(fs.find(4) == fs.end());
 
         assert(fs.count(1) == 0);
@@ -1086,17 +1156,26 @@ void test_set_operations_transparent() {
         }
     };
 
-    Set<int, key_comparer> fs{0, 3, 5};
+    Set<int, key_comparator> fs{0, 3, 5};
     assert_all_requirements_and_equals(fs, {0, 3, 5});
 
-    assert(fs.find(shouldnt_convert{0}) != fs.end());
+    assert(fs.find(shouldnt_convert{0}) == fs.begin());
     assert(fs.count(shouldnt_convert{3}) == 1);
     assert(!fs.contains(shouldnt_convert{1}));
     assert(fs.lower_bound(shouldnt_convert{-1}) == fs.begin());
     assert(fs.lower_bound(shouldnt_convert{8}) == fs.end());
     assert(fs.upper_bound(shouldnt_convert{2}) == fs.find(3));
-    auto [first, last] = fs.equal_range(shouldnt_convert{5});
-    assert(first + 1 == last);
+    assert(fs.equal_range(shouldnt_convert{5}) == (pair{fs.begin() + 2, fs.end()}));
+
+    // Also test const overloads:
+    const auto& cfs = fs;
+    assert(cfs.find(shouldnt_convert{0}) == cfs.begin());
+    assert(cfs.count(shouldnt_convert{3}) == 1);
+    assert(!cfs.contains(shouldnt_convert{1}));
+    assert(cfs.lower_bound(shouldnt_convert{-1}) == cfs.begin());
+    assert(cfs.lower_bound(shouldnt_convert{8}) == cfs.end());
+    assert(cfs.upper_bound(shouldnt_convert{2}) == cfs.find(3));
+    assert(cfs.equal_range(shouldnt_convert{5}) == (pair{cfs.begin() + 2, cfs.end()}));
 }
 
 namespace test_throwing_swap {
@@ -1133,6 +1212,13 @@ void test_throwing_compare_single() {
         assert(ranges::equal(s1, initializer_list<int>{4, 5, 6}));
         assert(ranges::equal(s2, initializer_list<int>{1, 2, 3}));
     }
+    {
+        set_type s1{{1, 2, 3}, comparator{false}};
+        set_type s2{{4, 5, 6}, comparator{false}};
+        swap(s1, s2);
+        assert(ranges::equal(s1, initializer_list<int>{4, 5, 6}));
+        assert(ranges::equal(s2, initializer_list<int>{1, 2, 3}));
+    }
     {
         set_type s1{{1, 2, 3}, comparator{false}};
         set_type s2{{4, 5, 6}, comparator{false}};
@@ -1153,6 +1239,19 @@ void test_throwing_compare_single() {
             assert(false);
         }
     }
+    {
+        set_type s1{{1, 2, 3}, comparator{true}};
+        set_type s2{{4, 5, 6}, comparator{false}};
+        try {
+            swap(s1, s2);
+            assert(false);
+        } catch (const unique_exception&) {
+            assert(s1.empty());
+            assert(s2.empty());
+        } catch (...) {
+            assert(false);
+        }
+    }
     {
         set_type s1{{1, 2, 3}, comparator{true}};
         set_type s2{{4, 5, 6}, comparator{false}};
@@ -1214,7 +1313,7 @@ void test_non_strict_weak_order_compare() {
         assert(first == cont.begin());
         assert(last == cont.begin() + 2);
 
-        assert(cont.end() != cont.find(strange_int{1}));
+        assert(cont.begin() + 2 == cont.find(strange_int{1}));
         assert(cont.end() == cont.find(strange_int{3}));
 
         assert(2 == cont.erase(strange_int{0}));
@@ -1234,7 +1333,7 @@ void test_non_strict_weak_order_compare() {
         assert(first == cont.begin());
         assert(last == cont.begin() + 2);
 
-        assert(cont.end() != cont.find(strange_int{1}));
+        assert(cont.begin() + 2 == cont.find(strange_int{1}));
         assert(cont.end() == cont.find(strange_int{3}));
 
         assert(2 == cont.erase(strange_int{0}));
@@ -1243,20 +1342,18 @@ void test_non_strict_weak_order_compare() {
 }
 
 void run_normal_tests() {
-    test_spaceship_operator<flat_set<int>>();
-    test_spaceship_operator<flat_multiset<int>>();
-    test_spaceship_operator<flat_set<int, std::greater<int>>>();
-    test_spaceship_operator<flat_multiset<int, std::greater<int>>>();
-    test_spaceship_operator<flat_set<int, std::less<int>, deque<int>>>();
-    test_spaceship_operator<flat_multiset<int, std::less<int>, deque<int>>>();
-    test_spaceship_operator<flat_set<int, std::greater<int>, deque<int>>>();
-    test_spaceship_operator<flat_multiset<int, std::greater<int>, deque<int>>>();
+    mt19937_64 eng(42);
 
     test_constructors<vector<int>>();
     test_constructors<deque<int>>();
     test_allocator_extended_constructors<iterator_pair_construction::no_allocator>();
     test_allocator_extended_constructors<iterator_pair_construction::with_allocator>();
 
+    test_iterators_and_capacity<flat_set<int>>();
+    test_iterators_and_capacity<flat_multiset<int>>();
+    test_iterators_and_capacity<flat_set<int, less<int>, deque<int>>>();
+    test_iterators_and_capacity<flat_multiset<int, less<int>, deque<int>>>();
+
     test_always_reversible<flat_set>();
     test_always_reversible<flat_multiset>();
 
@@ -1266,21 +1363,30 @@ void run_normal_tests() {
     test_insert_2<deque<int>>();
     test_insert_hint_is_respected<vector<int>>();
     test_insert_hint_is_respected<deque<int>>();
+    test_comparator_application();
     test_insert_transparent();
-    test_insert_using_invalid_hint();
-    test_insert_upper_bound();
+    test_insert_using_invalid_hint(eng);
+    test_insert_upper_bound(eng);
 
-    test_comparer_application();
-    test_non_static_comparer();
+    test_spaceship_operator<flat_set<int>>();
+    test_spaceship_operator<flat_multiset<int>>();
+    test_spaceship_operator<flat_set<int, greater<int>>>();
+    test_spaceship_operator<flat_multiset<int, greater<int>>>();
+    test_spaceship_operator<flat_set<int, less<int>, deque<int>>>();
+    test_spaceship_operator<flat_multiset<int, less<int>, deque<int>>>();
+    test_spaceship_operator<flat_set<int, greater<int>, deque<int>>>();
+    test_spaceship_operator<flat_multiset<int, greater<int>, deque<int>>>();
+
+    test_non_static_comparator();
 
     test_extract_1<flat_set>();
     test_extract_1<flat_multiset>();
     test_extract_2<flat_set>();
     test_extract_2<flat_multiset>();
 
+    test_invariant_robustness();
     test_erase_1();
     test_erase_2();
-    test_invariant_robustness();
 
     test_erase_if<flat_set<int>>();
     test_erase_if<flat_multiset<int>>();
@@ -1355,60 +1461,47 @@ void test_death_insert_unsorted_initializer_list() {
     cont.insert(sorted, {137, 42, 3337, 15});
 }
 
-template <cont_type type>
 void test_death_construct_duplicates_initializer_list() {
-    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    C cont(sorted, {42, 137, 137, 3337});
+    using C = flat_set<int>;
+    C cont(sorted_unique, {42, 137, 137, 3337});
 }
 
-template <cont_type type>
 void test_death_construct_duplicates_iter_iter() {
-    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    typename C::container_type values{42, 137, 137, 3337};
-    C cont(sorted, values.begin(), values.end());
+    using C = flat_set<int>;
+    C::container_type values{42, 137, 137, 3337};
+    C cont(sorted_unique, values.begin(), values.end());
 }
 
-template <cont_type type>
 void test_death_construct_duplicates_container() {
-    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    typename C::container_type values{42, 137, 137, 3337};
-    C cont(sorted, values);
+    using C = flat_set<int>;
+    C::container_type values{42, 137, 137, 3337};
+    C cont(sorted_unique, values);
 }
 
-template <cont_type type>
 void test_death_replace_duplicates_container() {
-    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
+    using C = flat_set<int>;
     C cont;
     cont.replace({42, 137, 137, 3337});
 }
 
-template <cont_type type>
 void test_death_insert_duplicates_iter_iter() {
-    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    typename C::container_type values{42, 137, 137, 3337};
+    using C = flat_set<int>;
+    C::container_type values{42, 137, 137, 3337};
     C cont;
-    cont.insert(sorted, values.begin(), values.end());
+    cont.insert(sorted_unique, values.begin(), values.end());
 }
 
-template <cont_type type>
 void test_death_insert_duplicates_range() {
-    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
-    typename C::container_type values{42, 137, 137, 3337};
+    using C = flat_set<int>;
+    C::container_type values{42, 137, 137, 3337};
     C cont;
-    cont.insert_range(sorted, values);
+    cont.insert_range(sorted_unique, values);
 }
 
-template <cont_type type>
 void test_death_insert_duplicates_initializer_list() {
-    using C = conditional_t<type == cont_type::unique, flat_set<int>, flat_multiset<int>>;
-    const conditional_t<type == cont_type::unique, sorted_unique_t, sorted_equivalent_t> sorted;
+    using C = flat_set<int>;
     C cont;
-    cont.insert(sorted, {42, 137, 137, 3337});
+    cont.insert(sorted_unique, {42, 137, 137, 3337});
 }
 
 int main(int argc, char* argv[]) {
@@ -1434,13 +1527,13 @@ int main(int argc, char* argv[]) {
         test_death_insert_unsorted_initializer_list<cont_type::multi>,
 
         // Tests shared between flat_set and flat_map - violation of unique elements
-        test_death_construct_duplicates_initializer_list<cont_type::unique>,
-        test_death_construct_duplicates_iter_iter<cont_type::unique>,
-        test_death_construct_duplicates_container<cont_type::unique>,
-        test_death_replace_duplicates_container<cont_type::unique>,
-        test_death_insert_duplicates_iter_iter<cont_type::unique>,
-        test_death_insert_duplicates_range<cont_type::unique>,
-        test_death_insert_duplicates_initializer_list<cont_type::unique>,
+        test_death_construct_duplicates_initializer_list,
+        test_death_construct_duplicates_iter_iter,
+        test_death_construct_duplicates_container,
+        test_death_replace_duplicates_container,
+        test_death_insert_duplicates_iter_iter,
+        test_death_insert_duplicates_range,
+        test_death_insert_duplicates_initializer_list,
     });
 #endif // defined(_DEBUG)
 
diff --git a/tests/std/tests/VSO_0191296_allocator_construct/test.compile.pass.cpp b/tests/std/tests/VSO_0191296_allocator_construct/test.compile.pass.cpp
index f407db63e9b..e78577b4164 100644
--- a/tests/std/tests/VSO_0191296_allocator_construct/test.compile.pass.cpp
+++ b/tests/std/tests/VSO_0191296_allocator_construct/test.compile.pass.cpp
@@ -994,7 +994,7 @@ struct check_all_optional_sequence_requirements<Tag, false> {};
 //
 //
 
-DEFINE_TEST(test_ordered_associative_default_constructor_with_comparer,
+DEFINE_TEST(test_ordered_associative_default_constructor_with_comparator,
 {
     // X(c) and X a(c);
     // Requires:  key_compare is CopyConstructible
@@ -1022,13 +1022,13 @@ DEFINE_TEST(test_ordered_associative_default_constructor_with_comparer,
 });
 
 
-DEFINE_TEST(test_ordered_associative_range_constructor_with_comparer, {
+DEFINE_TEST(test_ordered_associative_range_constructor_with_comparator, {
     // SPEC:  These are the only two operations for which traits are specified for key_compare, but
     // there are many other operations for which key_compare must meet other requirements (e.g. a
     // call to a.key_comp() necessitates that the key_comp type is move constructible.
     //
-    // In the rest of the tests, I have assumed std::less for the comparer, which meets any possible
-    // requirements, but it should be considered whether the comparer requirements should be more
+    // In the rest of the tests, I have assumed std::less for the comparator, which meets any possible
+    // requirements, but it should be considered whether the comparator requirements should be more
     // thoroughly specified.
 
     std::move_iterator<typename Traits::emplace_argument_type*> i;
@@ -1076,8 +1076,8 @@ DEFINE_TEST(test_ordered_associative_insert, {
 template <container_tag Tag, bool = (container_traits<Tag>::features & c_is_ordered_associative) != 0>
 struct check_all_ordered_associative_requirements {
     check_all_ordered_associative_requirements() {
-        test_ordered_associative_default_constructor_with_comparer<Tag>();
-        test_ordered_associative_range_constructor_with_comparer<Tag>();
+        test_ordered_associative_default_constructor_with_comparator<Tag>();
+        test_ordered_associative_range_constructor_with_comparator<Tag>();
         test_ordered_associative_emplace<Tag>();
         test_ordered_associative_insert<Tag>();
     }