From 06521626503d7e6fccbfcd1a39795f9fbe2e46f9 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Mon, 6 Nov 2023 00:46:08 +0800
Subject: [PATCH 1/6] Correct allocator-extended allocators for
 `flat_(multi)set`

---
 stl/inc/flat_set                          |  47 +++---
 tests/std/tests/P1222R4_flat_set/test.cpp | 169 ++++++++++++++++++++++
 2 files changed, 195 insertions(+), 21 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index d31bf71ce01..df55eb490c3 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -68,10 +68,12 @@ public:
     _Base_flat_set() : _Mycont(), _Mycomp() {}
 
     template <_Allocator_for<container_type> _Alloc>
-    _Base_flat_set(const _Deriv& _Set, const _Alloc& _Al) : _Mycont(_Set._Mycont, _Al), _Mycomp(_Set._Mycomp) {}
+    _Base_flat_set(const _Deriv& _Set, const _Alloc& _Al)
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _Set._Mycont)), _Mycomp(_Set._Mycomp) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Deriv&& _Set, const _Alloc& _Al)
-        : _Mycont(_STD move(_Set).extract(), _Al), _Mycomp(_Set._Mycomp) // intentionally copy comparator, see LWG-2227
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al, _STD move(_Set).extract())),
+          _Mycomp(_Set._Mycomp) // intentionally copy comparator, see LWG-2227
     {}
 
     explicit _Base_flat_set(container_type _Cont, const key_compare& _Comp = key_compare())
@@ -79,10 +81,11 @@ public:
         _Make_invariants_fulfilled();
     }
     template <_Allocator_for<container_type> _Alloc>
-    _Base_flat_set(const container_type& _Cont, const _Alloc& _Al) : _Base_flat_set(container_type(_Cont, _Al)) {}
+    _Base_flat_set(const container_type& _Cont, const _Alloc& _Al)
+        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al, _Cont)) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(container_type(_Cont, _Al), _Comp) {}
+        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al, _Cont), _Comp) {}
 
     _Base_flat_set(_Tsorted, container_type _Cont, const key_compare& _Comp = key_compare())
         : _Mycont(_STD move(_Cont)), _Mycomp(_Comp) {
@@ -90,68 +93,70 @@ public:
     }
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, const container_type& _Cont, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, container_type(_Cont, _Al)) {}
+        : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _Cont)) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, const container_type& _Cont, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, container_type(_Cont, _Al), _Comp) {}
+        : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _Cont), _Comp) {}
 
     explicit _Base_flat_set(const key_compare& _Comp) : _Mycont(), _Mycomp(_Comp) {}
     template <_Allocator_for<container_type> _Alloc>
-    _Base_flat_set(const key_compare& _Comp, const _Alloc& _Al) : _Mycont(_Al), _Mycomp(_Comp) {}
+    _Base_flat_set(const key_compare& _Comp, const _Alloc& _Al)
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp(_Comp) {}
     template <_Allocator_for<container_type> _Alloc>
-    explicit _Base_flat_set(const _Alloc& _Al) : _Mycont(_Al), _Mycomp() {}
+    explicit _Base_flat_set(const _Alloc& _Al)
+        : _Mycont(_STD make_obj_using_allocator<container_type>(_Al)), _Mycomp() {}
 
-    // FIXME, an allocator-aware container may not support "C(_First, _Last, _Al)".
     template <input_iterator _Iter>
     _Base_flat_set(_Iter _First, _Iter _Last, const key_compare& _Comp = key_compare())
         : _Base_flat_set(container_type(_First, _Last), _Comp) {}
     template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Iter _First, _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(container_type(_First, _Last, _Al), _Comp) {}
+        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last), _Comp) {}
     template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
-    _Base_flat_set(_Iter _First, _Iter _Last, const _Alloc& _Al) : _Base_flat_set(container_type(_First, _Last, _Al)) {}
+    _Base_flat_set(_Iter _First, _Iter _Last, const _Alloc& _Al)
+        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)) {}
 
-    // FIXME, an allocator-aware container may not support "C(from_range, _STD forward<_Rng>(_Range), _Al)".
     template <_Container_compatible_range<_Kty> _Rng>
     _Base_flat_set(from_range_t, _Rng&& _Range)
         : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range))) {}
     template <_Container_compatible_range<_Kty> _Rng, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(from_range_t, _Rng&& _Range, const _Alloc& _Al)
-        : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range), _Al)) {}
+        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al, from_range, _STD forward<_Rng>(_Range))) {}
     template <_Container_compatible_range<_Kty> _Rng>
     _Base_flat_set(from_range_t, _Rng&& _Range, const key_compare& _Comp)
         : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range)), _Comp) {}
     template <_Container_compatible_range<_Kty> _Rng, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(from_range_t, _Rng&& _Range, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range), _Al), _Comp) {}
+        : _Base_flat_set(
+            _STD make_obj_using_allocator<container_type>(_Al, from_range, _STD forward<_Rng>(_Range)), _Comp) {}
 
     template <input_iterator _Iter>
     _Base_flat_set(_Tsorted _Tsort, _Iter _First, _Iter _Last, const key_compare& _Comp = key_compare())
         : _Base_flat_set(_Tsort, container_type(_First, _Last), _Comp) {}
     template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, _Iter _First, _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, container_type(_First, _Last, _Al), _Comp) {}
+        : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _First, _Last), _Comp) {}
     template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, _Iter _First, _Iter _Last, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, container_type(_First, _Last, _Al)) {}
+        : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _First, _Last)) {}
 
-    // FIXME, an allocator-aware container may not support "C(_Ilist, _Al)".
     _Base_flat_set(initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
         : _Base_flat_set(container_type(_Ilist), _Comp) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(container_type(_Ilist, _Al), _Comp) {}
+        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al, _Ilist), _Comp) {}
     template <_Allocator_for<container_type> _Alloc>
-    _Base_flat_set(initializer_list<_Kty> _Ilist, const _Alloc& _Al) : _Base_flat_set(container_type(_Ilist, _Al)) {}
+    _Base_flat_set(initializer_list<_Kty> _Ilist, const _Alloc& _Al)
+        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al, _Ilist)) {}
 
     _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
         : _Base_flat_set(_Tsort, container_type(_Ilist), _Comp) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, container_type(_Ilist, _Al), _Comp) {}
+        : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _Ilist), _Comp) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, container_type(_Ilist, _Al)) {}
+        : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _Ilist)) {}
 
     _Base_flat_set(const _Base_flat_set&) = default;
     _Base_flat_set(_Base_flat_set&& _Other) noexcept(
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index e1976302b37..22512b2e659 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -11,13 +11,117 @@
 #include <iostream>
 #include <memory>
 #include <random>
+#include <ranges>
 #include <tuple>
 #include <utility>
 #include <vector>
 
+#define TEST_ASSERT(...) assert((__VA_ARGS__))
+
 using namespace std;
 using namespace ranges;
 
+template <class R, class T>
+concept container_compatible_range = input_range<R> && convertible_to<range_reference_t<R>, T>;
+
+template <class T, class Alloc = allocator<T>>
+class alternative_vector : private vector<T, Alloc> { // not allocator-aware, but can be used-allocator constructed
+private:
+    using base_type = vector<T, Alloc>;
+
+public:
+    using base_type::allocator_type;
+    using base_type::const_iterator;
+    using base_type::const_pointer;
+    using base_type::const_reference;
+    using base_type::const_reverse_iterator;
+    using base_type::difference_type;
+    using base_type::iterator;
+    using base_type::pointer;
+    using base_type::reference;
+    using base_type::reverse_iterator;
+    using base_type::size_type;
+    using base_type::value_type;
+
+    constexpr alternative_vector() noexcept(noexcept(Alloc())) : base_type(Alloc()) {}
+    constexpr explicit alternative_vector(allocator_arg_t, const Alloc& a) : base_type(a) {}
+    constexpr explicit alternative_vector(size_type n) : base_type(n) {}
+    constexpr explicit alternative_vector(allocator_arg_t, const Alloc& a, size_type n) : base_type(n, a) {}
+    constexpr alternative_vector(size_type n, const T& v) : base_type(n, v) {}
+    constexpr alternative_vector(allocator_arg_t, const Alloc& a, size_type n, const T& v) : base_type(n, v, a) {}
+    template <class InputIt>
+    constexpr alternative_vector(InputIt first, InputIt last) : base_type(first, last) {}
+    template <class InputIt>
+    constexpr alternative_vector(allocator_arg_t, const Alloc& a, InputIt first, InputIt last)
+        : base_type(first, last, a) {}
+    template <container_compatible_range<T> R>
+    constexpr alternative_vector(from_range_t, R&& rg) : base_type(from_range, forward<R>(rg)) {}
+    template <container_compatible_range<T> R>
+    constexpr alternative_vector(allocator_arg_t, const Alloc& a, from_range_t, R&& rg)
+        : base_type(from_range, forward<R>(rg), a) {}
+
+    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) {}
+    constexpr alternative_vector(initializer_list<T> il) : base_type(il) {}
+    constexpr alternative_vector(allocator_arg_t, const Alloc& a, initializer_list<T> il) : base_type(il, a) {}
+
+    alternative_vector(const alternative_vector&) = default;
+    alternative_vector(alternative_vector&&)      = default;
+
+    alternative_vector& operator=(const alternative_vector&) = default;
+    alternative_vector& operator=(alternative_vector&&)      = default;
+    constexpr alternative_vector& operator=(initializer_list<T> il) {
+        base_type::operator=(il);
+        return *this;
+    }
+
+    using base_type::assign;
+    using base_type::assign_range;
+    using base_type::get_allocator;
+
+    using base_type::begin;
+    using base_type::end;
+    using base_type::rbegin;
+    using base_type::rend;
+
+    using base_type::cbegin;
+    using base_type::cend;
+    using base_type::crbegin;
+    using base_type::crend;
+
+    using base_type::capacity;
+    using base_type::empty;
+    using base_type::max_size;
+    using base_type::reserve;
+    using base_type::resize;
+    using base_type::shrink_to_fit;
+    using base_type::size;
+
+    using base_type::operator[];
+    using base_type::at;
+    using base_type::back;
+    using base_type::front;
+
+    using base_type::data;
+
+    using base_type::append_range;
+    using base_type::emplace_back;
+    using base_type::pop_back;
+    using base_type::push_back;
+
+    using base_type::emplace;
+    using base_type::erase;
+    using base_type::insert;
+    using base_type::insert_range;
+    using base_type::swap;
+
+    using base_type::clear;
+
+    friend auto operator<=>(const alternative_vector&, const alternative_vector&) = default;
+};
+
 template <class T>
 void assert_container_requirements(const T& s) {
     T m = s;
@@ -166,6 +270,70 @@ void test_constructors() {
     assert_all_requirements_and_equals(flat_multiset<int>(std::move(b), allocator<int>{}), {-1, 1, 2, 7, 7, 7, 100});
 }
 
+void test_allocator_extended_constructors() {
+    constexpr allocator<int> ator;
+    constexpr std::less<int> comp;
+    {
+        using fs = flat_set<int, std::less<int>, alternative_vector<int>>;
+
+        fs s0{1, 1, 2, 3, 5, 8};
+        alternative_vector<int> v{1, 1, 2, 3, 5, 8};
+        alternative_vector<int> v2{1, 2, 3, 5, 8};
+
+        TEST_ASSERT(fs{comp, ator} == fs{});
+
+        TEST_ASSERT(fs{s0, ator} == s0);
+        TEST_ASSERT(fs{fs{s0}, ator} == s0);
+
+        TEST_ASSERT(fs{v, ator} == s0);
+        TEST_ASSERT(fs{{1, 1, 2, 3, 5, 8}, ator} == s0);
+        TEST_ASSERT(fs{v.begin(), v.end(), ator} == s0);
+        TEST_ASSERT(fs{from_range, v, ator} == s0);
+
+        TEST_ASSERT(fs{v, comp, ator} == s0);
+        TEST_ASSERT(fs{{1, 1, 2, 3, 5, 8}, comp, ator} == s0);
+        TEST_ASSERT(fs{v.begin(), v.end(), comp, ator} == s0);
+        TEST_ASSERT(fs{from_range, v, comp, ator} == s0);
+
+        TEST_ASSERT(fs{sorted_unique, v2, ator} == s0);
+        TEST_ASSERT(fs{sorted_unique, {1, 2, 3, 5, 8}, ator} == s0);
+        TEST_ASSERT(fs{sorted_unique, v2.begin(), v2.end(), ator} == s0);
+
+        TEST_ASSERT(fs{sorted_unique, v2, comp, ator} == s0);
+        TEST_ASSERT(fs{sorted_unique, {1, 2, 3, 5, 8}, comp, ator} == s0);
+        TEST_ASSERT(fs{sorted_unique, v2.begin(), v2.end(), comp, ator} == s0);
+    }
+    {
+        using fms = flat_multiset<int, std::less<int>, alternative_vector<int>>;
+
+        fms s0{1, 1, 2, 3, 5, 8};
+        alternative_vector<int> v{1, 1, 2, 3, 5, 8};
+
+        TEST_ASSERT(fms{comp, ator} == fms{});
+
+        TEST_ASSERT(fms{s0, ator} == s0);
+        TEST_ASSERT(fms{fms{s0}, ator} == s0);
+
+        TEST_ASSERT(fms{v, ator} == s0);
+        TEST_ASSERT(fms{{1, 1, 2, 3, 5, 8}, ator} == s0);
+        TEST_ASSERT(fms{v.begin(), v.end(), ator} == s0);
+        TEST_ASSERT(fms{from_range, v, ator} == s0);
+
+        TEST_ASSERT(fms{v, comp, ator} == s0);
+        TEST_ASSERT(fms{{1, 1, 2, 3, 5, 8}, comp, ator} == s0);
+        TEST_ASSERT(fms{v.begin(), v.end(), comp, ator} == s0);
+        TEST_ASSERT(fms{from_range, v, comp, ator} == s0);
+
+        TEST_ASSERT(fms{sorted_equivalent, v, ator} == s0);
+        TEST_ASSERT(fms{sorted_equivalent, {1, 1, 2, 3, 5, 8}, ator} == s0);
+        TEST_ASSERT(fms{sorted_equivalent, v.begin(), v.end(), ator} == s0);
+
+        TEST_ASSERT(fms{sorted_equivalent, v, comp, ator} == s0);
+        TEST_ASSERT(fms{sorted_equivalent, {1, 1, 2, 3, 5, 8}, comp, ator} == s0);
+        TEST_ASSERT(fms{sorted_equivalent, v.begin(), v.end(), comp, ator} == s0);
+    }
+}
+
 template <template <class...> class Set>
 void test_always_reversible() {
     // Test that flat_meow is unconditionally reversible.
@@ -870,6 +1038,7 @@ int main() {
 
     test_constructors<vector<int>>();
     test_constructors<deque<int>>();
+    test_allocator_extended_constructors();
 
     test_always_reversible<flat_set>();
     test_always_reversible<flat_multiset>();

From 0b76976a49b1138bef8d42ee9aa54429ae8c77f1 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Mon, 6 Nov 2023 01:24:42 +0800
Subject: [PATCH 2/6] Dependently `using` for clang

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

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 22512b2e659..973e6d52f87 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -30,18 +30,18 @@ class alternative_vector : private vector<T, Alloc> { // not allocator-aware, bu
     using base_type = vector<T, Alloc>;
 
 public:
-    using base_type::allocator_type;
-    using base_type::const_iterator;
-    using base_type::const_pointer;
-    using base_type::const_reference;
-    using base_type::const_reverse_iterator;
-    using base_type::difference_type;
-    using base_type::iterator;
-    using base_type::pointer;
-    using base_type::reference;
-    using base_type::reverse_iterator;
-    using base_type::size_type;
-    using base_type::value_type;
+    using allocator_type         = base_type::allocator_type;
+    using const_iterator         = base_type::const_iterator;
+    using const_pointer          = base_type::const_pointer;
+    using const_reference        = base_type::const_reference;
+    using const_reverse_iterator = base_type::const_reverse_iterator;
+    using difference_type        = base_type::difference_type;
+    using iterator               = base_type::iterator;
+    using pointer                = base_type::pointer;
+    using reference              = base_type::reference;
+    using reverse_iterator       = base_type::reverse_iterator;
+    using size_type              = base_type::size_type;
+    using value_type             = base_type::value_type;
 
     constexpr alternative_vector() noexcept(noexcept(Alloc())) : base_type(Alloc()) {}
     constexpr explicit alternative_vector(allocator_arg_t, const Alloc& a) : base_type(a) {}

From a9d0c5bd7ec2e3a1fd7a9e81dc81d32a7b720661 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Tue, 7 Nov 2023 00:22:30 +0800
Subject: [PATCH 3/6] Pedantic non-member `swap`

See [container.reqmts]/51.
---
 tests/std/tests/P1222R4_flat_set/test.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 973e6d52f87..ec3b05a56dd 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -120,6 +120,10 @@ class alternative_vector : private vector<T, Alloc> { // not allocator-aware, bu
     using base_type::clear;
 
     friend auto operator<=>(const alternative_vector&, const alternative_vector&) = default;
+
+    friend constexpr void swap(alternative_vector& lhs, alternative_vector& rhs) noexcept(noexcept(lhs.swap(rhs))) {
+        lhs.swap(rhs);
+    }
 };
 
 template <class T>

From 4d57ef9783469325df1ad67e20c0bbee83c94c02 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Wed, 8 Nov 2023 02:12:08 +0800
Subject: [PATCH 4/6] Tweak arguments for using-allocator construction

Per [sequence.reqmts], several constructors don't need to be implicit;

Also remove non-required allocator-extended constructors of
`alternative_vector`.
---
 stl/inc/flat_set                          | 25 +++++----
 tests/std/tests/P1222R4_flat_set/test.cpp | 64 +++++++++++++----------
 2 files changed, 51 insertions(+), 38 deletions(-)

diff --git a/stl/inc/flat_set b/stl/inc/flat_set
index df55eb490c3..52dfa2083d5 100644
--- a/stl/inc/flat_set
+++ b/stl/inc/flat_set
@@ -111,24 +111,31 @@ public:
         : _Base_flat_set(container_type(_First, _Last), _Comp) {}
     template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Iter _First, _Iter _Last, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last), _Comp) {}
+        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al), _Comp) {
+        insert(_First, _Last);
+    }
     template <input_iterator _Iter, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Iter _First, _Iter _Last, const _Alloc& _Al)
-        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al, _First, _Last)) {}
+        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al)) {
+        insert(_First, _Last);
+    }
 
     template <_Container_compatible_range<_Kty> _Rng>
     _Base_flat_set(from_range_t, _Rng&& _Range)
         : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range))) {}
     template <_Container_compatible_range<_Kty> _Rng, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(from_range_t, _Rng&& _Range, const _Alloc& _Al)
-        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al, from_range, _STD forward<_Rng>(_Range))) {}
+        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al)) {
+        insert_range(_STD forward<_Rng>(_Range));
+    }
     template <_Container_compatible_range<_Kty> _Rng>
     _Base_flat_set(from_range_t, _Rng&& _Range, const key_compare& _Comp)
         : _Base_flat_set(container_type(from_range, _STD forward<_Rng>(_Range)), _Comp) {}
     template <_Container_compatible_range<_Kty> _Rng, _Allocator_for<container_type> _Alloc>
     _Base_flat_set(from_range_t, _Rng&& _Range, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(
-            _STD make_obj_using_allocator<container_type>(_Al, from_range, _STD forward<_Rng>(_Range)), _Comp) {}
+        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al), _Comp) {
+        insert_range(_STD forward<_Rng>(_Range));
+    }
 
     template <input_iterator _Iter>
     _Base_flat_set(_Tsorted _Tsort, _Iter _First, _Iter _Last, const key_compare& _Comp = key_compare())
@@ -144,19 +151,19 @@ public:
         : _Base_flat_set(container_type(_Ilist), _Comp) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al, _Ilist), _Comp) {}
+        : _Base_flat_set(_Ilist.begin(), _Ilist.end(), _Comp, _Al) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(initializer_list<_Kty> _Ilist, const _Alloc& _Al)
-        : _Base_flat_set(_STD make_obj_using_allocator<container_type>(_Al, _Ilist)) {}
+        : _Base_flat_set(_Ilist.begin(), _Ilist.end(), _Al) {}
 
     _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const key_compare& _Comp = key_compare())
         : _Base_flat_set(_Tsort, container_type(_Ilist), _Comp) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const key_compare& _Comp, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _Ilist), _Comp) {}
+        : _Base_flat_set(_Tsort, _Ilist.begin(), _Ilist.end(), _Comp, _Al) {}
     template <_Allocator_for<container_type> _Alloc>
     _Base_flat_set(_Tsorted _Tsort, initializer_list<_Kty> _Ilist, const _Alloc& _Al)
-        : _Base_flat_set(_Tsort, _STD make_obj_using_allocator<container_type>(_Al, _Ilist)) {}
+        : _Base_flat_set(_Tsort, _Ilist.begin(), _Ilist.end(), _Al) {}
 
     _Base_flat_set(const _Base_flat_set&) = default;
     _Base_flat_set(_Base_flat_set&& _Other) noexcept(
diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index ec3b05a56dd..6f448dde664 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -21,10 +21,13 @@
 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>;
 
-template <class T, class Alloc = allocator<T>>
+template <class T, class Alloc = allocator<T>,
+    iterator_pair_construction Choice = iterator_pair_construction::with_allocator>
 class alternative_vector : private vector<T, Alloc> { // not allocator-aware, but can be used-allocator constructed
 private:
     using base_type = vector<T, Alloc>;
@@ -44,28 +47,24 @@ class alternative_vector : private vector<T, Alloc> { // not allocator-aware, bu
     using value_type             = base_type::value_type;
 
     constexpr alternative_vector() noexcept(noexcept(Alloc())) : base_type(Alloc()) {}
-    constexpr explicit alternative_vector(allocator_arg_t, const Alloc& a) : base_type(a) {}
+    constexpr alternative_vector(allocator_arg_t, const Alloc& a) : base_type(a) {}
     constexpr explicit alternative_vector(size_type n) : base_type(n) {}
-    constexpr explicit alternative_vector(allocator_arg_t, const Alloc& a, size_type n) : base_type(n, a) {}
-    constexpr alternative_vector(size_type n, const T& v) : base_type(n, v) {}
-    constexpr alternative_vector(allocator_arg_t, const Alloc& a, size_type n, const T& v) : base_type(n, v, a) {}
+    constexpr explicit alternative_vector(size_type n, const T& v) : base_type(n, v) {}
     template <class InputIt>
-    constexpr alternative_vector(InputIt first, InputIt last) : base_type(first, last) {}
+    constexpr explicit alternative_vector(InputIt first, InputIt last) : base_type(first, last) {}
     template <class InputIt>
-    constexpr alternative_vector(allocator_arg_t, const Alloc& a, InputIt first, InputIt last)
+        requires (Choice == iterator_pair_construction::with_allocator)
+    constexpr explicit alternative_vector(allocator_arg_t, const Alloc& a, InputIt first, InputIt last)
         : base_type(first, last, a) {}
+
     template <container_compatible_range<T> R>
-    constexpr alternative_vector(from_range_t, R&& rg) : base_type(from_range, forward<R>(rg)) {}
-    template <container_compatible_range<T> R>
-    constexpr alternative_vector(allocator_arg_t, const Alloc& a, from_range_t, R&& rg)
-        : base_type(from_range, forward<R>(rg), a) {}
+    constexpr explicit alternative_vector(from_range_t, R&& rg) : base_type(from_range, forward<R>(rg)) {}
 
     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) {}
-    constexpr alternative_vector(initializer_list<T> il) : base_type(il) {}
-    constexpr alternative_vector(allocator_arg_t, const Alloc& a, initializer_list<T> il) : base_type(il, a) {}
+    constexpr explicit alternative_vector(initializer_list<T> il) : base_type(il) {}
 
     alternative_vector(const alternative_vector&) = default;
     alternative_vector(alternative_vector&&)      = default;
@@ -274,15 +273,17 @@ void test_constructors() {
     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;
     {
-        using fs = flat_set<int, std::less<int>, alternative_vector<int>>;
+        using fs = flat_set<int, std::less<int>, vec>;
 
         fs s0{1, 1, 2, 3, 5, 8};
-        alternative_vector<int> v{1, 1, 2, 3, 5, 8};
-        alternative_vector<int> v2{1, 2, 3, 5, 8};
+        vec v{1, 1, 2, 3, 5, 8};
+        vec v2{1, 2, 3, 5, 8};
 
         TEST_ASSERT(fs{comp, ator} == fs{});
 
@@ -300,18 +301,20 @@ void test_allocator_extended_constructors() {
         TEST_ASSERT(fs{from_range, v, comp, ator} == s0);
 
         TEST_ASSERT(fs{sorted_unique, v2, ator} == s0);
-        TEST_ASSERT(fs{sorted_unique, {1, 2, 3, 5, 8}, ator} == s0);
-        TEST_ASSERT(fs{sorted_unique, v2.begin(), v2.end(), ator} == s0);
-
         TEST_ASSERT(fs{sorted_unique, v2, comp, ator} == s0);
-        TEST_ASSERT(fs{sorted_unique, {1, 2, 3, 5, 8}, comp, ator} == s0);
-        TEST_ASSERT(fs{sorted_unique, v2.begin(), v2.end(), comp, ator} == s0);
+        if constexpr (Choice == iterator_pair_construction::with_allocator) {
+            TEST_ASSERT(fs{sorted_unique, {1, 2, 3, 5, 8}, ator} == s0);
+            TEST_ASSERT(fs{sorted_unique, {1, 2, 3, 5, 8}, comp, ator} == s0);
+
+            TEST_ASSERT(fs{sorted_unique, v2.begin(), v2.end(), ator} == s0);
+            TEST_ASSERT(fs{sorted_unique, v2.begin(), v2.end(), comp, ator} == s0);
+        }
     }
     {
-        using fms = flat_multiset<int, std::less<int>, alternative_vector<int>>;
+        using fms = flat_multiset<int, std::less<int>, vec>;
 
         fms s0{1, 1, 2, 3, 5, 8};
-        alternative_vector<int> v{1, 1, 2, 3, 5, 8};
+        vec v{1, 1, 2, 3, 5, 8};
 
         TEST_ASSERT(fms{comp, ator} == fms{});
 
@@ -329,12 +332,14 @@ void test_allocator_extended_constructors() {
         TEST_ASSERT(fms{from_range, v, comp, ator} == s0);
 
         TEST_ASSERT(fms{sorted_equivalent, v, ator} == s0);
-        TEST_ASSERT(fms{sorted_equivalent, {1, 1, 2, 3, 5, 8}, ator} == s0);
-        TEST_ASSERT(fms{sorted_equivalent, v.begin(), v.end(), ator} == s0);
-
         TEST_ASSERT(fms{sorted_equivalent, v, comp, ator} == s0);
-        TEST_ASSERT(fms{sorted_equivalent, {1, 1, 2, 3, 5, 8}, comp, ator} == s0);
-        TEST_ASSERT(fms{sorted_equivalent, v.begin(), v.end(), comp, ator} == s0);
+        if constexpr (Choice == iterator_pair_construction::with_allocator) {
+            TEST_ASSERT(fms{sorted_equivalent, {1, 1, 2, 3, 5, 8}, ator} == s0);
+            TEST_ASSERT(fms{sorted_equivalent, {1, 1, 2, 3, 5, 8}, comp, ator} == s0);
+
+            TEST_ASSERT(fms{sorted_equivalent, v.begin(), v.end(), ator} == s0);
+            TEST_ASSERT(fms{sorted_equivalent, v.begin(), v.end(), comp, ator} == s0);
+        }
     }
 }
 
@@ -1042,7 +1047,8 @@ int main() {
 
     test_constructors<vector<int>>();
     test_constructors<deque<int>>();
-    test_allocator_extended_constructors();
+    test_allocator_extended_constructors<iterator_pair_construction::no_allocator>();
+    test_allocator_extended_constructors<iterator_pair_construction::with_allocator>();
 
     test_always_reversible<flat_set>();
     test_always_reversible<flat_multiset>();

From e3127f4063a5cb828facbd648cc1d52c6b40f678 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Fri, 10 Nov 2023 01:45:06 +0800
Subject: [PATCH 5/6] Address @StephanTLavavej's review comments

---
 tests/std/tests/P1222R4_flat_set/test.cpp | 107 ++++++++++++----------
 1 file changed, 57 insertions(+), 50 deletions(-)

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index 6f448dde664..ae41eebc407 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -13,6 +13,7 @@
 #include <random>
 #include <ranges>
 #include <tuple>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -28,23 +29,23 @@ concept container_compatible_range = input_range<R> && convertible_to<range_refe
 
 template <class T, class Alloc = allocator<T>,
     iterator_pair_construction Choice = iterator_pair_construction::with_allocator>
-class alternative_vector : private vector<T, Alloc> { // not allocator-aware, but can be used-allocator constructed
+class alternative_vector : private vector<T, Alloc> { // not allocator-aware, but can be uses-allocator constructed
 private:
     using base_type = vector<T, Alloc>;
 
 public:
-    using allocator_type         = base_type::allocator_type;
-    using const_iterator         = base_type::const_iterator;
-    using const_pointer          = base_type::const_pointer;
-    using const_reference        = base_type::const_reference;
-    using const_reverse_iterator = base_type::const_reverse_iterator;
-    using difference_type        = base_type::difference_type;
-    using iterator               = base_type::iterator;
-    using pointer                = base_type::pointer;
-    using reference              = base_type::reference;
-    using reverse_iterator       = base_type::reverse_iterator;
-    using size_type              = base_type::size_type;
-    using value_type             = base_type::value_type;
+    using typename base_type::allocator_type;
+    using typename base_type::const_iterator;
+    using typename base_type::const_pointer;
+    using typename base_type::const_reference;
+    using typename base_type::const_reverse_iterator;
+    using typename base_type::difference_type;
+    using typename base_type::iterator;
+    using typename base_type::pointer;
+    using typename base_type::reference;
+    using typename base_type::reverse_iterator;
+    using typename base_type::size_type;
+    using typename base_type::value_type;
 
     constexpr alternative_vector() noexcept(noexcept(Alloc())) : base_type(Alloc()) {}
     constexpr alternative_vector(allocator_arg_t, const Alloc& a) : base_type(a) {}
@@ -281,64 +282,70 @@ void test_allocator_extended_constructors() {
     {
         using fs = flat_set<int, std::less<int>, vec>;
 
-        fs s0{1, 1, 2, 3, 5, 8};
-        vec v{1, 1, 2, 3, 5, 8};
-        vec v2{1, 2, 3, 5, 8};
+        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{comp, ator} == fs{});
 
-        TEST_ASSERT(fs{s0, ator} == s0);
-        TEST_ASSERT(fs{fs{s0}, ator} == s0);
+        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{fs{s_expected}, ator} == s_expected);
 
-        TEST_ASSERT(fs{v, ator} == s0);
-        TEST_ASSERT(fs{{1, 1, 2, 3, 5, 8}, ator} == s0);
-        TEST_ASSERT(fs{v.begin(), v.end(), ator} == s0);
-        TEST_ASSERT(fs{from_range, v, ator} == s0);
+        TEST_ASSERT(fs{v_raw, ator} == s_expected);
+        TEST_ASSERT(fs{{3, 7, 1, 85, 222, 1}, ator} == s_expected);
+        TEST_ASSERT(fs{v_raw.begin(), v_raw.end(), ator} == s_expected);
+        TEST_ASSERT(fs{from_range, v_raw, ator} == s_expected);
 
-        TEST_ASSERT(fs{v, comp, ator} == s0);
-        TEST_ASSERT(fs{{1, 1, 2, 3, 5, 8}, comp, ator} == s0);
-        TEST_ASSERT(fs{v.begin(), v.end(), comp, ator} == s0);
-        TEST_ASSERT(fs{from_range, v, comp, ator} == s0);
+        TEST_ASSERT(fs{v_raw, comp, ator} == s_expected);
+        TEST_ASSERT(fs{{3, 7, 1, 85, 222, 1}, comp, ator} == s_expected);
+        TEST_ASSERT(fs{v_raw.begin(), v_raw.end(), comp, ator} == s_expected);
+        TEST_ASSERT(fs{from_range, v_raw, comp, ator} == s_expected);
 
-        TEST_ASSERT(fs{sorted_unique, v2, ator} == s0);
-        TEST_ASSERT(fs{sorted_unique, v2, comp, ator} == s0);
+        TEST_ASSERT(fs{sorted_unique, v_sorted_unique, ator} == s_expected);
+        TEST_ASSERT(fs{sorted_unique, v_sorted_unique, comp, ator} == s_expected);
         if constexpr (Choice == iterator_pair_construction::with_allocator) {
-            TEST_ASSERT(fs{sorted_unique, {1, 2, 3, 5, 8}, ator} == s0);
-            TEST_ASSERT(fs{sorted_unique, {1, 2, 3, 5, 8}, comp, ator} == s0);
+            TEST_ASSERT(fs{sorted_unique, {1, 3, 7, 85, 222}, ator} == s_expected);
+            TEST_ASSERT(fs{sorted_unique, {1, 3, 7, 85, 222}, comp, ator} == s_expected);
 
-            TEST_ASSERT(fs{sorted_unique, v2.begin(), v2.end(), ator} == s0);
-            TEST_ASSERT(fs{sorted_unique, v2.begin(), v2.end(), comp, ator} == s0);
+            TEST_ASSERT(fs{sorted_unique, v_sorted_unique.begin(), v_sorted_unique.end(), ator} == s_expected);
+            TEST_ASSERT(fs{sorted_unique, v_sorted_unique.begin(), v_sorted_unique.end(), comp, ator} == s_expected);
         }
     }
     {
         using fms = flat_multiset<int, std::less<int>, vec>;
 
-        fms s0{1, 1, 2, 3, 5, 8};
-        vec v{1, 1, 2, 3, 5, 8};
+        fms s{3, 7, 1, 85, 222, 1};
+        fms s_expected{1, 1, 3, 7, 85, 222};
+        vec v_sorted_eq{1, 1, 3, 7, 85, 222};
 
         TEST_ASSERT(fms{comp, ator} == fms{});
 
-        TEST_ASSERT(fms{s0, ator} == s0);
-        TEST_ASSERT(fms{fms{s0}, ator} == s0);
+        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{fms{s_expected}, ator} == s_expected);
 
-        TEST_ASSERT(fms{v, ator} == s0);
-        TEST_ASSERT(fms{{1, 1, 2, 3, 5, 8}, ator} == s0);
-        TEST_ASSERT(fms{v.begin(), v.end(), ator} == s0);
-        TEST_ASSERT(fms{from_range, v, ator} == s0);
+        TEST_ASSERT(fms{v_sorted_eq, ator} == s_expected);
+        TEST_ASSERT(fms{{3, 7, 1, 85, 222, 1}, ator} == s_expected);
+        TEST_ASSERT(fms{v_sorted_eq.begin(), v_sorted_eq.end(), ator} == s_expected);
+        TEST_ASSERT(fms{from_range, v_sorted_eq, ator} == s_expected);
 
-        TEST_ASSERT(fms{v, comp, ator} == s0);
-        TEST_ASSERT(fms{{1, 1, 2, 3, 5, 8}, comp, ator} == s0);
-        TEST_ASSERT(fms{v.begin(), v.end(), comp, ator} == s0);
-        TEST_ASSERT(fms{from_range, v, comp, ator} == s0);
+        TEST_ASSERT(fms{v_sorted_eq, comp, ator} == s_expected);
+        TEST_ASSERT(fms{{3, 7, 1, 85, 222, 1}, comp, ator} == s_expected);
+        TEST_ASSERT(fms{v_sorted_eq.begin(), v_sorted_eq.end(), comp, ator} == s_expected);
+        TEST_ASSERT(fms{from_range, v_sorted_eq, comp, ator} == s_expected);
 
-        TEST_ASSERT(fms{sorted_equivalent, v, ator} == s0);
-        TEST_ASSERT(fms{sorted_equivalent, v, comp, ator} == s0);
+        TEST_ASSERT(fms{sorted_equivalent, v_sorted_eq, ator} == s_expected);
+        TEST_ASSERT(fms{sorted_equivalent, v_sorted_eq, comp, ator} == s_expected);
         if constexpr (Choice == iterator_pair_construction::with_allocator) {
-            TEST_ASSERT(fms{sorted_equivalent, {1, 1, 2, 3, 5, 8}, ator} == s0);
-            TEST_ASSERT(fms{sorted_equivalent, {1, 1, 2, 3, 5, 8}, comp, ator} == s0);
+            TEST_ASSERT(fms{sorted_equivalent, {1, 1, 3, 7, 85, 222}, ator} == s_expected);
+            TEST_ASSERT(fms{sorted_equivalent, {1, 1, 3, 7, 85, 222}, comp, ator} == s_expected);
 
-            TEST_ASSERT(fms{sorted_equivalent, v.begin(), v.end(), ator} == s0);
-            TEST_ASSERT(fms{sorted_equivalent, v.begin(), v.end(), comp, ator} == s0);
+            TEST_ASSERT(fms{sorted_equivalent, v_sorted_eq.begin(), v_sorted_eq.end(), ator} == s_expected);
+            TEST_ASSERT(fms{sorted_equivalent, v_sorted_eq.begin(), v_sorted_eq.end(), comp, ator} == s_expected);
         }
     }
 }

From 800813bfe1a7c2dbac282205b513daf165c6a8dc Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Fri, 10 Nov 2023 10:31:43 -0800
Subject: [PATCH 6/6] Add `v_raw` coverage to `flat_multiset`.

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

diff --git a/tests/std/tests/P1222R4_flat_set/test.cpp b/tests/std/tests/P1222R4_flat_set/test.cpp
index ae41eebc407..1eefde7bdf3 100644
--- a/tests/std/tests/P1222R4_flat_set/test.cpp
+++ b/tests/std/tests/P1222R4_flat_set/test.cpp
@@ -319,6 +319,7 @@ void test_allocator_extended_constructors() {
 
         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{comp, ator} == fms{});
@@ -328,15 +329,15 @@ void test_allocator_extended_constructors() {
         TEST_ASSERT(fms{std::move(s), ator} == s_expected);
         TEST_ASSERT(fms{fms{s_expected}, ator} == s_expected);
 
-        TEST_ASSERT(fms{v_sorted_eq, ator} == s_expected);
+        TEST_ASSERT(fms{v_raw, ator} == s_expected);
         TEST_ASSERT(fms{{3, 7, 1, 85, 222, 1}, ator} == s_expected);
-        TEST_ASSERT(fms{v_sorted_eq.begin(), v_sorted_eq.end(), ator} == s_expected);
-        TEST_ASSERT(fms{from_range, v_sorted_eq, ator} == s_expected);
+        TEST_ASSERT(fms{v_raw.begin(), v_raw.end(), ator} == s_expected);
+        TEST_ASSERT(fms{from_range, v_raw, ator} == s_expected);
 
-        TEST_ASSERT(fms{v_sorted_eq, comp, ator} == s_expected);
+        TEST_ASSERT(fms{v_raw, comp, ator} == s_expected);
         TEST_ASSERT(fms{{3, 7, 1, 85, 222, 1}, comp, ator} == s_expected);
-        TEST_ASSERT(fms{v_sorted_eq.begin(), v_sorted_eq.end(), comp, ator} == s_expected);
-        TEST_ASSERT(fms{from_range, v_sorted_eq, comp, ator} == s_expected);
+        TEST_ASSERT(fms{v_raw.begin(), v_raw.end(), comp, ator} == s_expected);
+        TEST_ASSERT(fms{from_range, v_raw, comp, ator} == s_expected);
 
         TEST_ASSERT(fms{sorted_equivalent, v_sorted_eq, ator} == s_expected);
         TEST_ASSERT(fms{sorted_equivalent, v_sorted_eq, comp, ator} == s_expected);